diff --git a/deps/saucer/include/glaze/api/api.hpp b/deps/saucer/include/glaze/api/api.hpp
index b7ce73e..1e6690f 100644
--- a/deps/saucer/include/glaze/api/api.hpp
+++ b/deps/saucer/include/glaze/api/api.hpp
@@ -100,7 +100,7 @@ namespace glz
 
          auto tuple_args = std::forward_as_tuple(std::forward<Args>(args)...);
 
-         for_each<N>([&](auto I) { std::get<I>(arguments) = &std::get<I>(tuple_args); });
+         for_each<N>([&]<auto I>() { std::get<I>(arguments) = &std::get<I>(tuple_args); });
 
          if constexpr (std::is_pointer_v<Ret>) {
             void* ptr{};
diff --git a/deps/saucer/include/glaze/api/hash.hpp b/deps/saucer/include/glaze/api/hash.hpp
index c34f02d..09c220c 100644
--- a/deps/saucer/include/glaze/api/hash.hpp
+++ b/deps/saucer/include/glaze/api/hash.hpp
@@ -77,10 +77,6 @@ namespace glz
          static constexpr type value{};
          static constexpr const std::string_view get() { return {value.data, num_digits(x)}; }
       };
-
-      /* instantiate numeric_string::value as needed for different numbers */
-      template <uint64_t x>
-      constexpr typename numeric_string<x>::type numeric_string<x>::value;
    }
 
    template <class T, T Value>
diff --git a/deps/saucer/include/glaze/api/impl.hpp b/deps/saucer/include/glaze/api/impl.hpp
index 4f4ab21..1422f17 100644
--- a/deps/saucer/include/glaze/api/impl.hpp
+++ b/deps/saucer/include/glaze/api/impl.hpp
@@ -19,8 +19,8 @@
 #include "glaze/api/std/vector.hpp"
 #include "glaze/api/tuplet.hpp"
 #include "glaze/api/type_support.hpp"
-#include "glaze/binary/read.hpp"
-#include "glaze/binary/write.hpp"
+#include "glaze/beve/read.hpp"
+#include "glaze/beve/write.hpp"
 #include "glaze/glaze.hpp"
 #include "glaze/json/read.hpp"
 #include "glaze/json/write.hpp"
@@ -36,7 +36,7 @@ namespace glz
 
       [[nodiscard]] bool contains(const sv path) noexcept override
       {
-         return detail::seek_impl([&](auto&&) {}, user, path);
+         return seek([&](auto&&) {}, user, path);
       }
 
       bool read(const uint32_t format, const sv path, const sv data) noexcept override
@@ -44,12 +44,11 @@ namespace glz
          error_ctx pe{};
          bool success;
 
-         if (format == json) {
-            success = detail::seek_impl([&](auto&& val) { pe = glz::read<opts{}>(val, data); }, user, path);
+         if (format == JSON) {
+            success = seek([&](auto&& val) { pe = glz::read<opts{}>(val, data); }, user, path);
          }
          else {
-            success =
-               detail::seek_impl([&](auto&& val) { pe = glz::read<opts{.format = binary}>(val, data); }, user, path);
+            success = seek([&](auto&& val) { pe = glz::read<opts{.format = BEVE}>(val, data); }, user, path);
          }
 
          if (success) {
@@ -64,11 +63,11 @@ namespace glz
       bool write(const uint32_t format, const sv path, std::string& data) noexcept override
       {
          // TODO: Support write errors when seeking
-         if (format == json) {
-            return detail::seek_impl([&](auto&& val) { std::ignore = glz::write_json(val, data); }, user, path);
+         if (format == JSON) {
+            return seek([&](auto&& val) { std::ignore = glz::write_json(val, data); }, user, path);
          }
          else {
-            return detail::seek_impl([&](auto&& val) { std::ignore = glz::write_binary(val, data); }, user, path);
+            return seek([&](auto&& val) { std::ignore = glz::write_beve(val, data); }, user, path);
          }
       }
 
@@ -106,11 +105,11 @@ namespace glz
 
          bool found = false;
 
-         detail::seek_impl(
+         seek(
             [&](auto&& parent) {
                using P = std::decay_t<decltype(parent)>;
 
-               detail::seek_impl(
+               seek(
                   [&](auto&& val) {
                      using V = std::decay_t<decltype(val)>;
                      if constexpr (std::is_member_function_pointer_v<V>) {
@@ -174,7 +173,7 @@ namespace glz
       decltype(auto) unwrap(T&& val)
       {
          using V = std::decay_t<T>;
-         if constexpr (detail::nullable_t<V>) {
+         if constexpr (nullable_t<V>) {
             if (val) {
                return unwrap(*val);
             }
@@ -197,7 +196,7 @@ namespace glz
 
          glz::hash_t type_hash{};
 
-         const auto success = detail::seek_impl(
+         const auto success = seek(
             [&](auto&& val) {
                using V = std::decay_t<decltype(*unwrap(val))>;
                if constexpr (std::is_member_function_pointer_v<V>) {
@@ -231,11 +230,11 @@ namespace glz
          const auto parent_ptr = p.first;
          const auto last_ptr = p.second;
 
-         detail::seek_impl(
+         seek(
             [&](auto&& parent) {
                using P = std::decay_t<decltype(parent)>;
 
-               detail::seek_impl(
+               seek(
                   [&](auto&& val) {
                      using V = std::decay_t<decltype(val)>;
                      if constexpr (std::is_member_function_pointer_v<V>) {
@@ -303,7 +302,7 @@ namespace glz
          using T = std::tuple<Args...>;
 
          constexpr auto N = sizeof...(Args);
-         for_each<N>([&](auto I) {
+         for_each<N>([&]<auto I>() {
             using V = glz::tuple_element_t<I, T>;
             ptr->emplace(name_v<V>, make_api<V>);
          });
diff --git a/deps/saucer/include/glaze/api/lib.hpp b/deps/saucer/include/glaze/api/lib.hpp
index b966ad8..b783957 100644
--- a/deps/saucer/include/glaze/api/lib.hpp
+++ b/deps/saucer/include/glaze/api/lib.hpp
@@ -45,7 +45,7 @@ namespace glz
 
    struct lib_loader final
    {
-      using create = glz::iface_fn (*)(void);
+      using create = glz::iface_fn (*)(void) noexcept;
 
       iface api_map{};
       std::vector<lib_t> loaded_libs{};
diff --git a/deps/saucer/include/glaze/api/trait.hpp b/deps/saucer/include/glaze/api/trait.hpp
index f766414..8cd1da1 100644
--- a/deps/saucer/include/glaze/api/trait.hpp
+++ b/deps/saucer/include/glaze/api/trait.hpp
@@ -8,6 +8,7 @@
 #include "glaze/api/hash.hpp"
 #include "glaze/core/common.hpp"
 #include "glaze/core/meta.hpp"
+#include "glaze/core/reflect.hpp"
 #include "glaze/util/string_literal.hpp"
 
 namespace glz
@@ -21,9 +22,9 @@ namespace glz
 
       static constexpr sv type_size_hash = hash128_v<int_to_sv_v<size_t, sizeof(T)>>; // must hash for consistent length
 
-      static constexpr sv major_version = hash128_i_v<version<T>[0]>; // must hash for consistent length
-      static constexpr sv minor_version = hash128_i_v<version<T>[1]>; // must hash for consistent length
-      static constexpr sv revision = hash128_i_v<version<T>[2]>; // must hash for consistent length
+      static constexpr sv major_version = hash128_i_v<version_v<T>.major>; // must hash for consistent length
+      static constexpr sv minor_version = hash128_i_v<version_v<T>.minor>; // must hash for consistent length
+      static constexpr sv revision = hash128_i_v<version_v<T>.patch>; // must hash for consistent length
 
 #define std_trait(x) static constexpr sv x = to_sv<std::x##_v<T>>()
       std_trait(is_trivial);
@@ -50,8 +51,6 @@ namespace glz
       std_trait(is_aggregate);
 #undef std_trait
 
-      // static constexpr sv cplusplus = empty_if<std::is_standard_layout_v<T>>(to_sv<__cplusplus>());
-
 #ifdef __clang__
       static constexpr sv clang = "clang";
 #endif
@@ -64,7 +63,14 @@ namespace glz
 
       static constexpr sv blank = ""; // to end possible macros
 
-      static constexpr sv members = glz::name_v<glz::detail::member_tuple_t<T>>;
+      static constexpr sv members = [] {
+         if constexpr (glaze_object_t<T> || reflectable<T>) {
+            return glz::name_v<detail::member_tuple_t<T>>;
+         }
+         else {
+            return "";
+         }
+      }();
 
       static constexpr sv to_hash =
          join_v<type_name_hash,
@@ -106,7 +112,7 @@ namespace glz
 
      public:
       static constexpr sv version_sv = join_v<v, major_version, comma, minor_version, comma, revision>;
-      static constexpr version_t version = ::glz::version<T>;
+      static constexpr version_t version = ::glz::version_v<T>;
 
       static constexpr sv hash = hash128_v<to_hash>;
    };
diff --git a/deps/saucer/include/glaze/api/tuplet.hpp b/deps/saucer/include/glaze/api/tuplet.hpp
index 8c798a2..4f6d37f 100644
--- a/deps/saucer/include/glaze/api/tuplet.hpp
+++ b/deps/saucer/include/glaze/api/tuplet.hpp
@@ -9,10 +9,10 @@
 namespace glz
 {
    template <class... T>
-   struct meta<glz::tuplet::tuple<T...>>
+   struct meta<glz::tuple<T...>>
    {
       static constexpr std::string_view name = []<size_t... I>(std::index_sequence<I...>) {
-         return join_v<chars<"glz::tuplet::tuple<">,
+         return join_v<chars<"glz::tuple<">,
                        ((I != sizeof...(T) - 1) ? join_v<name_v<T>, chars<",">> : join_v<name_v<T>>)..., chars<">">>;
       }(std::make_index_sequence<sizeof...(T)>{});
    };
diff --git a/deps/saucer/include/glaze/base64/base64.hpp b/deps/saucer/include/glaze/base64/base64.hpp
new file mode 100644
index 0000000..e707b7f
--- /dev/null
+++ b/deps/saucer/include/glaze/base64/base64.hpp
@@ -0,0 +1,65 @@
+// Glaze Library
+// For the license information refer to glaze.hpp
+
+#pragma once
+
+#include <array>
+#include <string>
+#include <string_view>
+#include <vector>
+
+namespace glz
+{
+   inline constexpr std::string_view base64_chars =
+      "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+      "abcdefghijklmnopqrstuvwxyz"
+      "0123456789+/";
+
+   inline std::string read_base64(const std::string_view input)
+   {
+      std::string decoded_data;
+      static constexpr std::array<int, 256> decode_table = [] {
+         std::array<int, 256> t;
+         t.fill(-1);
+         for (int i = 0; i < 64; ++i) {
+            t[base64_chars[i]] = i;
+         }
+         return t;
+      }();
+
+      int val = 0, valb = -8;
+      for (unsigned char c : input) {
+         if (decode_table[c] == -1) break; // Stop decoding at padding '=' or invalid characters
+         val = (val << 6) + decode_table[c];
+         valb += 6;
+         if (valb >= 0) {
+            decoded_data.push_back((val >> valb) & 0xFF);
+            valb -= 8;
+         }
+      }
+
+      return decoded_data;
+   }
+
+   inline std::string write_base64(const std::string_view input)
+   {
+      std::string encoded_data;
+
+      int val = 0, valb = -6;
+      for (unsigned char c : input) {
+         val = (val << 8) + c;
+         valb += 8;
+         while (valb >= 0) {
+            encoded_data.push_back(base64_chars[(val >> valb) & 0x3F]);
+            valb -= 6;
+         }
+      }
+      if (valb > -6) {
+         encoded_data.push_back(base64_chars[((val << 8) >> (valb + 8)) & 0x3F]);
+      }
+      while (encoded_data.size() % 4) {
+         encoded_data.push_back('=');
+      }
+      return encoded_data;
+   }
+}
diff --git a/deps/saucer/include/glaze/beve.hpp b/deps/saucer/include/glaze/beve.hpp
new file mode 100644
index 0000000..1b8d063
--- /dev/null
+++ b/deps/saucer/include/glaze/beve.hpp
@@ -0,0 +1,11 @@
+// Glaze Library
+// For the license information refer to glaze.hpp
+
+#pragma once
+
+#include "glaze/beve/header.hpp"
+#include "glaze/beve/ptr.hpp"
+#include "glaze/beve/read.hpp"
+#include "glaze/beve/wrappers.hpp"
+#include "glaze/beve/write.hpp"
+#include "glaze/thread/atomic.hpp"
diff --git a/deps/saucer/include/glaze/binary/beve_to_json.hpp b/deps/saucer/include/glaze/beve/beve_to_json.hpp
similarity index 68%
rename from deps/saucer/include/glaze/binary/beve_to_json.hpp
rename to deps/saucer/include/glaze/beve/beve_to_json.hpp
index 79f0326..22f571d 100644
--- a/deps/saucer/include/glaze/binary/beve_to_json.hpp
+++ b/deps/saucer/include/glaze/beve/beve_to_json.hpp
@@ -3,22 +3,26 @@
 
 #pragma once
 
-#include "glaze/binary/header.hpp"
+#include "glaze/beve/header.hpp"
 #include "glaze/json/write.hpp"
 
 namespace glz
 {
    namespace detail
    {
-      template <opts Opts>
-      inline void beve_to_json_number(auto&& tag, auto&& ctx, auto&& it, auto&&, auto& out, auto&& ix) noexcept
+      template <auto Opts>
+      inline void beve_to_json_number(auto&& tag, auto&& ctx, auto&& it, auto&& end, auto& out, auto&& ix) noexcept
       {
          const auto number_type = (tag & 0b000'11'000) >> 3;
-         const uint8_t byte_count = detail::byte_count_lookup[tag >> 5];
+         const uint8_t byte_count = byte_count_lookup[tag >> 5];
 
          auto write_number = [&]<class T>(T&& value) {
+            if ((it + sizeof(T)) > end) [[unlikely]] {
+               ctx.error = error_code::syntax_error;
+               return;
+            }
             std::memcpy(&value, it, sizeof(T));
-            to_json<T>::template op<Opts>(value, ctx, out, ix);
+            to<JSON, T>::template op<Opts>(value, ctx, out, ix);
             it += sizeof(T);
          };
 
@@ -100,9 +104,20 @@ namespace glz
          }
       }
 
-      template <glz::opts Opts, class Buffer>
-      inline void beve_to_json_value(auto&& ctx, auto&& it, auto&& end, Buffer& out, auto&& ix) noexcept
+      template <auto Opts, class Buffer>
+      inline void beve_to_json_value(auto&& ctx, auto&& it, auto&& end, Buffer& out, auto&& ix,
+                                     uint32_t recursive_depth)
       {
+         // Check recursion depth limit
+         if (recursive_depth >= max_recursive_depth_limit) [[unlikely]] {
+            ctx.error = error_code::exceeded_max_recursive_depth;
+            return;
+         }
+
+         if (it >= end) [[unlikely]] {
+            ctx.error = error_code::syntax_error;
+            return;
+         }
          const auto tag = uint8_t(*it);
          const auto type = tag & 0b00000'111;
          switch (type) {
@@ -129,9 +144,16 @@ namespace glz
          }
          case tag::string: {
             ++it;
-            const auto n = detail::int_from_compressed(ctx, it, end);
+            const auto n = int_from_compressed(ctx, it, end);
+            if (bool(ctx.error)) [[unlikely]] {
+               return;
+            }
+            if (uint64_t(end - it) < n) [[unlikely]] {
+               ctx.error = error_code::unexpected_end;
+               return;
+            }
             const sv value{reinterpret_cast<const char*>(it), n};
-            to_json<sv>::template op<Opts>(value, ctx, out, ix);
+            to<JSON, sv>::template op<Opts>(value, ctx, out, ix);
             it += n;
             break;
          }
@@ -144,17 +166,30 @@ namespace glz
                dump<'\n'>(out, ix);
                dumpn<Opts.indentation_char>(ctx.indentation_level, out, ix);
             }
+            else {
+               ++ctx.indentation_level;
+            }
 
             const auto key_type = (tag & 0b000'11'000) >> 3;
             switch (key_type) {
             case 0: {
                // string key
-               const auto n_fields = detail::int_from_compressed(ctx, it, end);
+               const auto n_fields = int_from_compressed(ctx, it, end);
+               if (bool(ctx.error)) {
+                  return;
+               }
                for (size_t i = 0; i < n_fields; ++i) {
                   // convert the key
-                  const auto n = detail::int_from_compressed(ctx, it, end);
+                  const auto n = int_from_compressed(ctx, it, end);
+                  if (bool(ctx.error)) [[unlikely]] {
+                     return;
+                  }
+                  if (uint64_t(end - it) < n) [[unlikely]] {
+                     ctx.error = error_code::unexpected_end;
+                     return;
+                  }
                   const sv key{reinterpret_cast<const char*>(it), n};
-                  to_json<sv>::template op<Opts>(key, ctx, out, ix);
+                  to<JSON, sv>::template op<Opts>(key, ctx, out, ix);
                   if constexpr (Opts.prettify) {
                      dump<": ">(out, ix);
                   }
@@ -162,8 +197,46 @@ namespace glz
                      dump<':'>(out, ix);
                   }
                   it += n;
-                  // convert the value
-                  beve_to_json_value<Opts>(ctx, it, end, out, ix);
+                  beve_to_json_value<Opts>(ctx, it, end, out, ix, recursive_depth + 1);
+                  if (bool(ctx.error)) [[unlikely]] {
+                     return;
+                  }
+                  if (i != n_fields - 1) {
+                     dump<','>(out, ix);
+                     if constexpr (Opts.prettify) {
+                        dump<'\n'>(out, ix);
+                        dumpn<Opts.indentation_char>(ctx.indentation_level, out, ix);
+                     }
+                  }
+               }
+               break;
+            }
+            case 1:
+               [[fallthrough]]; // signed integer key
+            case 2: {
+               // unsigned integer key
+               const auto n_fields = int_from_compressed(ctx, it, end);
+               if (bool(ctx.error)) {
+                  return;
+               }
+               for (size_t i = 0; i < n_fields; ++i) {
+                  // convert the key
+                  dump<'"'>(out, ix);
+                  beve_to_json_number<Opts>(tag, ctx, it, end, out, ix);
+                  if (bool(ctx.error)) [[unlikely]] {
+                     return;
+                  }
+                  dump<'"'>(out, ix);
+                  if constexpr (Opts.prettify) {
+                     dump<": ">(out, ix);
+                  }
+                  else {
+                     dump<':'>(out, ix);
+                  }
+                  beve_to_json_value<Opts>(ctx, it, end, out, ix, recursive_depth + 1);
+                  if (bool(ctx.error)) [[unlikely]] {
+                     return;
+                  }
                   if (i != n_fields - 1) {
                      dump<','>(out, ix);
                      if constexpr (Opts.prettify) {
@@ -185,19 +258,29 @@ namespace glz
                dump<'\n'>(out, ix);
                dumpn<Opts.indentation_char>(ctx.indentation_level, out, ix);
             }
+            else {
+               --ctx.indentation_level;
+            }
             dump<'}'>(out, ix);
             break;
          }
          case tag::typed_array: {
             ++it;
             const auto value_type = (tag & 0b000'11'000) >> 3;
-            const uint8_t byte_count = detail::byte_count_lookup[tag >> 5];
+            const uint8_t byte_count = byte_count_lookup[tag >> 5];
 
             auto write_array = [&]<class T>(T&& value) {
                const auto n = int_from_compressed(ctx, it, end);
+               if (bool(ctx.error)) [[unlikely]] {
+                  return;
+               }
                for (size_t i = 0; i < n; ++i) {
+                  if ((it + sizeof(T)) > end) [[unlikely]] {
+                     ctx.error = error_code::unexpected_end;
+                     return;
+                  }
                   std::memcpy(&value, it, sizeof(T));
-                  to_json<T>::template op<Opts>(value, ctx, out, ix);
+                  to<JSON, T>::template op<Opts>(value, ctx, out, ix);
                   it += sizeof(T);
                   if (i != n - 1) {
                      dump<','>(out, ix);
@@ -291,10 +374,20 @@ namespace glz
                case 1: {
                   // array of strings
                   const auto n_strings = int_from_compressed(ctx, it, end);
+                  if (bool(ctx.error)) [[unlikely]] {
+                     return;
+                  }
                   for (size_t i = 0; i < n_strings; ++i) {
-                     const auto n = detail::int_from_compressed(ctx, it, end);
+                     const auto n = int_from_compressed(ctx, it, end);
+                     if (bool(ctx.error)) [[unlikely]] {
+                        return;
+                     }
+                     if (uint64_t(end - it) < n) [[unlikely]] {
+                        ctx.error = error_code::unexpected_end;
+                        return;
+                     }
                      const sv value{reinterpret_cast<const char*>(it), n};
-                     to_json<sv>::template op<Opts>(value, ctx, out, ix);
+                     to<JSON, sv>::template op<Opts>(value, ctx, out, ix);
                      it += n;
                      if (i != n_strings - 1) {
                         dump<','>(out, ix);
@@ -322,9 +415,15 @@ namespace glz
          case tag::generic_array: {
             ++it;
             const auto n = int_from_compressed(ctx, it, end);
+            if (bool(ctx.error)) [[unlikely]] {
+               return;
+            }
             dump<'['>(out, ix);
             for (size_t i = 0; i < n; ++i) {
-               beve_to_json_value<Opts>(ctx, it, end, out, ix);
+               beve_to_json_value<Opts>(ctx, it, end, out, ix, recursive_depth + 1);
+               if (bool(ctx.error)) [[unlikely]] {
+                  return;
+               }
                if (i != n - 1) {
                   dump<','>(out, ix);
                }
@@ -347,54 +446,19 @@ namespace glz
                skip_compressed_int(ctx, it, end);
                if (bool(ctx.error)) return;
 
-               // IMPORTANT: Code was commented because variants should typically write out the JSON value directly
-               // This makes sense for auto-deducible values, which should be the default behavior.
-               // In the future we may want a compile time option that dumps the index for cases that cannot be
-               // auto-deduced
-               /*const auto index = int_from_compressed(ctx, it, end);
-
-               dump<'{'>(out, ix);
-               if constexpr (Opts.prettify) {
-                  ctx.indentation_level += Opts.indentation_width;
-                  dump<'\n'>(out, ix);
-                  dumpn<Opts.indentation_char>(ctx.indentation_level, out, ix);
-               }
-
-               if constexpr (Opts.prettify) {
-                  dump<R"("index": )">(out, ix);
-               }
-               else {
-                  dump<R"("index":)">(out, ix);
-               }
-
-               to_json<std::remove_cvref_t<decltype(index)>>::template op<Opts>(index, ctx, out, ix);
-
-               dump<','>(out, ix);
-               if constexpr (Opts.prettify) {
-                  dump<'\n'>(out, ix);
-                  dumpn<Opts.indentation_char>(ctx.indentation_level, out, ix);
-               }
-
-               if constexpr (Opts.prettify) {
-                  dump<R"("value": )">(out, ix);
-               }
-               else {
-                  dump<R"("value":)">(out, ix);
-               }*/
-
-               beve_to_json_value<Opts>(ctx, it, end, out, ix);
-
-               /*if constexpr (Opts.prettify) {
-                  ctx.indentation_level -= Opts.indentation_width;
-                  dump<'\n'>(out, ix);
-                  dumpn<Opts.indentation_char>(ctx.indentation_level, out, ix);
+               beve_to_json_value<Opts>(ctx, it, end, out, ix, recursive_depth + 1);
+               if (bool(ctx.error)) [[unlikely]] {
+                  return;
                }
-               dump<'}'>(out, ix);*/
                break;
             }
             case 2: {
                // matrices
                ++it;
+               if (it >= end) [[unlikely]] {
+                  ctx.error = error_code::syntax_error;
+                  return;
+               }
                const auto matrix_header = uint8_t(*it);
                ++it;
 
@@ -404,6 +468,9 @@ namespace glz
                   dump<'\n'>(out, ix);
                   dumpn<Opts.indentation_char>(ctx.indentation_level, out, ix);
                }
+               else {
+                  ++ctx.indentation_level;
+               }
 
                if constexpr (Opts.prettify) {
                   dump<R"("layout": )">(out, ix);
@@ -428,7 +495,10 @@ namespace glz
                   dump<R"("extents":)">(out, ix);
                }
 
-               beve_to_json_value<Opts>(ctx, it, end, out, ix);
+               beve_to_json_value<Opts>(ctx, it, end, out, ix, recursive_depth + 1);
+               if (bool(ctx.error)) [[unlikely]] {
+                  return;
+               }
 
                dump<','>(out, ix);
                if constexpr (Opts.prettify) {
@@ -443,19 +513,29 @@ namespace glz
                   dump<R"("value":)">(out, ix);
                }
 
-               beve_to_json_value<Opts>(ctx, it, end, out, ix);
+               beve_to_json_value<Opts>(ctx, it, end, out, ix, recursive_depth + 1);
+               if (bool(ctx.error)) [[unlikely]] {
+                  return;
+               }
 
                if constexpr (Opts.prettify) {
                   ctx.indentation_level -= Opts.indentation_width;
                   dump<'\n'>(out, ix);
                   dumpn<Opts.indentation_char>(ctx.indentation_level, out, ix);
                }
+               else {
+                  --ctx.indentation_level;
+               }
                dump<'}'>(out, ix);
                break;
             }
             case 3: {
                // complex numbers
                ++it;
+               if (it >= end) [[unlikely]] {
+                  ctx.error = error_code::syntax_error;
+                  return;
+               }
                const auto complex_header = uint8_t(*it);
                ++it;
 
@@ -464,12 +544,21 @@ namespace glz
                   // complex array
                   const auto number_tag = complex_header & 0b111'00000;
                   const auto n = int_from_compressed(ctx, it, end);
+                  if (bool(ctx.error)) [[unlikely]] {
+                     return;
+                  }
                   dump<'['>(out, ix);
                   for (size_t i = 0; i < n; ++i) {
                      dump<'['>(out, ix);
                      beve_to_json_number<Opts>(number_tag, ctx, it, end, out, ix);
+                     if (bool(ctx.error)) [[unlikely]] {
+                        return;
+                     }
                      dump<','>(out, ix);
                      beve_to_json_number<Opts>(number_tag, ctx, it, end, out, ix);
+                     if (bool(ctx.error)) [[unlikely]] {
+                        return;
+                     }
                      dump<']'>(out, ix);
                      if (i != n - 1) {
                         dump<','>(out, ix);
@@ -482,8 +571,14 @@ namespace glz
                   const auto number_tag = complex_header & 0b111'00000;
                   dump<'['>(out, ix);
                   beve_to_json_number<Opts>(number_tag, ctx, it, end, out, ix);
+                  if (bool(ctx.error)) [[unlikely]] {
+                     return;
+                  }
                   dump<','>(out, ix);
                   beve_to_json_number<Opts>(number_tag, ctx, it, end, out, ix);
+                  if (bool(ctx.error)) [[unlikely]] {
+                     return;
+                  }
                   dump<']'>(out, ix);
                }
 
@@ -504,8 +599,8 @@ namespace glz
       }
    }
 
-   template <glz::opts Opts = glz::opts{}, class BEVEBuffer, class JSONBuffer>
-   [[nodiscard]] inline error_ctx beve_to_json(const BEVEBuffer& beve, JSONBuffer& out) noexcept
+   template <auto Opts = glz::opts{}, class BEVEBuffer, class JSONBuffer>
+   [[nodiscard]] inline error_ctx beve_to_json(const BEVEBuffer& beve, JSONBuffer& out)
    {
       size_t ix{}; // write index
 
@@ -515,7 +610,7 @@ namespace glz
       context ctx{};
 
       while (it < end) {
-         detail::beve_to_json_value<Opts>(ctx, it, end, out, ix);
+         detail::beve_to_json_value<Opts>(ctx, it, end, out, ix, 0);
          if (bool(ctx.error)) {
             return {ctx.error};
          }
diff --git a/deps/saucer/include/glaze/binary/header.hpp b/deps/saucer/include/glaze/beve/header.hpp
similarity index 68%
rename from deps/saucer/include/glaze/binary/header.hpp
rename to deps/saucer/include/glaze/beve/header.hpp
index 3958683..d99a877 100644
--- a/deps/saucer/include/glaze/binary/header.hpp
+++ b/deps/saucer/include/glaze/beve/header.hpp
@@ -13,6 +13,20 @@
 #include "glaze/core/context.hpp"
 #include "glaze/util/inline.hpp"
 
+namespace glz
+{
+   GLZ_ALWAYS_INLINE bool invalid_end(is_context auto& ctx, auto&& it, auto&& end) noexcept
+   {
+      if (it >= end) [[unlikely]] {
+         ctx.error = error_code::unexpected_end;
+         return true;
+      }
+      else [[likely]] {
+         return false;
+      }
+   }
+}
+
 namespace glz::tag
 {
    constexpr uint8_t null = 0;
@@ -46,16 +60,20 @@ namespace glz::tag
    constexpr uint8_t f128 = 0b100'00'001;
 }
 
-namespace glz::detail
+namespace glz
 {
    template <class T>
    constexpr uint8_t byte_count = uint8_t(std::bit_width(sizeof(T)) - 1);
 
-   constexpr std::array<uint8_t, 8> byte_count_lookup{1, 2, 4, 8, 16, 32, 64, 128};
+   inline constexpr std::array<uint8_t, 8> byte_count_lookup{1, 2, 4, 8, 16, 32, 64, 128};
 
-   [[nodiscard]] GLZ_ALWAYS_INLINE constexpr size_t int_from_compressed(is_context auto&& ctx, auto&& it,
-                                                                        auto&& end) noexcept
+   [[nodiscard]] GLZ_ALWAYS_INLINE constexpr size_t int_from_compressed(auto&& ctx, auto&& it, auto&& end) noexcept
    {
+      if (it >= end) [[unlikely]] {
+         ctx.error = error_code::unexpected_end;
+         return 0;
+      }
+
       uint8_t header;
       std::memcpy(&header, it, 1);
       const uint8_t config = header & 0b000000'11;
@@ -82,10 +100,22 @@ namespace glz::detail
          return h >> 2;
       }
       case 3: {
-         uint64_t h;
-         std::memcpy(&h, it, 8);
-         it += 8;
-         return h >> 2;
+         // On 32-bit systems it's impossible to address more than 4 GBiB of memory, so we should verify first if we are
+         // running in 64-bit mode here
+         if constexpr (sizeof(size_t) > sizeof(uint32_t)) {
+            uint64_t h;
+            std::memcpy(&h, it, 8);
+            it += 8;
+            h = h >> 2;
+            static constexpr uint64_t safety_limit = 1ull << 48; // 2^48
+            if (h > safety_limit) [[unlikely]] {
+               ctx.error = error_code::unexpected_end;
+               return 0;
+            }
+            return h;
+         }
+         // Fallthrough in case we are in 32-bit mode
+         [[fallthrough]];
       }
       default:
          return 0;
@@ -94,6 +124,10 @@ namespace glz::detail
 
    GLZ_ALWAYS_INLINE constexpr void skip_compressed_int(is_context auto&& ctx, auto&& it, auto&& end) noexcept
    {
+      if (invalid_end(ctx, it, end)) {
+         return;
+      }
+
       uint8_t header;
       std::memcpy(&header, it, 1);
       const uint8_t config = header & 0b000000'11;
diff --git a/deps/saucer/include/glaze/binary/ptr.hpp b/deps/saucer/include/glaze/beve/ptr.hpp
similarity index 58%
rename from deps/saucer/include/glaze/binary/ptr.hpp
rename to deps/saucer/include/glaze/beve/ptr.hpp
index 3699d2b..6b27180 100644
--- a/deps/saucer/include/glaze/binary/ptr.hpp
+++ b/deps/saucer/include/glaze/beve/ptr.hpp
@@ -3,8 +3,8 @@
 
 #pragma once
 
-#include "glaze/binary/read.hpp"
-#include "glaze/binary/write.hpp"
+#include "glaze/beve/read.hpp"
+#include "glaze/beve/write.hpp"
 #include "glaze/core/ptr.hpp"
 
 namespace glz
@@ -12,12 +12,12 @@ namespace glz
    template <class T, class B>
    bool read_as_binary(T&& root_value, const sv json_ptr, B&& buffer)
    {
-      return read_as<opts{.format = binary}>(std::forward<T>(root_value), json_ptr, buffer);
+      return read_as<opts{.format = BEVE}>(std::forward<T>(root_value), json_ptr, buffer);
    }
 
    template <class T, class B>
    bool write_as_binary(T&& root_value, const sv json_ptr, B&& buffer)
    {
-      return write_as<opts{.format = binary}>(std::forward<T>(root_value), json_ptr, buffer);
+      return write_as<opts{.format = BEVE}>(std::forward<T>(root_value), json_ptr, buffer);
    }
 }
diff --git a/deps/saucer/include/glaze/beve/read.hpp b/deps/saucer/include/glaze/beve/read.hpp
new file mode 100644
index 0000000..2e36a7f
--- /dev/null
+++ b/deps/saucer/include/glaze/beve/read.hpp
@@ -0,0 +1,1594 @@
+// Glaze Library
+// For the license information refer to glaze.hpp
+
+#pragma once
+
+#include "glaze/beve/header.hpp"
+#include "glaze/beve/skip.hpp"
+#include "glaze/core/opts.hpp"
+#include "glaze/core/read.hpp"
+#include "glaze/core/reflect.hpp"
+#include "glaze/file/file_ops.hpp"
+#include "glaze/util/dump.hpp"
+
+// To handle invalid inputs we must check if (it >= end) at the beginning of each function
+// This way we can always call a function after incrementing the iterator without needed to do a tail check
+// If we know the first function called has an end check, we don't need a guard at the top of the function
+// Also, after almost every function call we need to check if an error was produced
+
+namespace glz
+{
+   template <>
+   struct parse<BEVE>
+   {
+      template <auto Opts, class T, class Tag, is_context Ctx, class It0, class It1>
+         requires(check_no_header(Opts))
+      GLZ_ALWAYS_INLINE static void op(T&& value, Tag&& tag, Ctx&& ctx, It0&& it, It1&& end)
+      {
+         if constexpr (const_value_v<T>) {
+            if constexpr (Opts.error_on_const_read) {
+               ctx.error = error_code::attempt_const_read;
+            }
+            else {
+               // do not read anything into the const value
+               skip_value<BEVE>::op<Opts>(std::forward<Ctx>(ctx), std::forward<It0>(it), std::forward<It1>(end));
+            }
+         }
+         else {
+            using V = std::remove_cvref_t<T>;
+            from<BEVE, V>::template op<Opts>(std::forward<T>(value), std::forward<Tag>(tag), std::forward<Ctx>(ctx),
+                                             std::forward<It0>(it), std::forward<It1>(end));
+         }
+      }
+
+      template <auto Opts, class T, is_context Ctx, class It0, class It1>
+         requires(not check_no_header(Opts))
+      GLZ_ALWAYS_INLINE static void op(T&& value, Ctx&& ctx, It0&& it, It1&& end)
+      {
+         if constexpr (const_value_v<T>) {
+            if constexpr (Opts.error_on_const_read) {
+               ctx.error = error_code::attempt_const_read;
+            }
+            else {
+               // do not read anything into the const value
+               skip_value<BEVE>::op<Opts>(std::forward<Ctx>(ctx), std::forward<It0>(it), std::forward<It1>(end));
+            }
+         }
+         else {
+            using V = std::remove_cvref_t<T>;
+            from<BEVE, V>::template op<Opts>(std::forward<T>(value), std::forward<Ctx>(ctx), std::forward<It0>(it),
+                                             std::forward<It1>(end));
+         }
+      }
+   };
+
+   template <class T>
+      requires(glaze_value_t<T> && !custom_read<T>)
+   struct from<BEVE, T>
+   {
+      template <auto Opts, class Value, is_context Ctx, class It0, class It1>
+      GLZ_ALWAYS_INLINE static void op(Value&& value, Ctx&& ctx, It0&& it, It1&& end)
+      {
+         using V = std::decay_t<decltype(get_member(std::declval<Value>(), meta_wrapper_v<T>))>;
+         from<BEVE, V>::template op<Opts>(get_member(std::forward<Value>(value), meta_wrapper_v<T>),
+                                          std::forward<Ctx>(ctx), std::forward<It0>(it), std::forward<It1>(end));
+      }
+   };
+
+   template <always_null_t T>
+   struct from<BEVE, T>
+   {
+      template <auto Opts>
+      GLZ_ALWAYS_INLINE static void op(auto&&, is_context auto&& ctx, auto&& it, auto&& end) noexcept
+      {
+         if (invalid_end(ctx, it, end)) {
+            return;
+         }
+         if (uint8_t(*it)) [[unlikely]] {
+            ctx.error = error_code::syntax_error;
+            return;
+         }
+         ++it;
+      }
+   };
+
+   template <>
+   struct from<BEVE, hidden>
+   {
+      template <auto Opts>
+      GLZ_ALWAYS_INLINE static void op(auto&&, is_context auto&& ctx, auto&&...) noexcept
+      {
+         ctx.error = error_code::attempt_read_hidden;
+      }
+   };
+
+   template <is_bitset T>
+   struct from<BEVE, T>
+   {
+      template <auto Opts>
+      static void op(auto&& value, is_context auto&& ctx, auto&& it, auto&& end) noexcept
+      {
+         if (invalid_end(ctx, it, end)) {
+            return;
+         }
+         const auto tag = uint8_t(*it);
+
+         constexpr uint8_t type = uint8_t(3) << 3;
+         constexpr uint8_t header = tag::typed_array | type;
+
+         if (tag != header) [[unlikely]] {
+            ctx.error = error_code::syntax_error;
+            return;
+         }
+
+         ++it;
+         const auto n = int_from_compressed(ctx, it, end);
+         if (bool(ctx.error)) [[unlikely]] {
+            return;
+         }
+
+         const auto num_bytes = (value.size() + 7) / 8;
+         for (size_t byte_i{}, i{}; byte_i < num_bytes; ++byte_i, ++it) {
+            if (invalid_end(ctx, it, end)) {
+               return;
+            }
+            uint8_t byte;
+            std::memcpy(&byte, it, 1);
+            for (size_t bit_i = 0; bit_i < 8 && i < n; ++bit_i, ++i) {
+               value[i] = byte >> bit_i & uint8_t(1);
+            }
+         }
+      }
+   };
+
+   template <>
+   struct from<BEVE, skip>
+   {
+      template <auto Opts>
+      GLZ_ALWAYS_INLINE static void op(auto&&, is_context auto&& ctx, auto&&... args) noexcept
+      {
+         skip_value<BEVE>::op<Opts>(ctx, args...);
+      }
+   };
+
+   template <glaze_flags_t T>
+   struct from<BEVE, T>
+   {
+      template <auto Opts, is_context Ctx, class It0, class It1>
+      static void op(auto&& value, Ctx&& ctx, It0&& it, It1&& end)
+      {
+         constexpr auto N = reflect<T>::size;
+
+         constexpr auto Length = byte_length<T>();
+         uint8_t data[Length];
+
+         if ((it + Length) > end) [[unlikely]] {
+            ctx.error = error_code::unexpected_end;
+            return;
+         }
+         std::memcpy(data, it, Length);
+         it += Length;
+
+         for_each<N>([&]<size_t I>() {
+            get_member(value, get<I>(reflect<T>::values)) = data[I / 8] & (uint8_t{1} << (7 - (I % 8)));
+         });
+      }
+   };
+
+   template <class T>
+      requires(num_t<T> || char_t<T> || glaze_enum_t<T>)
+   struct from<BEVE, T>
+   {
+      static constexpr uint8_t type = std::floating_point<T> ? 0 : (std::is_signed_v<T> ? 0b000'01'000 : 0b000'10'000);
+      static constexpr uint8_t header = tag::number | type | (byte_count<T> << 5);
+
+      template <auto Opts>
+         requires(check_no_header(Opts))
+      GLZ_ALWAYS_INLINE static void op(auto&& value, const uint8_t tag, is_context auto&& ctx, auto&& it,
+                                       auto&& end) noexcept
+      {
+         if (invalid_end(ctx, it, end)) {
+            return;
+         }
+
+         using V = std::decay_t<decltype(value)>;
+
+         constexpr auto is_volatile = std::is_volatile_v<std::remove_reference_t<decltype(value)>>;
+
+         if (tag != header) {
+            if constexpr (check_allow_conversions(Opts)) {
+               if constexpr (num_t<T>) {
+                  if ((tag & 0b00000111) != tag::number) {
+                     ctx.error = error_code::syntax_error;
+                     return;
+                  }
+
+                  auto decode = [&](auto&& i) {
+                     if ((it + sizeof(i)) > end) [[unlikely]] {
+                        ctx.error = error_code::unexpected_end;
+                        return;
+                     }
+                     std::memcpy(&i, it, sizeof(i));
+                     value = static_cast<V>(i);
+                     it += sizeof(i);
+                  };
+
+                  switch (tag) {
+                  case tag::f32: {
+                     if constexpr (std::integral<V>) {
+                        // We do not allow cross conversions from floats to integral types
+                        ctx.error = error_code::syntax_error;
+                     }
+                     else {
+                        static_assert(sizeof(float) == 4);
+                        // TODO: use float32_t in C++23
+                        decode(float{});
+                     }
+                     return;
+                  }
+                  case tag::f64: {
+                     if constexpr (std::integral<V>) {
+                        // We do not allow cross conversions from floats to integral types
+                        ctx.error = error_code::syntax_error;
+                     }
+                     else {
+                        static_assert(sizeof(double) == 8);
+                        // TODO: use float64_t in C++23
+                        decode(double{});
+                     }
+                     return;
+                  }
+                  case tag::i8: {
+                     decode(int8_t{});
+                     return;
+                  }
+                  case tag::i16: {
+                     decode(int16_t{});
+                     return;
+                  }
+                  case tag::i32: {
+                     decode(int32_t{});
+                     return;
+                  }
+                  case tag::i64: {
+                     decode(int64_t{});
+                     return;
+                  }
+                  case tag::u8: {
+                     decode(uint8_t{});
+                     return;
+                  }
+                  case tag::u16: {
+                     decode(uint16_t{});
+                     return;
+                  }
+                  case tag::u32: {
+                     decode(uint32_t{});
+                     return;
+                  }
+                  case tag::u64: {
+                     decode(uint64_t{});
+                     return;
+                  }
+                  default: {
+                     ctx.error = error_code::syntax_error;
+                     return;
+                  }
+                  }
+               }
+            }
+            else {
+               ctx.error = error_code::syntax_error;
+               return;
+            }
+         }
+
+         if ((it + sizeof(V)) > end) [[unlikely]] {
+            ctx.error = error_code::unexpected_end;
+            return;
+         }
+
+         if constexpr (is_volatile) {
+            V temp;
+            std::memcpy(&temp, it, sizeof(V));
+            value = temp;
+         }
+         else {
+            std::memcpy(&value, it, sizeof(V));
+         }
+         it += sizeof(V);
+      }
+
+      template <auto Opts>
+         requires(not check_no_header(Opts))
+      GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, auto&& it, auto&& end) noexcept
+      {
+         if (invalid_end(ctx, it, end)) {
+            return;
+         }
+         const auto tag = uint8_t(*it);
+         ++it;
+         op<no_header_on<Opts>()>(value, tag, ctx, it, end);
+      }
+   };
+
+   template <class T>
+      requires(std::is_enum_v<T> && !glaze_enum_t<T>)
+   struct from<BEVE, T>
+   {
+      template <auto Opts>
+      GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, auto&& it, auto&& end) noexcept
+      {
+         using V = std::underlying_type_t<std::decay_t<T>>;
+
+         if constexpr (check_no_header(Opts)) {
+            if ((it + sizeof(V)) > end) [[unlikely]] {
+               ctx.error = error_code::unexpected_end;
+               return;
+            }
+
+            std::memcpy(&value, it, sizeof(V));
+            it += sizeof(V);
+         }
+         else {
+            constexpr uint8_t type = std::floating_point<V> ? 0 : (std::is_signed_v<V> ? 0b000'01'000 : 0b000'10'000);
+            constexpr uint8_t header = tag::number | type | (byte_count<V> << 5);
+
+            if (invalid_end(ctx, it, end)) {
+               return;
+            }
+            const auto tag = uint8_t(*it);
+            if (tag != header) {
+               ctx.error = error_code::syntax_error;
+               return;
+            }
+
+            ++it;
+            if ((it + sizeof(V)) > end) [[unlikely]] {
+               ctx.error = error_code::unexpected_end;
+               return;
+            }
+
+            std::memcpy(&value, it, sizeof(V));
+            it += sizeof(V);
+         }
+      }
+   };
+
+   template <class T>
+      requires complex_t<T>
+   struct from<BEVE, T>
+   {
+      template <auto Opts>
+      static void op(auto&& value, is_context auto&& ctx, auto&& it, auto&& end) noexcept
+      {
+         if constexpr (check_no_header(Opts)) {
+            using V = std::decay_t<T>;
+            if ((it + sizeof(V)) > end) [[unlikely]] {
+               ctx.error = error_code::unexpected_end;
+               return;
+            }
+
+            std::memcpy(&value, it, sizeof(V));
+            it += sizeof(V);
+         }
+         else {
+            constexpr uint8_t header = tag::extensions | 0b00011'000;
+
+            if (invalid_end(ctx, it, end)) {
+               return;
+            }
+            const auto tag = uint8_t(*it);
+            if (tag != header) {
+               ctx.error = error_code::syntax_error;
+               return;
+            }
+            ++it;
+
+            using V = typename T::value_type;
+            constexpr uint8_t type = std::floating_point<V> ? 0 : (std::is_signed_v<V> ? 0b000'01'000 : 0b000'10'000);
+            constexpr uint8_t complex_number = 0;
+            constexpr uint8_t complex_header = complex_number | type | (byte_count<V> << 5);
+
+            if (invalid_end(ctx, it, end)) {
+               return;
+            }
+            const auto complex_tag = uint8_t(*it);
+            if (complex_tag != complex_header) {
+               ctx.error = error_code::syntax_error;
+               return;
+            }
+            ++it;
+
+            if ((it + 2 * sizeof(V)) > end) [[unlikely]] {
+               ctx.error = error_code::unexpected_end;
+               return;
+            }
+
+            std::memcpy(&value, it, 2 * sizeof(V));
+            it += 2 * sizeof(V);
+         }
+      }
+   };
+
+   template <boolean_like T>
+   struct from<BEVE, T>
+   {
+      template <auto Opts>
+      GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, auto&& it, auto&& end) noexcept
+      {
+         if (invalid_end(ctx, it, end)) {
+            return;
+         }
+         const auto tag = uint8_t(*it);
+         if ((tag & 0b0000'1111) != tag::boolean) {
+            ctx.error = error_code::syntax_error;
+            return;
+         }
+
+         value = tag >> 4;
+         ++it;
+      }
+   };
+
+   template <is_member_function_pointer T>
+   struct from<BEVE, T>
+   {
+      template <auto Opts>
+      GLZ_ALWAYS_INLINE static void op(auto&& /*value*/, is_context auto&& /*ctx*/, auto&& /*it*/,
+                                       auto&& /*end*/) noexcept
+      {}
+   };
+
+   template <func_t T>
+   struct from<BEVE, T>
+   {
+      template <auto Opts>
+      GLZ_ALWAYS_INLINE static void op(auto&& /*value*/, is_context auto&& ctx, auto&& it, auto&& end) noexcept
+      {
+         skip_string_beve(ctx, it, end);
+      }
+   };
+
+   template <class T>
+   struct from<BEVE, basic_raw_json<T>>
+   {
+      template <auto Opts>
+      GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, auto&& it, auto&& end)
+      {
+         parse<BEVE>::op<Opts>(value.str, ctx, it, end);
+      }
+   };
+
+   template <class T>
+   struct from<BEVE, basic_text<T>>
+   {
+      template <auto Opts>
+      GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, auto&& it, auto&& end)
+      {
+         parse<BEVE>::op<Opts>(value.str, ctx, it, end);
+      }
+   };
+
+   template <is_variant T>
+   struct from<BEVE, T>
+   {
+      template <auto Opts>
+      GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, auto&& it, auto&& end) noexcept
+      {
+         constexpr uint8_t header = tag::extensions | 0b00001'000;
+         if (invalid_end(ctx, it, end)) {
+            return;
+         }
+         const auto tag = uint8_t(*it);
+         if (tag != header) [[unlikely]] {
+            ctx.error = error_code::syntax_error;
+            return;
+         }
+
+         ++it;
+         const auto type_index = int_from_compressed(ctx, it, end);
+         if (bool(ctx.error)) [[unlikely]] {
+            return;
+         }
+
+         if (value.index() != type_index) {
+            value = runtime_variant_map<T>()[type_index];
+         }
+         std::visit([&](auto&& v) { parse<BEVE>::op<Opts>(v, ctx, it, end); }, value);
+      }
+   };
+
+   template <str_t T>
+   struct from<BEVE, T> final
+   {
+      using V = typename std::decay_t<T>::value_type;
+      static_assert(sizeof(V) == 1);
+
+      template <auto Opts>
+         requires(check_no_header(Opts))
+      GLZ_ALWAYS_INLINE static void op(auto&& value, const uint8_t, is_context auto&& ctx, auto&& it, auto&& end)
+      {
+         const auto n = int_from_compressed(ctx, it, end);
+         if (bool(ctx.error)) [[unlikely]] {
+            return;
+         }
+         if (uint64_t(end - it) < n) [[unlikely]] {
+            ctx.error = error_code::unexpected_end;
+            return;
+         }
+         value.resize(n);
+         std::memcpy(value.data(), it, n);
+         it += n;
+      }
+
+      template <auto Opts>
+         requires(not check_no_header(Opts))
+      GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, auto&& it, auto&& end)
+      {
+         constexpr uint8_t header = tag::string;
+
+         if (invalid_end(ctx, it, end)) {
+            return;
+         }
+         const auto tag = uint8_t(*it);
+         if (tag != header) [[unlikely]] {
+            ctx.error = error_code::syntax_error;
+            return;
+         }
+
+         ++it;
+         const auto n = int_from_compressed(ctx, it, end);
+         if (bool(ctx.error)) [[unlikely]] {
+            return;
+         }
+         if (uint64_t(end - it) < n) [[unlikely]] {
+            ctx.error = error_code::unexpected_end;
+            return;
+         }
+
+         if constexpr (string_view_t<T>) {
+            value = {it, n};
+         }
+         else {
+            value.resize(n);
+            std::memcpy(value.data(), it, n);
+         }
+         it += n;
+      }
+   };
+
+   // for set types
+   template <class T>
+      requires(readable_array_t<T> && !emplace_backable<T> && !resizable<T> && emplaceable<T>)
+   struct from<BEVE, T> final
+   {
+      template <auto Opts>
+      static void op(auto&& value, is_context auto&& ctx, auto&& it, auto&& end)
+      {
+         using V = range_value_t<std::decay_t<T>>;
+
+         if (invalid_end(ctx, it, end)) {
+            return;
+         }
+         const auto tag = uint8_t(*it);
+
+         if constexpr (boolean_like<V>) {
+            constexpr uint8_t type = uint8_t(3) << 3;
+            constexpr uint8_t header = tag::typed_array | type;
+
+            if (tag != header) [[unlikely]] {
+               ctx.error = error_code::syntax_error;
+               return;
+            }
+
+            ++it;
+            const auto n = int_from_compressed(ctx, it, end);
+            if (bool(ctx.error)) [[unlikely]] {
+               return;
+            }
+
+            value.clear();
+
+            const auto num_bytes = (value.size() + 7) / 8;
+            for (size_t byte_i{}, i{}; byte_i < num_bytes; ++byte_i, ++it) {
+               if (invalid_end(ctx, it, end)) {
+                  return;
+               }
+               uint8_t byte;
+               std::memcpy(&byte, it, 1);
+               for (size_t bit_i = 7; bit_i < 8 && i < n; --bit_i, ++i) {
+                  bool x = byte >> bit_i & uint8_t(1);
+                  value.emplace(x);
+               }
+            }
+         }
+         else if constexpr (num_t<V>) {
+            constexpr uint8_t type = std::floating_point<V> ? 0 : (std::is_signed_v<V> ? 0b000'01'000 : 0b000'10'000);
+            constexpr uint8_t header = tag::typed_array | type | (byte_count<V> << 5);
+
+            if (tag != header) [[unlikely]] {
+               ctx.error = error_code::syntax_error;
+               return;
+            }
+
+            ++it;
+            const auto n = int_from_compressed(ctx, it, end);
+            if (bool(ctx.error)) [[unlikely]] {
+               return;
+            }
+
+            value.clear();
+
+            for (size_t i = 0; i < n; ++i) {
+               if ((it + sizeof(V)) > end) [[unlikely]] {
+                  ctx.error = error_code::unexpected_end;
+                  return;
+               }
+
+               V x;
+               std::memcpy(&x, it, sizeof(V));
+               it += sizeof(V);
+               value.emplace(x);
+            }
+         }
+         else if constexpr (str_t<V>) {
+            constexpr uint8_t type = uint8_t(3) << 3;
+            constexpr uint8_t string_indicator = uint8_t(1) << 5;
+            constexpr uint8_t header = tag::typed_array | type | string_indicator;
+
+            if (tag != header) [[unlikely]] {
+               ctx.error = error_code::syntax_error;
+               return;
+            }
+
+            ++it;
+            const auto n = int_from_compressed(ctx, it, end);
+            if (bool(ctx.error)) [[unlikely]] {
+               return;
+            }
+            if (uint64_t(end - it) < n) [[unlikely]] {
+               ctx.error = error_code::unexpected_end;
+               return;
+            }
+
+            value.clear();
+
+            for (size_t i = 0; i < n; ++i) {
+               const auto length = int_from_compressed(ctx, it, end);
+               if (bool(ctx.error)) [[unlikely]] {
+                  return;
+               }
+               if (uint64_t(end - it) < length) [[unlikely]] {
+                  ctx.error = error_code::unexpected_end;
+                  return;
+               }
+               V str;
+               str.resize(length);
+               std::memcpy(str.data(), it, length);
+               it += length;
+               value.emplace(std::move(str));
+            }
+         }
+         else if constexpr (complex_t<V>) {
+            static_assert(false_v<T>, "TODO");
+         }
+         else {
+            // generic array
+            if ((tag & 0b00000'111) != tag::generic_array) [[unlikely]] {
+               ctx.error = error_code::syntax_error;
+               return;
+            }
+
+            ++it;
+            const auto n = int_from_compressed(ctx, it, end);
+            if (bool(ctx.error)) [[unlikely]] {
+               return;
+            }
+
+            value.clear();
+
+            for (size_t i = 0; i < n; ++i) {
+               V v;
+               parse<BEVE>::op<Opts>(v, ctx, it, end);
+               value.emplace(std::move(v));
+            }
+         }
+      }
+   };
+
+   template <readable_array_t T>
+   struct from<BEVE, T> final
+   {
+      template <auto Opts>
+      static void op(auto&& value, is_context auto&& ctx, auto&& it, auto&& end)
+      {
+         using V = range_value_t<std::decay_t<T>>;
+
+         if (invalid_end(ctx, it, end)) {
+            return;
+         }
+         const auto tag = uint8_t(*it);
+
+         if constexpr (boolean_like<V>) {
+            constexpr uint8_t type = uint8_t(3) << 3;
+            constexpr uint8_t header = tag::typed_array | type;
+
+            if (tag != header) [[unlikely]] {
+               ctx.error = error_code::syntax_error;
+               return;
+            }
+
+            ++it;
+            const auto n = int_from_compressed(ctx, it, end);
+            if (bool(ctx.error)) [[unlikely]] {
+               return;
+            }
+
+            if constexpr (resizable<T>) {
+               value.resize(n);
+
+               if constexpr (check_shrink_to_fit(Opts)) {
+                  value.shrink_to_fit();
+               }
+            }
+
+            const auto num_bytes = (value.size() + 7) / 8;
+            for (size_t byte_i{}, i{}; byte_i < num_bytes; ++byte_i, ++it) {
+               if (invalid_end(ctx, it, end)) {
+                  return;
+               }
+               uint8_t byte;
+               std::memcpy(&byte, it, 1);
+               for (size_t bit_i = 7; bit_i < 8 && i < n; --bit_i, ++i) {
+                  value[i] = byte >> bit_i & uint8_t(1);
+               }
+            }
+         }
+         else if constexpr (num_t<V>) {
+            constexpr uint8_t type = std::floating_point<V> ? 0 : (std::is_signed_v<V> ? 0b000'01'000 : 0b000'10'000);
+            constexpr uint8_t header = tag::typed_array | type | (byte_count<V> << 5);
+
+            auto prepare = [&](const size_t element_size) -> size_t {
+               ++it;
+               if (invalid_end(ctx, it, end)) {
+                  return 0;
+               }
+
+               std::conditional_t<Opts.partial_read, size_t, const size_t> n = int_from_compressed(ctx, it, end);
+               if (bool(ctx.error)) [[unlikely]] {
+                  return 0;
+               }
+
+               if constexpr (Opts.partial_read) {
+                  n = value.size();
+               }
+
+               if ((it + n * element_size) > end) [[unlikely]] {
+                  ctx.error = error_code::unexpected_end;
+                  return 0;
+               }
+
+               if constexpr (resizable<T>) {
+                  value.resize(n);
+
+                  if constexpr (check_shrink_to_fit(Opts)) {
+                     value.shrink_to_fit();
+                  }
+               }
+               else {
+                  if (n > value.size()) {
+                     ctx.error = error_code::syntax_error;
+                     return 0;
+                  }
+               }
+
+               return n;
+            };
+
+            if (tag != header) {
+               if constexpr (check_allow_conversions(Opts)) {
+                  if (tag != header) [[unlikely]] {
+                     if constexpr (check_allow_conversions(Opts)) {
+                        if ((tag & 0b00000111) != tag::typed_array) {
+                           ctx.error = error_code::syntax_error;
+                           return;
+                        }
+
+                        const uint8_t byte_count = byte_count_lookup[tag >> 5];
+                        prepare(byte_count);
+                        if (bool(ctx.error)) [[unlikely]] {
+                           return;
+                        }
+
+                        for (auto&& x : value) {
+                           const uint8_t number_tag = tag::number | (tag & 0b11111000);
+                           parse<BEVE>::op<no_header_on<Opts>()>(x, number_tag, ctx, it, end);
+                        }
+                        return;
+                     }
+                     else {
+                        ctx.error = error_code::syntax_error;
+                        return;
+                     }
+                  }
+               }
+               else {
+                  ctx.error = error_code::syntax_error;
+                  return;
+               }
+            }
+
+            const auto n = prepare(sizeof(V));
+            if (bool(ctx.error)) [[unlikely]] {
+               return;
+            }
+
+            if constexpr (contiguous<T>) {
+               constexpr auto is_volatile =
+                  std::is_volatile_v<std::remove_reference_t<std::remove_pointer_t<decltype(value.data())>>>;
+
+               if constexpr (is_volatile) {
+                  V temp;
+                  for (size_t i = 0; i < n; ++i) {
+                     if ((it + sizeof(V)) > end) [[unlikely]] {
+                        ctx.error = error_code::unexpected_end;
+                        return;
+                     }
+
+                     std::memcpy(&temp, it, sizeof(V));
+                     value[i] = temp;
+                     it += sizeof(V);
+                  }
+               }
+               else {
+                  if ((it + n * sizeof(V)) > end) [[unlikely]] {
+                     ctx.error = error_code::unexpected_end;
+                     return;
+                  }
+                  std::memcpy(value.data(), it, n * sizeof(V));
+                  it += n * sizeof(V);
+               }
+            }
+            else {
+               for (auto&& x : value) {
+                  if ((it + sizeof(V)) > end) [[unlikely]] {
+                     ctx.error = error_code::unexpected_end;
+                     return;
+                  }
+
+                  std::memcpy(&x, it, sizeof(V));
+                  it += sizeof(V);
+               }
+            }
+         }
+         else if constexpr (str_t<V>) {
+            constexpr uint8_t type = uint8_t(3) << 3;
+            constexpr uint8_t string_indicator = uint8_t(1) << 5;
+            constexpr uint8_t header = tag::typed_array | type | string_indicator;
+
+            if (tag != header) [[unlikely]] {
+               ctx.error = error_code::syntax_error;
+               return;
+            }
+
+            ++it;
+            std::conditional_t<Opts.partial_read, size_t, const size_t> n = int_from_compressed(ctx, it, end);
+            if (bool(ctx.error)) [[unlikely]] {
+               return;
+            }
+
+            if constexpr (Opts.partial_read) {
+               n = value.size();
+            }
+
+            if constexpr (resizable<T>) {
+               value.resize(n);
+
+               if constexpr (check_shrink_to_fit(Opts)) {
+                  value.shrink_to_fit();
+               }
+            }
+
+            for (auto&& x : value) {
+               const auto length = int_from_compressed(ctx, it, end);
+               if (bool(ctx.error)) [[unlikely]] {
+                  return;
+               }
+               if (uint64_t(end - it) < length) [[unlikely]] {
+                  ctx.error = error_code::unexpected_end;
+                  return;
+               }
+
+               x.resize(length);
+
+               if constexpr (check_shrink_to_fit(Opts)) {
+                  value.shrink_to_fit();
+               }
+
+               std::memcpy(x.data(), it, length);
+               it += length;
+            }
+         }
+         else if constexpr (complex_t<V>) {
+            constexpr uint8_t header = tag::extensions | 0b00011'000;
+            if (tag != header) [[unlikely]] {
+               ctx.error = error_code::syntax_error;
+               return;
+            }
+            ++it;
+            if (invalid_end(ctx, it, end)) {
+               return;
+            }
+
+            using X = typename V::value_type;
+            constexpr uint8_t complex_array = 1;
+            constexpr uint8_t type = std::floating_point<X> ? 0 : (std::is_signed_v<X> ? 0b000'01'000 : 0b000'10'000);
+            constexpr uint8_t complex_header = complex_array | type | (byte_count<X> << 5);
+            const auto complex_tag = uint8_t(*it);
+            if (complex_tag != complex_header) [[unlikely]] {
+               ctx.error = error_code::syntax_error;
+               return;
+            }
+            ++it;
+            std::conditional_t<Opts.partial_read, size_t, const size_t> n = int_from_compressed(ctx, it, end);
+            if (bool(ctx.error)) [[unlikely]] {
+               return;
+            }
+
+            if constexpr (Opts.partial_read) {
+               n = value.size();
+            }
+
+            if (uint64_t(end - it) < n * sizeof(V)) [[unlikely]] {
+               ctx.error = error_code::unexpected_end;
+               return;
+            }
+
+            if constexpr (resizable<T>) {
+               value.resize(n);
+
+               if constexpr (check_shrink_to_fit(Opts)) {
+                  value.shrink_to_fit();
+               }
+            }
+
+            if constexpr (contiguous<T>) {
+               std::memcpy(value.data(), it, n * sizeof(V));
+               it += n * sizeof(V);
+            }
+            else {
+               for (auto&& x : value) {
+                  std::memcpy(&x, it, sizeof(V));
+                  it += sizeof(V);
+               }
+            }
+         }
+         else {
+            if ((tag & 0b00000'111) != tag::generic_array) [[unlikely]] {
+               ctx.error = error_code::syntax_error;
+               return;
+            }
+            ++it;
+            std::conditional_t<check_partial_read(Opts), size_t, const size_t> n = int_from_compressed(ctx, it, end);
+            if (bool(ctx.error)) [[unlikely]] {
+               return;
+            }
+
+            if constexpr (Opts.partial_read) {
+               n = value.size();
+            }
+
+            if constexpr (resizable<T>) {
+               value.resize(n);
+
+               if constexpr (check_shrink_to_fit(Opts)) {
+                  value.shrink_to_fit();
+               }
+            }
+
+            for (auto&& item : value) {
+               parse<BEVE>::op<Opts>(item, ctx, it, end);
+            }
+         }
+      }
+
+      // for types like std::vector<std::pair...> that can't look up with operator[]
+      // Instead of hashing or linear searching, we just clear the input and overwrite the entire contents
+      template <auto Opts>
+         requires(pair_t<range_value_t<T>> && check_concatenate(Opts) == true)
+      static void op(auto&& value, is_context auto&& ctx, auto&& it, auto&& end)
+      {
+         using Element = typename T::value_type;
+         using Key = typename Element::first_type;
+
+         constexpr uint8_t type = str_t<Key> ? 0 : (std::is_signed_v<Key> ? 0b000'01'000 : 0b000'10'000);
+         constexpr uint8_t byte_cnt = str_t<Key> ? 0 : byte_count<Key>;
+         constexpr uint8_t header = tag::object | type | (byte_cnt << 5);
+
+         if (invalid_end(ctx, it, end)) {
+            return;
+         }
+         const auto tag = uint8_t(*it);
+         if (tag != header) [[unlikely]] {
+            if constexpr (check_allow_conversions(Opts)) {
+               const auto key_type = tag & 0b000'11'000;
+               if constexpr (str_t<Key>) {
+                  if (key_type != 0) {
+                     ctx.error = error_code::syntax_error;
+                     return;
+                  }
+               }
+               else {
+                  if (key_type == 0) {
+                     ctx.error = error_code::syntax_error;
+                     return;
+                  }
+               }
+            }
+            else {
+               ctx.error = error_code::syntax_error;
+               return;
+            }
+         }
+
+         ++it;
+         const size_t n = int_from_compressed(ctx, it, end);
+         if (bool(ctx.error)) [[unlikely]] {
+            return;
+         }
+
+         value.clear();
+
+         if constexpr (std::is_arithmetic_v<std::decay_t<Key>>) {
+            constexpr uint8_t key_tag = tag::number | type | (byte_cnt << 5);
+            for (size_t i = 0; i < n; ++i) {
+               // convert the object tag to the key type tag
+               auto& item = value.emplace_back();
+               parse<BEVE>::op<no_header_on<Opts>()>(item.first, key_tag, ctx, it, end);
+               parse<BEVE>::op<Opts>(item.second, ctx, it, end);
+            }
+         }
+         else {
+            constexpr uint8_t key_tag = tag::string;
+            for (size_t i = 0; i < n; ++i) {
+               auto& item = value.emplace_back();
+               parse<BEVE>::op<no_header_on<Opts>()>(item.first, key_tag, ctx, it, end);
+               parse<BEVE>::op<Opts>(item.second, ctx, it, end);
+            }
+         }
+      }
+   };
+
+   template <pair_t T>
+   struct from<BEVE, T> final
+   {
+      template <auto Opts>
+      GLZ_ALWAYS_INLINE static void op(T& value, is_context auto&& ctx, auto&& it, auto&& end)
+      {
+         using Key = typename T::first_type;
+
+         constexpr uint8_t type = str_t<Key> ? 0 : (std::is_signed_v<Key> ? 0b000'01'000 : 0b000'10'000);
+         constexpr uint8_t byte_cnt = str_t<Key> ? 0 : byte_count<Key>;
+         constexpr uint8_t header = tag::object | type | (byte_cnt << 5);
+
+         if (invalid_end(ctx, it, end)) {
+            return;
+         }
+         const auto tag = uint8_t(*it);
+         if (tag != header) [[unlikely]] {
+            ctx.error = error_code::syntax_error;
+            return;
+         }
+
+         ++it;
+         const auto n = int_from_compressed(ctx, it, end);
+         if (bool(ctx.error)) [[unlikely]] {
+            return;
+         }
+
+         if (n != 1) [[unlikely]] {
+            ctx.error = error_code::syntax_error;
+            return;
+         }
+
+         constexpr uint8_t key_tag = type == 0 ? tag::string : (tag::number | type | (byte_cnt << 5));
+         parse<BEVE>::op<no_header_on<Opts>()>(value.first, key_tag, ctx, it, end);
+         parse<BEVE>::op<Opts>(value.second, ctx, it, end);
+      }
+   };
+
+   template <readable_map_t T>
+   struct from<BEVE, T> final
+   {
+      template <auto Opts>
+      static void op(auto&& value, is_context auto&& ctx, auto&& it, auto&& end)
+      {
+         using Key = typename T::key_type;
+
+         constexpr uint8_t type = str_t<Key> ? 0 : (std::is_signed_v<Key> ? 0b000'01'000 : 0b000'10'000);
+         constexpr uint8_t byte_cnt = str_t<Key> ? 0 : byte_count<Key>;
+         constexpr uint8_t header = tag::object | type | (byte_cnt << 5);
+
+         if (invalid_end(ctx, it, end)) {
+            return;
+         }
+         const auto tag = uint8_t(*it);
+         if (tag != header) [[unlikely]] {
+            if constexpr (check_allow_conversions(Opts)) {
+               const auto key_type = tag & 0b000'11'000;
+               if constexpr (str_t<Key>) {
+                  if (key_type != 0) {
+                     ctx.error = error_code::syntax_error;
+                     return;
+                  }
+               }
+               else {
+                  if (key_type == 0) {
+                     ctx.error = error_code::syntax_error;
+                     return;
+                  }
+               }
+            }
+            else {
+               ctx.error = error_code::syntax_error;
+               return;
+            }
+         }
+
+         ++it;
+         std::conditional_t<Opts.partial_read, size_t, const size_t> n = int_from_compressed(ctx, it, end);
+         if (bool(ctx.error)) [[unlikely]] {
+            return;
+         }
+
+         if constexpr (Opts.partial_read) {
+            n = value.size();
+         }
+
+         if constexpr (std::is_arithmetic_v<std::decay_t<Key>>) {
+            constexpr uint8_t key_tag = tag::number | type | (byte_cnt << 5);
+            Key key;
+            for (size_t i = 0; i < n; ++i) {
+               if constexpr (Opts.partial_read) {
+                  parse<BEVE>::op<no_header_on<Opts>()>(key, key_tag, ctx, it, end);
+                  if (auto element = value.find(key); element != value.end()) {
+                     parse<BEVE>::op<Opts>(element->second, ctx, it, end);
+                  }
+               }
+               else {
+                  // convert the object tag to the key type tag
+                  parse<BEVE>::op<no_header_on<Opts>()>(key, key_tag, ctx, it, end);
+                  parse<BEVE>::op<Opts>(value[key], ctx, it, end);
+               }
+            }
+         }
+         else {
+            constexpr uint8_t key_tag = tag::string;
+            static thread_local Key key;
+            for (size_t i = 0; i < n; ++i) {
+               if constexpr (Opts.partial_read) {
+                  parse<BEVE>::op<no_header_on<Opts>()>(key, key_tag, ctx, it, end);
+                  if (auto element = value.find(key); element != value.end()) {
+                     parse<BEVE>::op<Opts>(element->second, ctx, it, end);
+                  }
+               }
+               else {
+                  parse<BEVE>::op<no_header_on<Opts>()>(key, key_tag, ctx, it, end);
+                  parse<BEVE>::op<Opts>(value[key], ctx, it, end);
+               }
+            }
+         }
+      }
+   };
+
+   template <nullable_t T>
+      requires(std::is_array_v<T>)
+   struct from<BEVE, T> final
+   {
+      template <auto Opts, class V, size_t N>
+      GLZ_ALWAYS_INLINE static void op(V (&value)[N], is_context auto&& ctx, auto&& it, auto&& end) noexcept
+      {
+         parse<BEVE>::op<Opts>(std::span{value, N}, ctx, it, end);
+      }
+   };
+
+   template <nullable_t T>
+      requires(!std::is_array_v<T>)
+   struct from<BEVE, T> final
+   {
+      template <auto Opts>
+      GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, auto&& it, auto&& end)
+      {
+         if (invalid_end(ctx, it, end)) {
+            return;
+         }
+         const auto tag = uint8_t(*it);
+
+         if (tag == tag::null) {
+            ++it;
+            if constexpr (is_specialization_v<T, std::optional>)
+               value = std::nullopt;
+            else if constexpr (is_specialization_v<T, std::unique_ptr>)
+               value = nullptr;
+            else if constexpr (is_specialization_v<T, std::shared_ptr>)
+               value = nullptr;
+         }
+         else {
+            if (!value) {
+               if constexpr (is_specialization_v<T, std::optional>)
+                  value = std::make_optional<typename T::value_type>();
+               else if constexpr (is_specialization_v<T, std::unique_ptr>)
+                  value = std::make_unique<typename T::element_type>();
+               else if constexpr (is_specialization_v<T, std::shared_ptr>)
+                  value = std::make_shared<typename T::element_type>();
+               else if constexpr (constructible<T>) {
+                  value = meta_construct_v<T>();
+               }
+               else {
+                  ctx.error = error_code::invalid_nullable_read;
+                  return;
+                  // Cannot read into unset nullable that is not std::optional, std::unique_ptr, or std::shared_ptr
+               }
+            }
+            parse<BEVE>::op<Opts>(*value, ctx, it, end);
+         }
+      }
+   };
+
+   template <is_includer T>
+   struct from<BEVE, T>
+   {
+      template <auto Opts>
+      GLZ_ALWAYS_INLINE static void op(auto&&, is_context auto&& ctx, auto&& it, auto&& end) noexcept
+      {
+         if constexpr (check_no_header(Opts)) {
+            skip_compressed_int(ctx, it, end);
+         }
+         else {
+            constexpr uint8_t header = tag::string;
+
+            if (invalid_end(ctx, it, end)) {
+               return;
+            }
+            const auto tag = uint8_t(*it);
+            if (tag != header) [[unlikely]] {
+               ctx.error = error_code::syntax_error;
+               return;
+            }
+
+            ++it;
+            skip_compressed_int(ctx, it, end);
+         }
+      }
+   };
+
+   template <class T>
+      requires((glaze_object_t<T> || reflectable<T>) && not custom_read<T>)
+   struct from<BEVE, T> final
+   {
+      template <auto Opts>
+         requires(Opts.structs_as_arrays == true)
+      static void op(auto&& value, is_context auto&& ctx, auto&& it, auto&& end)
+      {
+         if constexpr (reflectable<T>) {
+            auto t = to_tie(value);
+            parse<BEVE>::op<Opts>(t, ctx, it, end);
+         }
+         else {
+            const auto tag = uint8_t(*it);
+            if (tag != tag::generic_array) [[unlikely]] {
+               ctx.error = error_code::syntax_error;
+               return;
+            }
+            ++it;
+            using V = std::decay_t<T>;
+            constexpr auto N = reflect<V>::size;
+            const auto n = int_from_compressed(ctx, it, end);
+            if (bool(ctx.error)) [[unlikely]] {
+               return;
+            }
+            if (n != N) {
+               ctx.error = error_code::syntax_error;
+               return;
+            }
+
+            for_each<N>(
+               [&]<size_t I>() { parse<BEVE>::op<Opts>(get_member(value, get<I>(reflect<V>::values)), ctx, it, end); });
+         }
+      }
+
+      template <auto Opts>
+         requires(Opts.structs_as_arrays == false)
+      static void op(auto&& value, is_context auto&& ctx, auto&& it, auto&& end)
+      {
+         constexpr uint8_t type = 0; // string key
+         constexpr uint8_t header = tag::object | type;
+
+         if (invalid_end(ctx, it, end)) {
+            return;
+         }
+         const auto tag = uint8_t(*it);
+         if (tag != header) [[unlikely]] {
+            ctx.error = error_code::syntax_error;
+            return;
+         }
+
+         ++it;
+
+         static constexpr auto N = reflect<T>::size;
+
+         static constexpr bit_array<N> all_fields = [] {
+            bit_array<N> arr{};
+            for (size_t i = 0; i < N; ++i) {
+               arr[i] = true;
+            }
+            return arr;
+         }();
+
+         decltype(auto) fields = [&]() -> decltype(auto) {
+            if constexpr (Opts.partial_read) {
+               return bit_array<N>{};
+            }
+            else {
+               return nullptr;
+            }
+         }();
+
+         const auto n_keys = int_from_compressed(ctx, it, end);
+         if (bool(ctx.error)) [[unlikely]] {
+            return;
+         }
+
+         for (size_t i = 0; i < n_keys; ++i) {
+            if constexpr (Opts.partial_read) {
+               if ((all_fields & fields) == all_fields) {
+                  return;
+               }
+            }
+
+            if constexpr (N > 0) {
+               static constexpr auto HashInfo = hash_info<T>;
+
+               const auto n = int_from_compressed(ctx, it, end);
+               if (bool(ctx.error)) [[unlikely]] {
+                  return;
+               }
+               if (uint64_t(end - it) < n || it == end) [[unlikely]] {
+                  ctx.error = error_code::unexpected_end;
+                  return;
+               }
+
+               const auto index = decode_hash_with_size<BEVE, T, HashInfo, HashInfo.type>::op(it, end, n);
+
+               if (index < N) [[likely]] {
+                  if constexpr (Opts.partial_read) {
+                     fields[index] = true;
+                  }
+
+                  const sv key{it, n};
+                  it += n;
+
+                  visit<N>(
+                     [&]<size_t I>() {
+                        static constexpr auto TargetKey = get<I>(reflect<T>::keys);
+                        static constexpr auto Length = TargetKey.size();
+                        if ((Length == n) && compare<Length>(TargetKey.data(), key.data())) [[likely]] {
+                           if constexpr (reflectable<T>) {
+                              parse<BEVE>::op<Opts>(get_member(value, get<I>(to_tie(value))), ctx, it, end);
+                           }
+                           else {
+                              parse<BEVE>::op<Opts>(get_member(value, get<I>(reflect<T>::values)), ctx, it, end);
+                           }
+                        }
+                        else {
+                           if constexpr (Opts.error_on_unknown_keys) {
+                              ctx.error = error_code::unknown_key;
+                              return;
+                           }
+                           else {
+                              skip_value<BEVE>::op<Opts>(ctx, it, end);
+                              if (bool(ctx.error)) [[unlikely]]
+                                 return;
+                           }
+                        }
+                     },
+                     index);
+
+                  if (bool(ctx.error)) [[unlikely]] {
+                     return;
+                  }
+               }
+               else [[unlikely]] {
+                  if constexpr (Opts.error_on_unknown_keys) {
+                     ctx.error = error_code::unknown_key;
+                     return;
+                  }
+                  else {
+                     it += n;
+                     skip_value<BEVE>::op<Opts>(ctx, it, end);
+                     if (bool(ctx.error)) [[unlikely]]
+                        return;
+                  }
+               }
+            }
+            else if constexpr (Opts.error_on_unknown_keys) {
+               ctx.error = error_code::unknown_key;
+               return;
+            }
+            else {
+               skip_value<BEVE>::op<Opts>(ctx, it, end);
+               if (bool(ctx.error)) [[unlikely]]
+                  return;
+            }
+         }
+      }
+   };
+
+   template <class T>
+      requires glaze_array_t<T>
+   struct from<BEVE, T> final
+   {
+      template <auto Opts>
+      static void op(auto&& value, is_context auto&& ctx, auto&& it, auto&& end)
+      {
+         if (invalid_end(ctx, it, end)) {
+            return;
+         }
+         const auto tag = uint8_t(*it);
+         if (tag != tag::generic_array) [[unlikely]] {
+            ctx.error = error_code::syntax_error;
+            return;
+         }
+         ++it;
+
+         constexpr auto N = reflect<T>::size;
+         const auto n = int_from_compressed(ctx, it, end);
+         if (bool(ctx.error)) [[unlikely]] {
+            return;
+         }
+         if (n != N) {
+            ctx.error = error_code::syntax_error;
+            return;
+         }
+
+         for_each<N>(
+            [&]<size_t I>() { parse<BEVE>::op<Opts>(get_member(value, get<I>(reflect<T>::values)), ctx, it, end); });
+      }
+   };
+
+   template <class T>
+      requires(tuple_t<T> || is_std_tuple<T>)
+   struct from<BEVE, T> final
+   {
+      template <auto Opts>
+      static void op(auto&& value, is_context auto&& ctx, auto&& it, auto&& end)
+      {
+         if (invalid_end(ctx, it, end)) {
+            return;
+         }
+         const auto tag = uint8_t(*it);
+         if (tag != tag::generic_array) [[unlikely]] {
+            ctx.error = error_code::syntax_error;
+            return;
+         }
+         ++it;
+
+         using V = std::decay_t<T>;
+         constexpr auto N = glz::tuple_size_v<V>;
+         if constexpr (Opts.partial_read) {
+            const auto n = int_from_compressed(ctx, it, end);
+            if (bool(ctx.error)) [[unlikely]] {
+               return;
+            }
+
+            if constexpr (is_std_tuple<T>) {
+               for_each_short_circuit<N>([&]<auto I>() {
+                  if (I < n) {
+                     parse<BEVE>::op<Opts>(std::get<I>(value), ctx, it, end);
+                     return false; // continue
+                  }
+                  return true; // short circuit
+               });
+            }
+            else {
+               for_each_short_circuit<N>([&]<auto I>() {
+                  if (I < n) {
+                     parse<BEVE>::op<Opts>(glz::get<I>(value), ctx, it, end);
+                     return false; // continue
+                  }
+                  return true; // short circuit
+               });
+            }
+         }
+         else {
+            const auto n = int_from_compressed(ctx, it, end);
+            if (bool(ctx.error)) [[unlikely]] {
+               return;
+            }
+            if (n != N) {
+               ctx.error = error_code::syntax_error;
+               return;
+            }
+
+            if constexpr (is_std_tuple<T>) {
+               for_each<N>([&]<size_t I>() { parse<BEVE>::op<Opts>(std::get<I>(value), ctx, it, end); });
+            }
+            else {
+               for_each<N>([&]<size_t I>() { parse<BEVE>::op<Opts>(glz::get<I>(value), ctx, it, end); });
+            }
+         }
+      }
+   };
+
+   template <filesystem_path T>
+   struct from<BEVE, T>
+   {
+      template <auto Opts>
+      static void op(auto&& value, is_context auto&& ctx, auto&&... args)
+      {
+         static thread_local std::string buffer{};
+         parse<BEVE>::op<Opts>(buffer, ctx, args...);
+         if (bool(ctx.error)) [[unlikely]] {
+            return;
+         }
+         value = buffer;
+      }
+   };
+
+   template <read_supported<BEVE> T, class Buffer>
+   [[nodiscard]] inline error_ctx read_beve(T&& value, Buffer&& buffer)
+   {
+      return read<opts{.format = BEVE}>(value, std::forward<Buffer>(buffer));
+   }
+
+   template <read_supported<BEVE> T, class Buffer>
+   [[nodiscard]] inline expected<T, error_ctx> read_beve(Buffer&& buffer)
+   {
+      T value{};
+      const auto pe = read<opts{.format = BEVE}>(value, std::forward<Buffer>(buffer));
+      if (pe) [[unlikely]] {
+         return unexpected(pe);
+      }
+      return value;
+   }
+
+   template <auto Opts = opts{}, read_supported<BEVE> T>
+   [[nodiscard]] inline error_ctx read_file_beve(T& value, const sv file_name, auto&& buffer)
+   {
+      context ctx{};
+      ctx.current_file = file_name;
+
+      const auto file_error = file_to_buffer(buffer, ctx.current_file);
+
+      if (bool(file_error)) [[unlikely]] {
+         return error_ctx{file_error};
+      }
+
+      return read<set_beve<Opts>()>(value, buffer, ctx);
+   }
+
+   template <read_supported<BEVE> T, class Buffer>
+   [[nodiscard]] inline error_ctx read_binary_untagged(T&& value, Buffer&& buffer)
+   {
+      return read<opts{.format = BEVE, .structs_as_arrays = true}>(std::forward<T>(value),
+                                                                   std::forward<Buffer>(buffer));
+   }
+
+   template <read_supported<BEVE> T, class Buffer>
+   [[nodiscard]] inline expected<T, error_ctx> read_binary_untagged(Buffer&& buffer)
+   {
+      T value{};
+      const auto pe = read<opts{.format = BEVE, .structs_as_arrays = true}>(value, std::forward<Buffer>(buffer));
+      if (pe) [[unlikely]] {
+         return unexpected(pe);
+      }
+      return value;
+   }
+
+   template <auto Opts = opts{}, read_supported<BEVE> T>
+   [[nodiscard]] inline error_ctx read_file_beve_untagged(T& value, const std::string& file_name, auto&& buffer)
+   {
+      return read_file_beve<opt_true<Opts, &opts::structs_as_arrays>>(value, file_name, buffer);
+   }
+}
diff --git a/deps/saucer/include/glaze/beve/skip.hpp b/deps/saucer/include/glaze/beve/skip.hpp
new file mode 100644
index 0000000..c486113
--- /dev/null
+++ b/deps/saucer/include/glaze/beve/skip.hpp
@@ -0,0 +1,241 @@
+// Glaze Library
+// For the license information refer to glaze.hpp
+
+#pragma once
+
+#include "glaze/beve/header.hpp"
+#include "glaze/core/opts.hpp"
+#include "glaze/core/read.hpp"
+#include "glaze/file/file_ops.hpp"
+#include "glaze/util/dump.hpp"
+
+namespace glz
+{
+   template <>
+   struct skip_value<BEVE>
+   {
+      template <auto Opts>
+      inline static void op(is_context auto&& ctx, auto&& it, auto&& end) noexcept;
+   };
+
+   inline void skip_string_beve(is_context auto&& ctx, auto&& it, auto&& end) noexcept
+   {
+      ++it;
+      const auto n = int_from_compressed(ctx, it, end);
+      if (bool(ctx.error)) [[unlikely]] {
+         return;
+      }
+      if (uint64_t(end - it) < n) [[unlikely]] {
+         ctx.error = error_code::unexpected_end;
+         return;
+      }
+      it += n;
+   }
+
+   GLZ_ALWAYS_INLINE void skip_number_beve(is_context auto&& ctx, auto&& it, auto&& end) noexcept
+   {
+      const auto tag = uint8_t(*it);
+      const uint8_t byte_count = byte_count_lookup[tag >> 5];
+      ++it;
+      if ((it + byte_count) > end) [[unlikely]] {
+         ctx.error = error_code::unexpected_end;
+         return;
+      }
+      it += byte_count;
+   }
+
+   template <auto Opts>
+   inline void skip_object_beve(is_context auto&& ctx, auto&& it, auto&& end) noexcept
+   {
+      if (invalid_end(ctx, it, end)) {
+         return;
+      }
+      const auto tag = uint8_t(*it);
+      ++it;
+
+      const auto n_keys = int_from_compressed(ctx, it, end);
+      if (bool(ctx.error)) [[unlikely]] {
+         return;
+      }
+
+      if ((tag & 0b00000'111) == tag::string) {
+         for (size_t i = 0; i < n_keys; ++i) {
+            const auto string_length = int_from_compressed(ctx, it, end);
+            if (bool(ctx.error)) [[unlikely]] {
+               return;
+            }
+            if (uint64_t(end - it) < string_length) [[unlikely]] {
+               ctx.error = error_code::unexpected_end;
+               return;
+            }
+
+            it += string_length;
+
+            skip_value<BEVE>::op<Opts>(ctx, it, end);
+            if (bool(ctx.error)) [[unlikely]]
+               return;
+         }
+      }
+      else if ((tag & 0b00000'111) == tag::number) {
+         const uint8_t byte_count = byte_count_lookup[tag >> 5];
+         for (size_t i = 0; i < n_keys; ++i) {
+            const auto n = int_from_compressed(ctx, it, end);
+            if (bool(ctx.error)) [[unlikely]] {
+               return;
+            }
+            if (uint64_t(end - it) < byte_count * n) [[unlikely]] {
+               ctx.error = error_code::unexpected_end;
+               return;
+            }
+
+            it += byte_count * n;
+
+            skip_value<BEVE>::op<Opts>(ctx, it, end);
+            if (bool(ctx.error)) [[unlikely]]
+               return;
+         }
+      }
+      else {
+         ctx.error = error_code::syntax_error;
+         return;
+      }
+   }
+
+   template <auto Opts>
+   inline void skip_typed_array_beve(is_context auto&& ctx, auto&& it, auto&& end) noexcept
+   {
+      const auto tag = uint8_t(*it);
+      const uint8_t type = (tag & 0b000'11'000) >> 3;
+      switch (type) {
+      case 0: // floating point (fallthrough)
+      case 1: // signed integer (fallthrough)
+      case 2: { // unsigned integer
+         ++it;
+         const auto n = int_from_compressed(ctx, it, end);
+         if (bool(ctx.error)) [[unlikely]] {
+            return;
+         }
+         const uint8_t byte_count = byte_count_lookup[tag >> 5];
+         if (uint64_t(end - it) < byte_count * n) [[unlikely]] {
+            ctx.error = error_code::unexpected_end;
+            return;
+         }
+         it += byte_count * n;
+         break;
+      }
+      case 3: { // bool or string
+         const bool is_bool = (tag & 0b00'1'00'000) >> 5;
+         ++it;
+         if (is_bool) {
+            const auto n = int_from_compressed(ctx, it, end);
+            if (bool(ctx.error)) [[unlikely]] {
+               return;
+            }
+
+            const auto num_bytes = (n + 7) / 8;
+            if (uint64_t(end - it) < num_bytes) [[unlikely]] {
+               ctx.error = error_code::unexpected_end;
+               return;
+            }
+            it += num_bytes;
+         }
+         else {
+            const auto n = int_from_compressed(ctx, it, end);
+            if (bool(ctx.error)) [[unlikely]] {
+               return;
+            }
+            if (uint64_t(end - it) < n) [[unlikely]] {
+               ctx.error = error_code::unexpected_end;
+               return;
+            }
+
+            it += n;
+         }
+         break;
+      }
+      default:
+         ctx.error = error_code::syntax_error;
+      }
+   }
+
+   template <auto Opts>
+   inline void skip_untyped_array_beve(is_context auto&& ctx, auto&& it, auto&& end) noexcept
+   {
+      ++it;
+      const auto n = int_from_compressed(ctx, it, end);
+      if (bool(ctx.error)) [[unlikely]] {
+         return;
+      }
+
+      for (size_t i = 0; i < n; ++i) {
+         skip_value<BEVE>::op<Opts>(ctx, it, end);
+      }
+   }
+
+   template <auto Opts>
+      requires(Opts.format == BEVE)
+   void skip_array(is_context auto&& ctx, auto&& it, auto&& end) noexcept
+   {
+      switch (uint8_t(*it) & 0b00000'111) {
+      case tag::typed_array: {
+         skip_typed_array_beve<Opts>(ctx, it, end);
+         break;
+      }
+      case tag::generic_array: {
+         skip_untyped_array_beve<Opts>(ctx, it, end);
+         break;
+      }
+      default:
+         ctx.error = error_code::syntax_error;
+      }
+   }
+
+   template <auto Opts>
+   GLZ_ALWAYS_INLINE void skip_additional_beve(is_context auto&& ctx, auto&& it, auto&& end) noexcept
+   {
+      ++it;
+      skip_value<BEVE>::op<Opts>(ctx, it, end);
+   }
+
+   template <auto Opts>
+   inline void skip_value<BEVE>::op(is_context auto&& ctx, auto&& it, auto&& end) noexcept
+   {
+      using namespace glz::detail;
+
+      if (invalid_end(ctx, it, end)) {
+         return;
+      }
+      switch (uint8_t(*it) & 0b00000'111) {
+      case tag::null: {
+         ++it;
+         break;
+      }
+      case tag::number: {
+         skip_number_beve(ctx, it, end);
+         break;
+      }
+      case tag::string: {
+         skip_string_beve(ctx, it, end);
+         break;
+      }
+      case tag::object: {
+         skip_object_beve<Opts>(ctx, it, end);
+         break;
+      }
+      case tag::typed_array: {
+         skip_typed_array_beve<Opts>(ctx, it, end);
+         break;
+      }
+      case tag::generic_array: {
+         skip_untyped_array_beve<Opts>(ctx, it, end);
+         break;
+      }
+      case tag::extensions: {
+         skip_additional_beve<Opts>(ctx, it, end);
+         break;
+      }
+      default:
+         ctx.error = error_code::syntax_error;
+      }
+   }
+}
diff --git a/deps/saucer/include/glaze/binary/wrappers.hpp b/deps/saucer/include/glaze/beve/wrappers.hpp
similarity index 65%
rename from deps/saucer/include/glaze/binary/wrappers.hpp
rename to deps/saucer/include/glaze/beve/wrappers.hpp
index 1bad91e..dfa9353 100644
--- a/deps/saucer/include/glaze/binary/wrappers.hpp
+++ b/deps/saucer/include/glaze/beve/wrappers.hpp
@@ -5,30 +5,31 @@
 
 #include <type_traits>
 
+#include "glaze/core/custom.hpp"
 #include "glaze/core/opts.hpp"
 #include "glaze/core/wrappers.hpp"
 #include "glaze/json/read.hpp"
 #include "glaze/json/write.hpp"
 
-namespace glz::detail
+namespace glz
 {
    template <is_opts_wrapper T>
-   struct from_binary<T>
+   struct from<BEVE, T>
    {
       template <auto Opts>
-      GLZ_ALWAYS_INLINE static void op(auto&& value, auto&&... args) noexcept
+      GLZ_ALWAYS_INLINE static void op(auto&& value, auto&&... args)
       {
-         read<binary>::op<opt_true<Opts, T::opts_member>>(value.val, args...);
+         parse<BEVE>::op<opt_true<Opts, T::opts_member>>(value.val, args...);
       }
    };
 
    template <is_opts_wrapper T>
-   struct to_binary<T>
+   struct to<BEVE, T>
    {
       template <auto Opts>
-      GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, auto&&... args) noexcept
+      GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, auto&&... args)
       {
-         write<binary>::op<opt_true<Opts, T::opts_member>>(value.val, ctx, args...);
+         serialize<BEVE>::op<opt_true<Opts, T::opts_member>>(value.val, ctx, args...);
       }
    };
 }
diff --git a/deps/saucer/include/glaze/beve/write.hpp b/deps/saucer/include/glaze/beve/write.hpp
new file mode 100644
index 0000000..2113a92
--- /dev/null
+++ b/deps/saucer/include/glaze/beve/write.hpp
@@ -0,0 +1,987 @@
+// Glaze Library
+// For the license information refer to glaze.hpp
+
+#pragma once
+
+#include <utility>
+
+#include "glaze/beve/header.hpp"
+#include "glaze/core/opts.hpp"
+#include "glaze/core/reflect.hpp"
+#include "glaze/core/seek.hpp"
+#include "glaze/core/to.hpp"
+#include "glaze/core/write.hpp"
+#include "glaze/util/dump.hpp"
+#include "glaze/util/for_each.hpp"
+#include "glaze/util/variant.hpp"
+
+namespace glz
+{
+   template <>
+   struct serialize<BEVE>
+   {
+      template <auto Opts, class T, is_context Ctx, class B, class IX>
+      GLZ_ALWAYS_INLINE static void op(T&& value, Ctx&& ctx, B&& b, IX&& ix)
+      {
+         to<BEVE, std::remove_cvref_t<T>>::template op<Opts>(std::forward<T>(value), std::forward<Ctx>(ctx),
+                                                             std::forward<B>(b), std::forward<IX>(ix));
+      }
+
+      template <auto Opts, class T, is_context Ctx, class B, class IX>
+      GLZ_ALWAYS_INLINE static void no_header(T&& value, Ctx&& ctx, B&& b, IX&& ix)
+      {
+         to<BEVE, std::remove_cvref_t<T>>::template no_header<Opts>(std::forward<T>(value), std::forward<Ctx>(ctx),
+                                                                    std::forward<B>(b), std::forward<IX>(ix));
+      }
+   };
+
+   GLZ_ALWAYS_INLINE void dump_type(auto&& value, auto&& b, auto&& ix)
+   {
+      using V = std::decay_t<decltype(value)>;
+      constexpr auto n = sizeof(V);
+      if (const auto k = ix + n; k > b.size()) [[unlikely]] {
+         b.resize(2 * k);
+      }
+
+      constexpr auto is_volatile = std::is_volatile_v<std::remove_reference_t<decltype(value)>>;
+
+      if constexpr (is_volatile) {
+         const V temp = value;
+         std::memcpy(&b[ix], &temp, n);
+      }
+      else {
+         std::memcpy(&b[ix], &value, n);
+      }
+      ix += n;
+   }
+
+   template <uint64_t i, class... Args>
+   GLZ_ALWAYS_INLINE void dump_compressed_int(Args&&... args)
+   {
+      if constexpr (i < 64) {
+         const uint8_t c = uint8_t(i) << 2;
+         dump_type(c, args...);
+      }
+      else if constexpr (i < 16384) {
+         const uint16_t c = uint16_t(1) | (uint16_t(i) << 2);
+         dump_type(c, args...);
+      }
+      else if constexpr (i < 1073741824) {
+         const uint32_t c = uint32_t(2) | (uint32_t(i) << 2);
+         dump_type(c, args...);
+      }
+      else if constexpr (i < 4611686018427387904) {
+         const uint64_t c = uint64_t(3) | (uint64_t(i) << 2);
+         dump_type(c, args...);
+      }
+      else {
+         static_assert(i >= 4611686018427387904, "size not supported");
+      }
+   }
+
+   template <auto Opts, class... Args>
+   GLZ_ALWAYS_INLINE void dump_compressed_int(uint64_t i, Args&&... args)
+   {
+      if (i < 64) {
+         const uint8_t c = uint8_t(i) << 2;
+         dump_type(c, args...);
+      }
+      else if (i < 16384) {
+         const uint16_t c = uint16_t(1) | (uint16_t(i) << 2);
+         dump_type(c, args...);
+      }
+      else if (i < 1073741824) {
+         const uint32_t c = uint32_t(2) | (uint32_t(i) << 2);
+         dump_type(c, args...);
+      }
+      else if (i < 4611686018427387904) {
+         const uint64_t c = uint64_t(3) | (uint64_t(i) << 2);
+         dump_type(c, args...);
+      }
+      else {
+         std::abort(); // this should never happen because we should never allocate containers of this size
+      }
+   }
+
+   template <auto& Partial, auto Opts, class T, class Ctx, class B, class IX>
+   concept write_beve_partial_invocable = requires(T&& value, Ctx&& ctx, B&& b, IX&& ix) {
+      to_partial<BEVE, std::remove_cvref_t<T>>::template op<Partial, Opts>(
+         std::forward<T>(value), std::forward<Ctx>(ctx), std::forward<B>(b), std::forward<IX>(ix));
+   };
+
+   template <>
+   struct serialize_partial<BEVE>
+   {
+      template <auto& Partial, auto Opts, class T, is_context Ctx, class B, class IX>
+      static void op(T&& value, Ctx&& ctx, B&& b, IX&& ix)
+      {
+         if constexpr (std::count(Partial.begin(), Partial.end(), "") > 0) {
+            serialize<BEVE>::op<Opts>(value, ctx, b, ix);
+         }
+         else if constexpr (write_beve_partial_invocable<Partial, Opts, T, Ctx, B, IX>) {
+            to_partial<BEVE, std::remove_cvref_t<T>>::template op<Partial, Opts>(
+               std::forward<T>(value), std::forward<Ctx>(ctx), std::forward<B>(b), std::forward<IX>(ix));
+         }
+         else {
+            static_assert(false_v<T>, "Glaze metadata is probably needed for your type");
+         }
+      }
+   };
+
+   // Only object types are supported for partial
+   template <class T>
+      requires(glaze_object_t<T> || writable_map_t<T> || reflectable<T>)
+   struct to_partial<BEVE, T> final
+   {
+      template <auto& Partial, auto Opts, class... Args>
+      static void op(auto&& value, is_context auto&& ctx, auto&& b, auto&& ix)
+      {
+         static constexpr auto sorted = sort_json_ptrs(Partial);
+         static constexpr auto groups = glz::group_json_ptrs<sorted>();
+         static constexpr auto N = glz::tuple_size_v<std::decay_t<decltype(groups)>>;
+
+         constexpr uint8_t type = 0; // string
+         constexpr uint8_t tag = tag::object | type;
+         dump_type(tag, b, ix);
+
+         dump_compressed_int<N>(b, ix);
+
+         if constexpr (glaze_object_t<T>) {
+            for_each<N>([&]<auto I>() {
+               if (bool(ctx.error)) [[unlikely]] {
+                  return;
+               }
+
+               static constexpr auto group = glz::get<I>(groups);
+
+               static constexpr auto key = get<0>(group);
+               static constexpr auto sub_partial = get<1>(group);
+               static constexpr auto index = key_index<T>(key);
+               static_assert(index < reflect<T>::size, "Invalid key passed to partial write");
+
+               if constexpr (glaze_object_t<T>) {
+                  static constexpr auto member = get<index>(reflect<T>::values);
+                  serialize<BEVE>::no_header<Opts>(key, ctx, b, ix);
+                  serialize_partial<BEVE>::op<sub_partial, Opts>(get_member(value, member), ctx, b, ix);
+               }
+               else {
+                  serialize<BEVE>::no_header<Opts>(key, ctx, b, ix);
+                  serialize_partial<BEVE>::op<sub_partial, Opts>(get_member(value, get<index>(to_tie(value))), ctx, b,
+                                                                 ix);
+               }
+            });
+         }
+         else if constexpr (writable_map_t<T>) {
+            for_each<N>([&]<auto I>() {
+               if (bool(ctx.error)) [[unlikely]] {
+                  return;
+               }
+
+               static constexpr auto group = glz::get<I>(groups);
+
+               static constexpr auto key_value = get<0>(group);
+               static constexpr auto sub_partial = get<1>(group);
+               if constexpr (findable<std::decay_t<T>, decltype(key_value)>) {
+                  serialize<BEVE>::no_header<Opts>(key_value, ctx, b, ix);
+                  auto it = value.find(key_value);
+                  if (it != value.end()) {
+                     serialize_partial<BEVE>::op<sub_partial, Opts>(it->second, ctx, b, ix);
+                  }
+                  else {
+                     ctx.error = error_code::invalid_partial_key;
+                     return;
+                  }
+               }
+               else {
+                  static thread_local auto key =
+                     typename std::decay_t<T>::key_type(key_value); // TODO handle numeric keys
+                  serialize<BEVE>::no_header<Opts>(key, ctx, b, ix);
+                  auto it = value.find(key);
+                  if (it != value.end()) {
+                     serialize_partial<BEVE>::op<sub_partial, Opts>(it->second, ctx, b, ix);
+                  }
+                  else {
+                     ctx.error = error_code::invalid_partial_key;
+                     return;
+                  }
+               }
+            });
+         }
+      }
+   };
+
+   template <class T>
+      requires(glaze_value_t<T> && !custom_write<T>)
+   struct to<BEVE, T>
+   {
+      template <auto Opts, class Value, is_context Ctx, class B, class IX>
+      GLZ_ALWAYS_INLINE static void op(Value&& value, Ctx&& ctx, B&& b, IX&& ix)
+      {
+         using V = std::remove_cvref_t<decltype(get_member(std::declval<Value>(), meta_wrapper_v<T>))>;
+         to<BEVE, V>::template op<Opts>(get_member(std::forward<Value>(value), meta_wrapper_v<T>),
+                                        std::forward<Ctx>(ctx), std::forward<B>(b), std::forward<IX>(ix));
+      }
+   };
+
+   template <always_null_t T>
+   struct to<BEVE, T>
+   {
+      template <auto Opts>
+      GLZ_ALWAYS_INLINE static void op(auto&&, is_context auto&&, auto&&... args)
+      {
+         dump_type(uint8_t{0}, args...);
+      }
+   };
+
+   template <is_bitset T>
+   struct to<BEVE, T>
+   {
+      template <auto Opts, class... Args>
+      static void op(auto&& value, is_context auto&&, auto&&... args)
+      {
+         constexpr uint8_t type = uint8_t(3) << 3;
+         constexpr uint8_t tag = tag::typed_array | type;
+         dump_type(tag, args...);
+         dump_compressed_int<Opts>(value.size(), args...);
+
+         // constexpr auto num_bytes = (value.size() + 7) / 8;
+         const auto num_bytes = (value.size() + 7) / 8;
+         // .size() should be constexpr, but clang doesn't support this
+         std::vector<uint8_t> bytes(num_bytes);
+         // std::array<uint8_t, num_bytes> bytes{};
+         for (size_t byte_i{}, i{}; byte_i < num_bytes; ++byte_i) {
+            for (size_t bit_i = 0; bit_i < 8 && i < value.size(); ++bit_i, ++i) {
+               bytes[byte_i] |= uint8_t(value[i]) << uint8_t(bit_i);
+            }
+         }
+         dump(bytes, args...);
+      }
+   };
+
+   template <glaze_flags_t T>
+   struct to<BEVE, T>
+   {
+      template <auto Opts>
+      static void op(auto&& value, is_context auto&&, auto&& b, auto&& ix)
+      {
+         static constexpr auto N = reflect<T>::size;
+
+         std::array<uint8_t, byte_length<T>()> data{};
+
+         for_each<N>([&]<size_t I>() {
+            data[I / 8] |= static_cast<uint8_t>(get_member(value, get<I>(reflect<T>::values))) << (7 - (I % 8));
+         });
+
+         dump(data, b, ix);
+      }
+   };
+
+   template <is_member_function_pointer T>
+   struct to<BEVE, T>
+   {
+      template <auto Opts, class... Args>
+      GLZ_ALWAYS_INLINE static void op(auto&&, is_context auto&&, Args&&...) noexcept
+      {}
+   };
+
+   // write includers as empty strings
+   template <is_includer T>
+   struct to<BEVE, T>
+   {
+      template <auto Opts, class... Args>
+      GLZ_ALWAYS_INLINE static void op(auto&&, is_context auto&&, Args&&... args)
+      {
+         constexpr uint8_t tag = tag::string;
+
+         dump_type(tag, args...);
+         dump_compressed_int<Opts>(0, args...);
+      }
+   };
+
+   template <boolean_like T>
+   struct to<BEVE, T> final
+   {
+      template <auto Opts, class... Args>
+      GLZ_ALWAYS_INLINE static void op(const bool value, is_context auto&&, Args&&... args)
+      {
+         dump_type(value ? tag::bool_true : tag::bool_false, args...);
+      }
+   };
+
+   template <func_t T>
+   struct to<BEVE, T> final
+   {
+      template <auto Opts, class... Args>
+      GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, Args&&... args)
+      {
+         serialize<BEVE>::op<Opts>(name_v<std::decay_t<decltype(value)>>, ctx, args...);
+      }
+   };
+
+   template <class T>
+   struct to<BEVE, basic_raw_json<T>> final
+   {
+      template <auto Opts, class... Args>
+      GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, Args&&... args)
+      {
+         serialize<BEVE>::op<Opts>(value.str, ctx, std::forward<Args>(args)...);
+      }
+   };
+
+   template <class T>
+   struct to<BEVE, basic_text<T>> final
+   {
+      template <auto Opts, class... Args>
+      GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, Args&&... args)
+      {
+         serialize<BEVE>::op<Opts>(value.str, ctx, std::forward<Args>(args)...);
+      }
+   };
+
+   template <class T, class V>
+   constexpr size_t variant_index_v = []<size_t... I>(std::index_sequence<I...>) {
+      return ((std::is_same_v<T, std::variant_alternative_t<I, V>> * I) + ...);
+   }(std::make_index_sequence<std::variant_size_v<V>>{});
+
+   template <is_variant T>
+   struct to<BEVE, T> final
+   {
+      template <auto Opts, class... Args>
+      static void op(auto&& value, is_context auto&& ctx, Args&&... args)
+      {
+         using Variant = std::decay_t<decltype(value)>;
+
+         std::visit(
+            [&](auto&& v) {
+               using V = std::decay_t<decltype(v)>;
+
+               static constexpr uint64_t index = variant_index_v<V, Variant>;
+
+               constexpr uint8_t tag = tag::extensions | 0b00001'000;
+
+               dump_type(tag, args...);
+               dump_compressed_int<index>(args...);
+               serialize<BEVE>::op<Opts>(v, ctx, args...);
+            },
+            value);
+      }
+   };
+
+   template <class T>
+      requires num_t<T> || char_t<T> || glaze_enum_t<T>
+   struct to<BEVE, T> final
+   {
+      template <auto Opts, class... Args>
+      GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&&, Args&&... args)
+      {
+         constexpr uint8_t type = std::floating_point<T> ? 0 : (std::is_signed_v<T> ? 0b000'01'000 : 0b000'10'000);
+         constexpr uint8_t tag = tag::number | type | (byte_count<T> << 5);
+         dump_type(tag, args...);
+         dump_type(value, args...);
+      }
+
+      template <auto Opts>
+      GLZ_ALWAYS_INLINE static void no_header(auto&& value, is_context auto&&, auto&&... args)
+      {
+         dump_type(value, args...);
+      }
+   };
+
+   template <class T>
+      requires(std::is_enum_v<T> && !glaze_enum_t<T>)
+   struct to<BEVE, T> final
+   {
+      template <auto Opts, class... Args>
+      GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&&, Args&&... args)
+      {
+         using V = std::underlying_type_t<std::decay_t<T>>;
+
+         constexpr uint8_t type = std::floating_point<V> ? 0 : (std::is_signed_v<V> ? 0b000'01'000 : 0b000'10'000);
+         constexpr uint8_t tag = tag::number | type | (byte_count<V> << 5);
+         dump_type(tag, args...);
+         dump_type(value, args...);
+      }
+
+      template <auto Opts>
+      GLZ_ALWAYS_INLINE static void no_header(auto&& value, is_context auto&&, auto&&... args)
+      {
+         dump_type(value, args...);
+      }
+   };
+
+   template <class T>
+      requires complex_t<T>
+   struct to<BEVE, T> final
+   {
+      template <auto Opts>
+      GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&&, auto&&... args)
+      {
+         constexpr uint8_t tag = tag::extensions | 0b00011'000;
+         dump_type(tag, args...);
+
+         using V = typename T::value_type;
+         constexpr uint8_t complex_number = 0;
+         constexpr uint8_t type = std::floating_point<V> ? 0 : (std::is_signed_v<V> ? 0b000'01'000 : 0b000'10'000);
+         constexpr uint8_t complex_header = complex_number | type | (byte_count<V> << 5);
+         dump_type(complex_header, args...);
+         dump_type(value.real(), args...);
+         dump_type(value.imag(), args...);
+      }
+
+      template <auto Opts>
+      GLZ_ALWAYS_INLINE static void no_header(auto&& value, is_context auto&&, auto&&... args)
+      {
+         dump_type(value.real(), args...);
+         dump_type(value.imag(), args...);
+      }
+   };
+
+   template <str_t T>
+   struct to<BEVE, T> final
+   {
+      template <auto Opts>
+      GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&&, auto&& b, auto&& ix)
+      {
+         const sv str = [&]() -> const sv {
+            if constexpr (!char_array_t<T> && std::is_pointer_v<std::decay_t<T>>) {
+               return value ? value : "";
+            }
+            else {
+               return value;
+            }
+         }();
+
+         constexpr uint8_t tag = tag::string;
+
+         dump_type(tag, b, ix);
+         const auto n = str.size();
+         dump_compressed_int<Opts>(n, b, ix);
+
+         if (const auto k = ix + n; k > b.size()) [[unlikely]] {
+            b.resize(2 * k);
+         }
+
+         if (n) {
+            std::memcpy(&b[ix], str.data(), n);
+            ix += n;
+         }
+      }
+
+      template <auto Opts>
+      GLZ_ALWAYS_INLINE static void no_header(auto&& value, is_context auto&&, auto&& b, auto&& ix)
+      {
+         dump_compressed_int<Opts>(value.size(), b, ix);
+
+         const auto n = value.size();
+         if (const auto k = ix + n; k > b.size()) [[unlikely]] {
+            b.resize(2 * k);
+         }
+
+         if (n) {
+            std::memcpy(&b[ix], value.data(), n);
+            ix += n;
+         }
+      }
+   };
+
+   template <writable_array_t T>
+   struct to<BEVE, T> final
+   {
+      static constexpr bool map_like_array = pair_t<range_value_t<T>>;
+
+      template <auto Opts>
+         requires(map_like_array ? check_concatenate(Opts) == false : true)
+      static void op(auto&& value, is_context auto&& ctx, auto&& b, auto&& ix)
+      {
+         using V = range_value_t<std::decay_t<T>>;
+
+         if constexpr (boolean_like<V>) {
+            constexpr uint8_t type = uint8_t(3) << 3;
+            constexpr uint8_t tag = tag::typed_array | type;
+            dump_type(tag, b, ix);
+            dump_compressed_int<Opts>(value.size(), b, ix);
+
+            // booleans must be dumped using single bits
+            if constexpr (has_static_size<T>) {
+               constexpr auto num_bytes = (value.size() + 7) / 8;
+               std::array<uint8_t, num_bytes> bytes{};
+               for (size_t byte_i{}, i{}; byte_i < num_bytes; ++byte_i) {
+                  for (size_t bit_i = 7; bit_i < 8 && i < value.size(); --bit_i, ++i) {
+                     bytes[byte_i] |= uint8_t(value[i]) << uint8_t(bit_i);
+                  }
+               }
+               dump(bytes, b, ix);
+            }
+            else if constexpr (accessible<T>) {
+               const auto num_bytes = (value.size() + 7) / 8;
+               for (size_t byte_i{}, i{}; byte_i < num_bytes; ++byte_i) {
+                  uint8_t byte{};
+                  for (size_t bit_i = 7; bit_i < 8 && i < value.size(); --bit_i, ++i) {
+                     byte |= uint8_t(value[i]) << uint8_t(bit_i);
+                  }
+                  dump_type(byte, b, ix);
+               }
+            }
+            else {
+               static_assert(false_v<T>);
+            }
+         }
+         else if constexpr (num_t<V>) {
+            constexpr uint8_t type = std::floating_point<V> ? 0 : (std::is_signed_v<V> ? 0b000'01'000 : 0b000'10'000);
+            constexpr uint8_t tag = tag::typed_array | type | (byte_count<V> << 5);
+            dump_type(tag, b, ix);
+            dump_compressed_int<Opts>(value.size(), b, ix);
+
+            if constexpr (contiguous<T>) {
+               constexpr auto is_volatile =
+                  std::is_volatile_v<std::remove_reference_t<std::remove_pointer_t<decltype(value.data())>>>;
+
+               auto dump_array = [&](auto&& b, auto&& ix) {
+                  const auto n = value.size() * sizeof(V);
+                  if (const auto k = ix + n; k > b.size()) [[unlikely]] {
+                     b.resize(2 * k);
+                  }
+
+                  if constexpr (is_volatile) {
+                     V temp;
+                     const auto n_elements = value.size();
+                     for (size_t i = 0; i < n_elements; ++i) {
+                        temp = value[i];
+                        std::memcpy(&b[ix], &temp, sizeof(V));
+                        ix += sizeof(V);
+                     }
+                  }
+                  else {
+                     std::memcpy(&b[ix], value.data(), n);
+                     ix += n;
+                  }
+               };
+
+               dump_array(b, ix);
+            }
+            else {
+               for (auto& x : value) {
+                  dump_type(x, b, ix);
+               }
+            }
+         }
+         else if constexpr (str_t<V>) {
+            constexpr uint8_t type = uint8_t(3) << 3;
+            constexpr uint8_t string_indicator = uint8_t(1) << 5;
+            constexpr uint8_t tag = tag::typed_array | type | string_indicator;
+            dump_type(tag, b, ix);
+            dump_compressed_int<Opts>(value.size(), b, ix);
+
+            for (auto& x : value) {
+               dump_compressed_int<Opts>(x.size(), b, ix);
+
+               auto dump_array = [&](auto&& b, auto&& ix) {
+                  const auto n = x.size();
+                  if (const auto k = ix + n; k > b.size()) [[unlikely]] {
+                     b.resize(2 * k);
+                  }
+
+                  if (n) {
+                     std::memcpy(&b[ix], x.data(), n);
+                     ix += n;
+                  }
+               };
+
+               dump_array(b, ix);
+            }
+         }
+         else if constexpr (complex_t<V>) {
+            constexpr uint8_t tag = tag::extensions | 0b00011'000;
+            dump_type(tag, b, ix);
+
+            using X = typename V::value_type;
+            constexpr uint8_t complex_array = 1;
+            constexpr uint8_t type = std::floating_point<X> ? 0 : (std::is_signed_v<X> ? 0b000'01'000 : 0b000'10'000);
+            constexpr uint8_t complex_header = complex_array | type | (byte_count<X> << 5);
+            dump_type(complex_header, b, ix);
+
+            dump_compressed_int<Opts>(value.size(), b, ix);
+
+            if constexpr (contiguous<T>) {
+               const auto n = value.size() * sizeof(V);
+               if (const auto k = ix + n; k > b.size()) [[unlikely]] {
+                  b.resize(2 * k);
+               }
+
+               if (n) {
+                  std::memcpy(&b[ix], value.data(), n);
+                  ix += n;
+               }
+            }
+            else {
+               for (auto&& x : value) {
+                  serialize<BEVE>::no_header<Opts>(x, ctx, b, ix);
+               }
+            }
+         }
+         else {
+            constexpr uint8_t tag = tag::generic_array;
+            dump_type(tag, b, ix);
+            dump_compressed_int<Opts>(value.size(), b, ix);
+
+            for (auto&& x : value) {
+               serialize<BEVE>::op<Opts>(x, ctx, b, ix);
+            }
+         }
+      }
+
+      template <auto Opts>
+         requires(map_like_array && check_concatenate(Opts) == true)
+      static auto op(auto&& value, is_context auto&& ctx, auto&&... args)
+      {
+         using Element = typename T::value_type;
+         using Key = typename Element::first_type;
+
+         constexpr uint8_t type = str_t<Key> ? 0 : (std::is_signed_v<Key> ? 0b000'01'000 : 0b000'10'000);
+         constexpr uint8_t byte_cnt = str_t<Key> ? 0 : byte_count<Key>;
+         constexpr uint8_t tag = tag::object | type | (byte_cnt << 5);
+         dump_type(tag, args...);
+
+         dump_compressed_int<Opts>(value.size(), args...);
+         for (auto&& [k, v] : value) {
+            serialize<BEVE>::no_header<Opts>(k, ctx, args...);
+            serialize<BEVE>::op<Opts>(v, ctx, args...);
+         }
+      }
+   };
+
+   template <pair_t T>
+   struct to<BEVE, T> final
+   {
+      template <auto Opts, class... Args>
+      GLZ_ALWAYS_INLINE static auto op(auto&& value, is_context auto&& ctx, Args&&... args)
+      {
+         using Key = typename T::first_type;
+
+         constexpr uint8_t type = str_t<Key> ? 0 : (std::is_signed_v<Key> ? 0b000'01'000 : 0b000'10'000);
+         constexpr uint8_t byte_cnt = str_t<Key> ? 0 : byte_count<Key>;
+         constexpr uint8_t tag = tag::object | type | (byte_cnt << 5);
+         dump_type(tag, args...);
+
+         dump_compressed_int<Opts>(1, args...);
+         const auto& [k, v] = value;
+         serialize<BEVE>::no_header<Opts>(k, ctx, args...);
+         serialize<BEVE>::op<Opts>(v, ctx, args...);
+      }
+   };
+
+   template <writable_map_t T>
+   struct to<BEVE, T> final
+   {
+      template <auto Opts, class... Args>
+      static auto op(auto&& value, is_context auto&& ctx, Args&&... args)
+      {
+         using Key = typename T::key_type;
+
+         constexpr uint8_t type = str_t<Key> ? 0 : (std::is_signed_v<Key> ? 0b000'01'000 : 0b000'10'000);
+         constexpr uint8_t byte_cnt = str_t<Key> ? 0 : byte_count<Key>;
+         constexpr uint8_t tag = tag::object | type | (byte_cnt << 5);
+         dump_type(tag, args...);
+
+         dump_compressed_int<Opts>(value.size(), args...);
+         for (auto&& [k, v] : value) {
+            serialize<BEVE>::no_header<Opts>(k, ctx, args...);
+            serialize<BEVE>::op<Opts>(v, ctx, args...);
+         }
+      }
+   };
+
+   template <nullable_t T>
+      requires(std::is_array_v<T>)
+   struct to<BEVE, T>
+   {
+      template <auto Opts, class V, size_t N, class... Args>
+      GLZ_ALWAYS_INLINE static void op(const V (&value)[N], is_context auto&& ctx, Args&&... args)
+      {
+         serialize<BEVE>::op<Opts>(std::span{value, N}, ctx, std::forward<Args>(args)...);
+      }
+   };
+
+   template <nullable_t T>
+      requires(!std::is_array_v<T>)
+   struct to<BEVE, T> final
+   {
+      template <auto Opts, class... Args>
+      GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, Args&&... args)
+      {
+         if (value) {
+            serialize<BEVE>::op<Opts>(*value, ctx, args...);
+         }
+         else {
+            dump<tag::null>(args...);
+         }
+      }
+   };
+
+   template <class T>
+      requires is_specialization_v<T, glz::obj> || is_specialization_v<T, glz::obj_copy>
+   struct to<BEVE, T>
+   {
+      template <auto Options>
+      static void op(auto&& value, is_context auto&& ctx, auto&&... args)
+      {
+         using V = std::decay_t<decltype(value.value)>;
+         static constexpr auto N = glz::tuple_size_v<V> / 2;
+
+         if constexpr (!check_opening_handled(Options)) {
+            constexpr uint8_t type = 0; // string key
+            constexpr uint8_t tag = tag::object | type;
+            dump_type(tag, args...);
+            dump_compressed_int<N>(args...);
+         }
+
+         for_each<N>([&]<size_t I>() {
+            constexpr auto Opts = opening_handled_off<Options>();
+            serialize<BEVE>::no_header<Opts>(get<2 * I>(value.value), ctx, args...);
+            serialize<BEVE>::op<Opts>(get<2 * I + 1>(value.value), ctx, args...);
+         });
+      }
+   };
+
+   template <class T>
+      requires is_specialization_v<T, glz::merge>
+   consteval size_t merge_element_count()
+   {
+      size_t count{};
+      using Tuple = std::decay_t<decltype(std::declval<T>().value)>;
+      for_each<glz::tuple_size_v<Tuple>>([&]<auto I>() constexpr {
+         using Value = std::decay_t<glz::tuple_element_t<I, Tuple>>;
+         if constexpr (is_specialization_v<Value, glz::obj> || is_specialization_v<Value, glz::obj_copy>) {
+            count += glz::tuple_size_v<decltype(std::declval<Value>().value)> / 2;
+         }
+         else {
+            count += reflect<Value>::N;
+         }
+      });
+      return count;
+   }
+
+   template <class T>
+      requires is_specialization_v<T, glz::merge>
+   struct to<BEVE, T>
+   {
+      template <auto Opts>
+      static void op(auto&& value, is_context auto&& ctx, auto&& b, auto&& ix)
+      {
+         using V = std::decay_t<decltype(value.value)>;
+         static constexpr auto N = glz::tuple_size_v<V>;
+
+         constexpr uint8_t type = 0; // string key
+         constexpr uint8_t tag = tag::object | type;
+         dump_type(tag, b, ix);
+         dump_compressed_int<merge_element_count<T>()>(b, ix);
+
+         [&]<size_t... I>(std::index_sequence<I...>) {
+            (serialize<BEVE>::op<opening_handled<Opts>()>(glz::get<I>(value.value), ctx, b, ix), ...);
+         }(std::make_index_sequence<N>{});
+      }
+   };
+
+   template <class T>
+      requires((glaze_object_t<T> || reflectable<T>) && not custom_write<T>)
+   struct to<BEVE, T> final
+   {
+      static constexpr auto N = reflect<T>::size;
+      static constexpr size_t count_to_write = [] {
+         size_t count{};
+         for_each<N>([&]<size_t I>() {
+            using V = field_t<T, I>;
+
+            if constexpr (std::same_as<V, hidden> || std::same_as<V, skip>) {
+               // do not serialize
+               // not serializing is_includer<V> would be a breaking change
+            }
+            else {
+               ++count;
+            }
+         });
+         return count;
+      }();
+
+      template <auto Opts, class... Args>
+         requires(Opts.structs_as_arrays == true)
+      static void op(auto&& value, is_context auto&& ctx, Args&&... args)
+      {
+         dump<tag::generic_array>(args...);
+         dump_compressed_int<count_to_write>(args...);
+
+         [[maybe_unused]] decltype(auto) t = [&]() -> decltype(auto) {
+            if constexpr (reflectable<T>) {
+               return to_tie(value);
+            }
+            else {
+               return nullptr;
+            }
+         }();
+
+         for_each<N>([&]<size_t I>() {
+            using val_t = field_t<T, I>;
+
+            if constexpr (std::same_as<val_t, hidden> || std::same_as<val_t, skip>) {
+               return;
+            }
+            else {
+               if constexpr (reflectable<T>) {
+                  serialize<BEVE>::op<Opts>(get_member(value, get<I>(t)), ctx, args...);
+               }
+               else {
+                  serialize<BEVE>::op<Opts>(get_member(value, get<I>(reflect<T>::values)), ctx, args...);
+               }
+            }
+         });
+      }
+
+      template <auto Options, class... Args>
+         requires(Options.structs_as_arrays == false)
+      static void op(auto&& value, is_context auto&& ctx, Args&&... args)
+      {
+         if constexpr (!check_opening_handled(Options)) {
+            constexpr uint8_t type = 0; // string key
+            constexpr uint8_t tag = tag::object | type;
+            dump_type(tag, args...);
+            dump_compressed_int<count_to_write>(args...);
+         }
+         constexpr auto Opts = opening_handled_off<Options>();
+
+         [[maybe_unused]] decltype(auto) t = [&]() -> decltype(auto) {
+            if constexpr (reflectable<T>) {
+               return to_tie(value);
+            }
+            else {
+               return nullptr;
+            }
+         }();
+
+         for_each<N>([&]<size_t I>() {
+            using val_t = field_t<T, I>;
+
+            if constexpr (std::same_as<val_t, hidden> || std::same_as<val_t, skip>) {
+               return;
+            }
+            else {
+               static constexpr sv key = reflect<T>::keys[I];
+               serialize<BEVE>::no_header<Opts>(key, ctx, args...);
+
+               decltype(auto) member = [&]() -> decltype(auto) {
+                  if constexpr (reflectable<T>) {
+                     return get<I>(t);
+                  }
+                  else {
+                     return get<I>(reflect<T>::values);
+                  }
+               }();
+
+               serialize<BEVE>::op<Opts>(get_member(value, member), ctx, args...);
+            }
+         });
+      }
+   };
+
+   template <class T>
+      requires glaze_array_t<T>
+   struct to<BEVE, T> final
+   {
+      template <auto Opts, class... Args>
+      static void op(auto&& value, is_context auto&& ctx, Args&&... args)
+      {
+         dump<tag::generic_array>(args...);
+
+         static constexpr auto N = reflect<T>::size;
+         dump_compressed_int<N>(args...);
+
+         for_each<reflect<T>::size>([&]<size_t I>() {
+            serialize<BEVE>::op<Opts>(get_member(value, get<I>(reflect<T>::values)), ctx, args...);
+         });
+      }
+   };
+
+   template <class T>
+      requires(tuple_t<T> || is_std_tuple<T>)
+   struct to<BEVE, T> final
+   {
+      template <auto Opts, class... Args>
+      static void op(auto&& value, is_context auto&& ctx, Args&&... args)
+      {
+         dump<tag::generic_array>(args...);
+
+         static constexpr auto N = glz::tuple_size_v<T>;
+         dump_compressed_int<N>(args...);
+
+         if constexpr (is_std_tuple<T>) {
+            [&]<size_t... I>(std::index_sequence<I...>) {
+               (serialize<BEVE>::op<Opts>(std::get<I>(value), ctx, args...), ...);
+            }(std::make_index_sequence<N>{});
+         }
+         else {
+            [&]<size_t... I>(std::index_sequence<I...>) {
+               (serialize<BEVE>::op<Opts>(glz::get<I>(value), ctx, args...), ...);
+            }(std::make_index_sequence<N>{});
+         }
+      }
+   };
+
+   template <write_supported<BEVE> T, class Buffer>
+   [[nodiscard]] error_ctx write_beve(T&& value, Buffer&& buffer)
+   {
+      return write<opts{.format = BEVE}>(std::forward<T>(value), std::forward<Buffer>(buffer));
+   }
+
+   template <auto Opts = opts{}, write_supported<BEVE> T>
+   [[nodiscard]] glz::expected<std::string, error_ctx> write_beve(T&& value)
+   {
+      return write<set_beve<Opts>()>(std::forward<T>(value));
+   }
+
+   template <auto& Partial, write_supported<BEVE> T, class Buffer>
+   [[nodiscard]] error_ctx write_beve(T&& value, Buffer&& buffer)
+   {
+      return write<Partial, opts{.format = BEVE}>(std::forward<T>(value), std::forward<Buffer>(buffer));
+   }
+
+   // requires file_name to be null terminated
+   template <auto Opts = opts{}, write_supported<BEVE> T>
+   [[nodiscard]] error_ctx write_file_beve(T&& value, const sv file_name, auto&& buffer)
+   {
+      static_assert(sizeof(decltype(*buffer.data())) == 1);
+
+      const auto ec = write<set_beve<Opts>()>(std::forward<T>(value), buffer);
+      if (bool(ec)) [[unlikely]] {
+         return ec;
+      }
+
+      std::ofstream file(file_name.data(), std::ios::binary);
+
+      if (file) {
+         file.write(reinterpret_cast<const char*>(buffer.data()), buffer.size());
+      }
+      else {
+         return {error_code::file_open_failure};
+      }
+
+      return {};
+   }
+
+   template <write_supported<BEVE> T, class Buffer>
+   [[nodiscard]] error_ctx write_beve_untagged(T&& value, Buffer&& buffer)
+   {
+      return write<opts{.format = BEVE, .structs_as_arrays = true}>(std::forward<T>(value),
+                                                                    std::forward<Buffer>(buffer));
+   }
+
+   template <write_supported<BEVE> T>
+   [[nodiscard]] glz::expected<std::string, error_ctx> write_beve_untagged(T&& value)
+   {
+      return write<opts{.format = BEVE, .structs_as_arrays = true}>(std::forward<T>(value));
+   }
+
+   template <auto Opts = opts{}, write_supported<BEVE> T>
+   [[nodiscard]] error_ctx write_file_beve_untagged(T&& value, const std::string& file_name, auto&& buffer)
+   {
+      return write_file_beve<opt_true<Opts, &opts::structs_as_arrays>>(std::forward<T>(value), file_name, buffer);
+   }
+}
diff --git a/deps/saucer/include/glaze/binary.hpp b/deps/saucer/include/glaze/binary.hpp
deleted file mode 100644
index 419f815..0000000
--- a/deps/saucer/include/glaze/binary.hpp
+++ /dev/null
@@ -1,11 +0,0 @@
-// Glaze Library
-// For the license information refer to glaze.hpp
-
-#pragma once
-
-#include "glaze/binary/custom.hpp"
-#include "glaze/binary/header.hpp"
-#include "glaze/binary/ptr.hpp"
-#include "glaze/binary/read.hpp"
-#include "glaze/binary/wrappers.hpp"
-#include "glaze/binary/write.hpp"
diff --git a/deps/saucer/include/glaze/binary/custom.hpp b/deps/saucer/include/glaze/binary/custom.hpp
deleted file mode 100644
index 9c7e57b..0000000
--- a/deps/saucer/include/glaze/binary/custom.hpp
+++ /dev/null
@@ -1,192 +0,0 @@
-// Glaze Library
-// For the license information refer to glaze.hpp
-
-#pragma once
-
-#include "glaze/binary/read.hpp"
-#include "glaze/binary/write.hpp"
-#include "glaze/core/seek.hpp"
-#include "glaze/core/wrappers.hpp"
-
-namespace glz::detail
-{
-   template <class T>
-      requires(is_specialization_v<T, custom_t>)
-   struct from_binary<T>
-   {
-      template <auto Opts>
-      GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, auto&& it, auto&& end) noexcept
-      {
-         using V = std::decay_t<decltype(value)>;
-         using From = typename V::from_t;
-
-         if constexpr (std::same_as<From, skip>) {
-            skip_value_binary<Opts>(ctx, it, end);
-         }
-         else if constexpr (std::is_member_pointer_v<From>) {
-            if constexpr (std::is_member_function_pointer_v<From>) {
-               using Ret = typename return_type<From>::type;
-               if constexpr (std::is_void_v<Ret>) {
-                  using Tuple = typename inputs_as_tuple<From>::type;
-                  if constexpr (glz::tuple_size_v<Tuple> == 0) {
-                     skip_array_binary<Opts>(ctx, it, end);
-                     if (bool(ctx.error)) [[unlikely]]
-                        return;
-                     (value.val.*(value.from))();
-                  }
-                  else if constexpr (glz::tuple_size_v<Tuple> == 1) {
-                     std::decay_t<glz::tuple_element_t<0, Tuple>> input{};
-                     read<binary>::op<Opts>(input, ctx, it, end);
-                     if (bool(ctx.error)) [[unlikely]]
-                        return;
-                     (value.val.*(value.from))(input);
-                  }
-                  else {
-                     static_assert(false_v<T>, "function cannot have more than one input");
-                  }
-               }
-               else {
-                  static_assert(false_v<T>, "function must have void return");
-               }
-            }
-            else if constexpr (std::is_member_object_pointer_v<From>) {
-               auto& from = value.val.*(value.from);
-               using Func = std::decay_t<decltype(from)>;
-               if constexpr (is_specialization_v<Func, std::function>) {
-                  using Ret = typename function_traits<Func>::result_type;
-
-                  if constexpr (std::is_void_v<Ret>) {
-                     using Tuple = typename function_traits<Func>::arguments;
-                     if constexpr (glz::tuple_size_v<Tuple> == 0) {
-                        skip_array_binary<Opts>(ctx, it, end);
-                        if (bool(ctx.error)) [[unlikely]]
-                           return;
-                        from();
-                     }
-                     else if constexpr (glz::tuple_size_v<Tuple> == 1) {
-                        std::decay_t<glz::tuple_element_t<0, Tuple>> input{};
-                        read<binary>::op<Opts>(input, ctx, it, end);
-                        if (bool(ctx.error)) [[unlikely]]
-                           return;
-                        from(input);
-                     }
-                     else {
-                        static_assert(false_v<T>, "function cannot have more than one input");
-                     }
-                  }
-                  else {
-                     static_assert(false_v<T>, "std::function must have void return");
-                  }
-               }
-               else {
-                  read<binary>::op<Opts>(from, ctx, it, end);
-               }
-            }
-            else {
-               static_assert(false_v<T>, "invalid type for custom");
-            }
-         }
-         else {
-            if constexpr (is_invocable_concrete<From>) {
-               using Ret = invocable_result_t<From>;
-               if constexpr (std::is_void_v<Ret>) {
-                  using Tuple = invocable_args_t<From>;
-                  constexpr auto N = glz::tuple_size_v<Tuple>;
-                  if constexpr (N == 0) {
-                     static_assert(false_v<T>, "lambda must take in the class as the first argument");
-                  }
-                  else if constexpr (N == 1) {
-                     skip_array_binary<Opts>(ctx, it, end);
-                     if (bool(ctx.error)) [[unlikely]]
-                        return;
-                     value.from(value.val);
-                  }
-                  else if constexpr (N == 2) {
-                     std::decay_t<glz::tuple_element_t<1, Tuple>> input{};
-                     read<binary>::op<Opts>(input, ctx, it, end);
-                     if (bool(ctx.error)) [[unlikely]]
-                        return;
-                     value.from(value.val, input);
-                  }
-                  else {
-                     static_assert(false_v<T>, "lambda cannot have more than two inputs");
-                  }
-               }
-               else {
-                  static_assert(false_v<T>, "lambda must have void return");
-               }
-            }
-            else if constexpr (std::invocable<From, decltype(value.val)>) {
-               read<binary>::op<Opts>(value.from(value.val), ctx, it, end);
-            }
-            else {
-               static_assert(
-                  false_v<T>,
-                  "IMPORTANT: If you have two arguments in your lambda (e.g. [](my_struct&, const std::string& "
-                  "input)) you must make all the arguments concrete types. None of the inputs can be `auto`. Also, "
-                  "you probably cannot define these lambdas within a local `struct glaze`, but instead need to use "
-                  "`glz::meta` outside your class so that your lambda can operate on a defined class.");
-            }
-         }
-      }
-   };
-
-   template <class T>
-      requires(is_specialization_v<T, custom_t>)
-   struct to_binary<T>
-   {
-      template <auto Opts>
-      GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, auto&&... args) noexcept
-      {
-         using V = std::decay_t<decltype(value)>;
-         using To = typename V::to_t;
-
-         if constexpr (std::is_member_pointer_v<To>) {
-            if constexpr (std::is_member_function_pointer_v<To>) {
-               using Tuple = typename inputs_as_tuple<To>::type;
-               if constexpr (glz::tuple_size_v<Tuple> == 0) {
-                  write<binary>::op<Opts>((value.val.*(value.to))(), ctx, args...);
-               }
-               else {
-                  static_assert(false_v<T>, "function cannot have inputs");
-               }
-            }
-            else if constexpr (std::is_member_object_pointer_v<To>) {
-               auto& to = value.val.*(value.to);
-               using Func = std::decay_t<decltype(to)>;
-               if constexpr (is_specialization_v<Func, std::function>) {
-                  using Ret = typename function_traits<Func>::result_type;
-
-                  if constexpr (std::is_void_v<Ret>) {
-                     static_assert(false_v<T>, "conversion to JSON must return a value");
-                  }
-                  else {
-                     using Tuple = typename function_traits<Func>::arguments;
-                     if constexpr (glz::tuple_size_v<Tuple> == 0) {
-                        write<binary>::op<Opts>(to(), ctx, args...);
-                     }
-                     else {
-                        static_assert(false_v<T>, "std::function cannot have inputs");
-                     }
-                  }
-               }
-               else {
-                  write<binary>::op<Opts>(to, ctx, args...);
-               }
-            }
-            else {
-               static_assert(false_v<T>, "invalid type for custom");
-            }
-         }
-         else {
-            if constexpr (std::invocable<To, decltype(value.val)>) {
-               write<binary>::op<Opts>(std::invoke(value.to, value.val), ctx, args...);
-            }
-            else {
-               static_assert(false_v<To>,
-                             "expected invocable function, perhaps you need const qualified input on your lambda");
-            }
-         }
-      }
-   };
-}
diff --git a/deps/saucer/include/glaze/binary/read.hpp b/deps/saucer/include/glaze/binary/read.hpp
deleted file mode 100644
index 4b2730f..0000000
--- a/deps/saucer/include/glaze/binary/read.hpp
+++ /dev/null
@@ -1,1364 +0,0 @@
-// Glaze Library
-// For the license information refer to glaze.hpp
-
-#pragma once
-
-#include "glaze/binary/header.hpp"
-#include "glaze/binary/skip.hpp"
-#include "glaze/core/opts.hpp"
-#include "glaze/core/read.hpp"
-#include "glaze/file/file_ops.hpp"
-#include "glaze/reflection/reflect.hpp"
-#include "glaze/util/dump.hpp"
-
-namespace glz
-{
-   namespace detail
-   {
-      template <>
-      struct read<binary>
-      {
-         template <auto Opts, class T, class Tag, is_context Ctx, class It0, class It1>
-            requires(Opts.no_header)
-         GLZ_ALWAYS_INLINE static void op(T&& value, Tag&& tag, Ctx&& ctx, It0&& it, It1&& end) noexcept
-         {
-            if constexpr (std::is_const_v<std::remove_reference_t<T>>) {
-               if constexpr (Opts.error_on_const_read) {
-                  ctx.error = error_code::attempt_const_read;
-               }
-               else {
-                  // do not read anything into the const value
-                  skip_value_binary<Opts>(std::forward<Ctx>(ctx), std::forward<It0>(it), std::forward<It1>(end));
-               }
-            }
-            else {
-               using V = std::remove_cvref_t<T>;
-               from_binary<V>::template op<Opts>(std::forward<T>(value), std::forward<Tag>(tag), std::forward<Ctx>(ctx),
-                                                 std::forward<It0>(it), std::forward<It1>(end));
-            }
-         }
-
-         template <auto Opts, class T, is_context Ctx, class It0, class It1>
-            requires(not Opts.no_header)
-         GLZ_ALWAYS_INLINE static void op(T&& value, Ctx&& ctx, It0&& it, It1&& end) noexcept
-         {
-            if constexpr (std::is_const_v<std::remove_reference_t<T>>) {
-               if constexpr (Opts.error_on_const_read) {
-                  ctx.error = error_code::attempt_const_read;
-               }
-               else {
-                  // do not read anything into the const value
-                  skip_value_binary<Opts>(std::forward<Ctx>(ctx), std::forward<It0>(it), std::forward<It1>(end));
-               }
-            }
-            else {
-               using V = std::remove_cvref_t<T>;
-               from_binary<V>::template op<Opts>(std::forward<T>(value), std::forward<Ctx>(ctx), std::forward<It0>(it),
-                                                 std::forward<It1>(end));
-            }
-         }
-      };
-
-      template <class T>
-         requires(glaze_value_t<T> && !custom_read<T>)
-      struct from_binary<T>
-      {
-         template <auto Opts, class Value, is_context Ctx, class It0, class It1>
-         GLZ_ALWAYS_INLINE static void op(Value&& value, Ctx&& ctx, It0&& it, It1&& end) noexcept
-         {
-            using V = std::decay_t<decltype(get_member(std::declval<Value>(), meta_wrapper_v<T>))>;
-            from_binary<V>::template op<Opts>(get_member(std::forward<Value>(value), meta_wrapper_v<T>),
-                                              std::forward<Ctx>(ctx), std::forward<It0>(it), std::forward<It1>(end));
-         }
-      };
-
-      template <always_null_t T>
-      struct from_binary<T>
-      {
-         template <auto Opts>
-         GLZ_ALWAYS_INLINE static void op(auto&&, is_context auto&& ctx, auto&& it, auto&&) noexcept
-         {
-            if (uint8_t(*it)) [[unlikely]] {
-               ctx.error = error_code::syntax_error;
-               return;
-            }
-            ++it;
-         }
-      };
-
-      template <>
-      struct from_binary<hidden>
-      {
-         template <auto Opts>
-         GLZ_ALWAYS_INLINE static void op(auto&&, is_context auto&& ctx, auto&&...) noexcept
-         {
-            ctx.error = error_code::attempt_read_hidden;
-         }
-      };
-
-      template <is_bitset T>
-      struct from_binary<T>
-      {
-         template <auto Opts>
-         GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, auto&& it, auto&& end) noexcept
-         {
-            const auto tag = uint8_t(*it);
-
-            constexpr uint8_t type = uint8_t(3) << 3;
-            constexpr uint8_t header = tag::typed_array | type;
-
-            if (tag != header) [[unlikely]] {
-               ctx.error = error_code::syntax_error;
-               return;
-            }
-
-            ++it;
-            if (it >= end) [[unlikely]] {
-               ctx.error = error_code::unexpected_end;
-               return;
-            }
-
-            const auto n = int_from_compressed(ctx, it, end);
-            if (bool(ctx.error)) [[unlikely]] {
-               return;
-            }
-
-            const auto num_bytes = (value.size() + 7) / 8;
-            for (size_t byte_i{}, i{}; byte_i < num_bytes; ++byte_i, ++it) {
-               uint8_t byte;
-               std::memcpy(&byte, it, 1);
-               for (size_t bit_i = 0; bit_i < 8 && i < n; ++bit_i, ++i) {
-                  value[i] = byte >> bit_i & uint8_t(1);
-               }
-            }
-         }
-      };
-
-      template <>
-      struct from_binary<skip>
-      {
-         template <auto Opts>
-         GLZ_ALWAYS_INLINE static void op(auto&&, is_context auto&& ctx, auto&&... args) noexcept
-         {
-            skip_value_binary<Opts>(ctx, args...);
-         }
-      };
-
-      template <glaze_flags_t T>
-      struct from_binary<T>
-      {
-         template <auto Opts, is_context Ctx, class It0, class It1>
-         GLZ_ALWAYS_INLINE static void op(auto&& value, Ctx&&, It0&& it, It1&&)
-         {
-            constexpr auto N = glz::tuple_size_v<meta_t<T>>;
-
-            constexpr auto Length = byte_length<T>();
-            uint8_t data[Length];
-
-            std::memcpy(data, it, Length);
-            it += Length;
-
-            for_each<N>([&](auto I) {
-               static constexpr auto item = glz::get<I>(meta_v<T>);
-
-               get_member(value, glz::get<1>(item)) = data[I / 8] & (uint8_t{1} << (7 - (I % 8)));
-            });
-         }
-      };
-
-      template <class T>
-         requires(num_t<T> || char_t<T> || glaze_enum_t<T>)
-      struct from_binary<T>
-      {
-         static constexpr uint8_t type =
-            std::floating_point<T> ? 0 : (std::is_signed_v<T> ? 0b000'01'000 : 0b000'10'000);
-         static constexpr uint8_t header = tag::number | type | (byte_count<T> << 5);
-
-         template <auto Opts>
-            requires(Opts.no_header)
-         GLZ_ALWAYS_INLINE static void op(auto&& value, const uint8_t tag, is_context auto&& ctx, auto&& it,
-                                          auto&&) noexcept
-         {
-            using V = std::decay_t<decltype(value)>;
-
-            constexpr auto is_volatile = std::is_volatile_v<std::remove_reference_t<decltype(value)>>;
-
-            if (tag != header) {
-               if constexpr (Opts.allow_conversions) {
-                  if constexpr (num_t<T>) {
-                     if ((tag & 0b00000111) != tag::number) {
-                        ctx.error = error_code::syntax_error;
-                        return;
-                     }
-
-                     auto decode = [&](auto&& i) {
-                        std::memcpy(&i, it, sizeof(i));
-                        value = static_cast<V>(i);
-                        it += sizeof(i);
-                     };
-
-                     switch (tag) {
-                     case tag::f32: {
-                        static_assert(sizeof(float) == 4);
-                        // TODO: use float32_t in C++23
-                        decode(float{});
-                        return;
-                     }
-                     case tag::f64: {
-                        static_assert(sizeof(double) == 8);
-                        // TODO: use float64_t in C++23
-                        decode(double{});
-                        return;
-                     }
-                     case tag::i8: {
-                        decode(int8_t{});
-                        return;
-                     }
-                     case tag::i16: {
-                        decode(int16_t{});
-                        return;
-                     }
-                     case tag::i32: {
-                        decode(int32_t{});
-                        return;
-                     }
-                     case tag::i64: {
-                        decode(int64_t{});
-                        return;
-                     }
-                     case tag::u8: {
-                        decode(uint8_t{});
-                        return;
-                     }
-                     case tag::u16: {
-                        decode(uint16_t{});
-                        return;
-                     }
-                     case tag::u32: {
-                        decode(uint32_t{});
-                        return;
-                     }
-                     case tag::u64: {
-                        decode(uint64_t{});
-                        return;
-                     }
-                     default: {
-                        ctx.error = error_code::syntax_error;
-                        return;
-                     }
-                     }
-                  }
-               }
-               else {
-                  ctx.error = error_code::syntax_error;
-                  return;
-               }
-            }
-
-            if constexpr (is_volatile) {
-               V temp;
-               std::memcpy(&temp, it, sizeof(V));
-               value = temp;
-            }
-            else {
-               std::memcpy(&value, it, sizeof(V));
-            }
-            it += sizeof(V);
-         }
-
-         template <auto Opts>
-            requires(not Opts.no_header)
-         GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, auto&& it, auto&& end) noexcept
-         {
-            const auto tag = uint8_t(*it);
-            ++it;
-            op<opt_true<Opts, &opts::no_header>>(value, tag, ctx, it, end);
-         }
-      };
-
-      template <class T>
-         requires(std::is_enum_v<T> && !glaze_enum_t<T>)
-      struct from_binary<T>
-      {
-         template <auto Opts>
-         GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, auto&& it, auto&&) noexcept
-         {
-            using V = std::underlying_type_t<std::decay_t<T>>;
-
-            if constexpr (Opts.no_header) {
-               std::memcpy(&value, it, sizeof(V));
-               it += sizeof(V);
-            }
-            else {
-               constexpr uint8_t type =
-                  std::floating_point<V> ? 0 : (std::is_signed_v<V> ? 0b000'01'000 : 0b000'10'000);
-               constexpr uint8_t header = tag::number | type | (byte_count<V> << 5);
-
-               const auto tag = uint8_t(*it);
-               if (tag != header) {
-                  ctx.error = error_code::syntax_error;
-                  return;
-               }
-
-               ++it;
-
-               std::memcpy(&value, it, sizeof(V));
-               it += sizeof(V);
-            }
-         }
-      };
-
-      template <class T>
-         requires complex_t<T>
-      struct from_binary<T>
-      {
-         template <auto Opts>
-         GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, auto&& it, auto&&) noexcept
-         {
-            if constexpr (Opts.no_header) {
-               using V = std::decay_t<T>;
-               std::memcpy(&value, it, sizeof(V));
-               it += sizeof(V);
-            }
-            else {
-               constexpr uint8_t header = tag::extensions | 0b00011'000;
-
-               const auto tag = uint8_t(*it);
-               if (tag != header) {
-                  ctx.error = error_code::syntax_error;
-                  return;
-               }
-               ++it;
-
-               using V = typename T::value_type;
-               constexpr uint8_t type =
-                  std::floating_point<V> ? 0 : (std::is_signed_v<V> ? 0b000'01'000 : 0b000'10'000);
-               constexpr uint8_t complex_number = 0;
-               constexpr uint8_t complex_header = complex_number | type | (byte_count<V> << 5);
-
-               const auto complex_tag = uint8_t(*it);
-               if (complex_tag != complex_header) {
-                  ctx.error = error_code::syntax_error;
-                  return;
-               }
-               ++it;
-
-               std::memcpy(&value, it, 2 * sizeof(V));
-               it += 2 * sizeof(V);
-            }
-         }
-      };
-
-      template <boolean_like T>
-      struct from_binary<T>
-      {
-         template <auto Opts>
-         GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, auto&& it, auto&& /* end */) noexcept
-         {
-            const auto tag = uint8_t(*it);
-            if ((tag & 0b0000'1111) != tag::boolean) {
-               ctx.error = error_code::syntax_error;
-               return;
-            }
-
-            value = tag >> 4;
-            ++it;
-         }
-      };
-
-      template <is_member_function_pointer T>
-      struct from_binary<T>
-      {
-         template <auto Opts>
-         GLZ_ALWAYS_INLINE static void op(auto&& /*value*/, is_context auto&& /*ctx*/, auto&& /*it*/,
-                                          auto&& /*end*/) noexcept
-         {}
-      };
-
-      template <func_t T>
-      struct from_binary<T>
-      {
-         template <auto Opts>
-         GLZ_ALWAYS_INLINE static void op(auto&& /*value*/, is_context auto&& ctx, auto&& it, auto&& end) noexcept
-         {
-            skip_string_binary(ctx, it, end);
-         }
-      };
-
-      template <class T>
-      struct from_binary<basic_raw_json<T>>
-      {
-         template <auto Opts>
-         GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, auto&& it, auto&& end) noexcept
-         {
-            read<binary>::op<Opts>(value.str, ctx, it, end);
-         }
-      };
-
-      template <class T>
-      struct from_binary<basic_text<T>>
-      {
-         template <auto Opts>
-         GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, auto&& it, auto&& end) noexcept
-         {
-            read<binary>::op<Opts>(value.str, ctx, it, end);
-         }
-      };
-
-      template <is_variant T>
-      struct from_binary<T>
-      {
-         template <auto Opts>
-         GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, auto&& it, auto&& end) noexcept
-         {
-            constexpr uint8_t header = tag::extensions | 0b00001'000;
-            const auto tag = uint8_t(*it);
-            if (tag != header) [[unlikely]] {
-               ctx.error = error_code::syntax_error;
-               return;
-            }
-            ++it;
-
-            const auto type_index = int_from_compressed(ctx, it, end);
-            if (value.index() != type_index) {
-               value = runtime_variant_map<T>()[type_index];
-            }
-            std::visit([&](auto&& v) { read<binary>::op<Opts>(v, ctx, it, end); }, value);
-         }
-      };
-
-      template <str_t T>
-      struct from_binary<T> final
-      {
-         using V = typename std::decay_t<T>::value_type;
-         static_assert(sizeof(V) == 1);
-
-         template <auto Opts>
-            requires(Opts.no_header)
-         GLZ_ALWAYS_INLINE static void op(auto&& value, const uint8_t, is_context auto&& ctx, auto&& it,
-                                          auto&& end) noexcept
-         {
-            const auto n = int_from_compressed(ctx, it, end);
-            if ((it + n) > end) [[unlikely]] {
-               ctx.error = error_code::unexpected_end;
-               return;
-            }
-            value.resize(n);
-            std::memcpy(value.data(), it, n);
-            it += n;
-         }
-
-         template <auto Opts>
-            requires(not Opts.no_header)
-         GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, auto&& it, auto&& end) noexcept
-         {
-            constexpr uint8_t header = tag::string;
-
-            const auto tag = uint8_t(*it);
-            if (tag != header) [[unlikely]] {
-               ctx.error = error_code::syntax_error;
-               return;
-            }
-
-            ++it;
-
-            const auto n = int_from_compressed(ctx, it, end);
-            if ((it + n) > end) [[unlikely]] {
-               ctx.error = error_code::unexpected_end;
-               return;
-            }
-
-            if constexpr (string_view_t<T>) {
-               value = {it, n};
-            }
-            else {
-               value.resize(n);
-               std::memcpy(value.data(), it, n);
-            }
-            it += n;
-         }
-      };
-
-      // for set types
-      template <class T>
-         requires(readable_array_t<T> && !emplace_backable<T> && !resizable<T> && emplaceable<T>)
-      struct from_binary<T> final
-      {
-         template <auto Opts>
-         GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, auto&& it, auto&& end) noexcept
-         {
-            using V = range_value_t<std::decay_t<T>>;
-
-            const auto tag = uint8_t(*it);
-
-            if constexpr (boolean_like<V>) {
-               constexpr uint8_t type = uint8_t(3) << 3;
-               constexpr uint8_t header = tag::typed_array | type;
-
-               if (tag != header) [[unlikely]] {
-                  ctx.error = error_code::syntax_error;
-                  return;
-               }
-
-               ++it;
-
-               const auto n = int_from_compressed(ctx, it, end);
-
-               value.clear();
-
-               const auto num_bytes = (value.size() + 7) / 8;
-               for (size_t byte_i{}, i{}; byte_i < num_bytes; ++byte_i, ++it) {
-                  uint8_t byte;
-                  std::memcpy(&byte, it, 1);
-                  for (size_t bit_i = 7; bit_i < 8 && i < n; --bit_i, ++i) {
-                     bool x = byte >> bit_i & uint8_t(1);
-                     value.emplace(x);
-                  }
-               }
-            }
-            else if constexpr (num_t<V>) {
-               constexpr uint8_t type =
-                  std::floating_point<V> ? 0 : (std::is_signed_v<V> ? 0b000'01'000 : 0b000'10'000);
-               constexpr uint8_t header = tag::typed_array | type | (byte_count<V> << 5);
-
-               if (tag != header) [[unlikely]] {
-                  ctx.error = error_code::syntax_error;
-                  return;
-               }
-
-               ++it;
-
-               const auto n = int_from_compressed(ctx, it, end);
-               if (bool(ctx.error)) [[unlikely]] {
-                  return;
-               }
-
-               value.clear();
-
-               for (size_t i = 0; i < n; ++i) {
-                  V x;
-                  std::memcpy(&x, it, sizeof(V));
-                  it += sizeof(V);
-                  value.emplace(x);
-               }
-            }
-            else if constexpr (str_t<V>) {
-               constexpr uint8_t type = uint8_t(3) << 3;
-               constexpr uint8_t string_indicator = uint8_t(1) << 5;
-               constexpr uint8_t header = tag::typed_array | type | string_indicator;
-
-               if (tag != header) [[unlikely]] {
-                  ctx.error = error_code::syntax_error;
-                  return;
-               }
-
-               ++it;
-
-               const auto n = int_from_compressed(ctx, it, end);
-               if (bool(ctx.error)) [[unlikely]] {
-                  return;
-               }
-
-               value.clear();
-
-               for (size_t i = 0; i < n; ++i) {
-                  const auto length = int_from_compressed(ctx, it, end);
-                  if ((it + length) > end) [[unlikely]] {
-                     ctx.error = error_code::unexpected_end;
-                     return;
-                  }
-                  V str;
-                  str.resize(length);
-                  std::memcpy(str.data(), it, length);
-                  it += length;
-                  value.emplace(std::move(str));
-               }
-            }
-            else if constexpr (complex_t<V>) {
-               static_assert(false_v<T>, "TODO");
-            }
-            else {
-               // generic array
-               if ((tag & 0b00000'111) != tag::generic_array) [[unlikely]] {
-                  ctx.error = error_code::syntax_error;
-                  return;
-               }
-               ++it;
-
-               const auto n = int_from_compressed(ctx, it, end);
-               if (bool(ctx.error)) [[unlikely]] {
-                  return;
-               }
-
-               value.clear();
-
-               for (size_t i = 0; i < n; ++i) {
-                  V v;
-                  read<binary>::op<Opts>(v, ctx, it, end);
-                  value.emplace(std::move(v));
-               }
-            }
-         }
-      };
-
-      template <readable_array_t T>
-      struct from_binary<T> final
-      {
-         template <auto Opts>
-         GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, auto&& it, auto&& end) noexcept
-         {
-            using V = range_value_t<std::decay_t<T>>;
-
-            const auto tag = uint8_t(*it);
-
-            if constexpr (boolean_like<V>) {
-               constexpr uint8_t type = uint8_t(3) << 3;
-               constexpr uint8_t header = tag::typed_array | type;
-
-               if (tag != header) [[unlikely]] {
-                  ctx.error = error_code::syntax_error;
-                  return;
-               }
-
-               ++it;
-
-               const auto n = int_from_compressed(ctx, it, end);
-               if (bool(ctx.error)) [[unlikely]] {
-                  return;
-               }
-
-               if constexpr (resizable<T>) {
-                  value.resize(n);
-
-                  if constexpr (Opts.shrink_to_fit) {
-                     value.shrink_to_fit();
-                  }
-               }
-
-               const auto num_bytes = (value.size() + 7) / 8;
-               for (size_t byte_i{}, i{}; byte_i < num_bytes; ++byte_i, ++it) {
-                  uint8_t byte;
-                  std::memcpy(&byte, it, 1);
-                  for (size_t bit_i = 7; bit_i < 8 && i < n; --bit_i, ++i) {
-                     value[i] = byte >> bit_i & uint8_t(1);
-                  }
-               }
-            }
-            else if constexpr (num_t<V>) {
-               constexpr uint8_t type =
-                  std::floating_point<V> ? 0 : (std::is_signed_v<V> ? 0b000'01'000 : 0b000'10'000);
-               constexpr uint8_t header = tag::typed_array | type | (byte_count<V> << 5);
-
-               auto prepare = [&](const size_t element_size) -> size_t {
-                  ++it;
-
-                  std::conditional_t<Opts.partial_read, size_t, const size_t> n = int_from_compressed(ctx, it, end);
-                  if (bool(ctx.error)) [[unlikely]] {
-                     return 0;
-                  }
-
-                  if constexpr (Opts.partial_read) {
-                     n = value.size();
-                  }
-
-                  if ((it + n * element_size) > end) [[unlikely]] {
-                     ctx.error = error_code::unexpected_end;
-                     return 0;
-                  }
-
-                  if constexpr (resizable<T>) {
-                     value.resize(n);
-
-                     if constexpr (Opts.shrink_to_fit) {
-                        value.shrink_to_fit();
-                     }
-                  }
-
-                  return n;
-               };
-
-               if (tag != header) {
-                  if constexpr (Opts.allow_conversions) {
-                     if (tag != header) [[unlikely]] {
-                        if constexpr (Opts.allow_conversions) {
-                           if ((tag & 0b00000111) != tag::typed_array) {
-                              ctx.error = error_code::syntax_error;
-                              return;
-                           }
-
-                           const uint8_t byte_count = byte_count_lookup[tag >> 5];
-                           prepare(byte_count);
-                           if (bool(ctx.error)) [[unlikely]] {
-                              return;
-                           }
-
-                           for (auto&& x : value) {
-                              const uint8_t number_tag = tag::number | (tag & 0b11111000);
-                              read<binary>::op<opt_true<Opts, &opts::no_header>>(x, number_tag, ctx, it, end);
-                           }
-                           return;
-                        }
-                        else {
-                           ctx.error = error_code::syntax_error;
-                           return;
-                        }
-                     }
-                  }
-                  else {
-                     ctx.error = error_code::syntax_error;
-                     return;
-                  }
-               }
-
-               const auto n = prepare(sizeof(V));
-               if (bool(ctx.error)) [[unlikely]] {
-                  return;
-               }
-
-               if constexpr (contiguous<T>) {
-                  constexpr auto is_volatile =
-                     std::is_volatile_v<std::remove_reference_t<std::remove_pointer_t<decltype(value.data())>>>;
-
-                  if constexpr (is_volatile) {
-                     V temp;
-                     for (size_t i = 0; i < n; ++i) {
-                        std::memcpy(&temp, it, sizeof(V));
-                        value[i] = temp;
-                        it += sizeof(V);
-                     }
-                  }
-                  else {
-                     std::memcpy(value.data(), it, n * sizeof(V));
-                     it += n * sizeof(V);
-                  }
-               }
-               else {
-                  for (auto&& x : value) {
-                     std::memcpy(&x, it, sizeof(V));
-                     it += sizeof(V);
-                  }
-               }
-            }
-            else if constexpr (str_t<V>) {
-               constexpr uint8_t type = uint8_t(3) << 3;
-               constexpr uint8_t string_indicator = uint8_t(1) << 5;
-               constexpr uint8_t header = tag::typed_array | type | string_indicator;
-
-               if (tag != header) [[unlikely]] {
-                  ctx.error = error_code::syntax_error;
-                  return;
-               }
-
-               ++it;
-
-               std::conditional_t<Opts.partial_read, size_t, const size_t> n = int_from_compressed(ctx, it, end);
-               if (bool(ctx.error)) [[unlikely]] {
-                  return;
-               }
-
-               if constexpr (Opts.partial_read) {
-                  n = value.size();
-               }
-
-               if constexpr (resizable<T>) {
-                  value.resize(n);
-
-                  if constexpr (Opts.shrink_to_fit) {
-                     value.shrink_to_fit();
-                  }
-               }
-
-               for (auto&& x : value) {
-                  const auto length = int_from_compressed(ctx, it, end);
-                  if (bool(ctx.error)) [[unlikely]] {
-                     return;
-                  }
-                  x.resize(length);
-
-                  if constexpr (Opts.shrink_to_fit) {
-                     value.shrink_to_fit();
-                  }
-
-                  std::memcpy(x.data(), it, length);
-                  it += length;
-               }
-            }
-            else if constexpr (complex_t<V>) {
-               constexpr uint8_t header = tag::extensions | 0b00011'000;
-               if (tag != header) [[unlikely]] {
-                  ctx.error = error_code::syntax_error;
-                  return;
-               }
-               ++it;
-
-               using X = typename V::value_type;
-               constexpr uint8_t complex_array = 1;
-               constexpr uint8_t type =
-                  std::floating_point<X> ? 0 : (std::is_signed_v<X> ? 0b000'01'000 : 0b000'10'000);
-               constexpr uint8_t complex_header = complex_array | type | (byte_count<X> << 5);
-               const auto complex_tag = uint8_t(*it);
-               if (complex_tag != complex_header) [[unlikely]] {
-                  ctx.error = error_code::syntax_error;
-                  return;
-               }
-               ++it;
-
-               std::conditional_t<Opts.partial_read, size_t, const size_t> n = int_from_compressed(ctx, it, end);
-               if (bool(ctx.error)) [[unlikely]] {
-                  return;
-               }
-
-               if constexpr (Opts.partial_read) {
-                  n = value.size();
-               }
-
-               if ((it + n * sizeof(V)) > end) [[unlikely]] {
-                  ctx.error = error_code::unexpected_end;
-                  return;
-               }
-
-               if constexpr (resizable<T>) {
-                  value.resize(n);
-
-                  if constexpr (Opts.shrink_to_fit) {
-                     value.shrink_to_fit();
-                  }
-               }
-
-               if constexpr (contiguous<T>) {
-                  std::memcpy(value.data(), it, n * sizeof(V));
-                  it += n * sizeof(V);
-               }
-               else {
-                  for (auto&& x : value) {
-                     std::memcpy(&x, it, sizeof(V));
-                     it += sizeof(V);
-                  }
-               }
-            }
-            else {
-               if ((tag & 0b00000'111) != tag::generic_array) [[unlikely]] {
-                  ctx.error = error_code::syntax_error;
-                  return;
-               }
-               ++it;
-
-               std::conditional_t<Opts.partial_read, size_t, const size_t> n = int_from_compressed(ctx, it, end);
-               if (bool(ctx.error)) [[unlikely]] {
-                  return;
-               }
-
-               if constexpr (Opts.partial_read) {
-                  n = value.size();
-               }
-
-               if constexpr (resizable<T>) {
-                  value.resize(n);
-
-                  if constexpr (Opts.shrink_to_fit) {
-                     value.shrink_to_fit();
-                  }
-               }
-
-               for (auto&& item : value) {
-                  read<binary>::op<Opts>(item, ctx, it, end);
-               }
-            }
-         }
-      };
-
-      template <pair_t T>
-      struct from_binary<T> final
-      {
-         template <auto Opts>
-         GLZ_ALWAYS_INLINE static void op(T& value, is_context auto&& ctx, auto&& it, auto&& end) noexcept
-         {
-            using Key = typename T::first_type;
-
-            constexpr uint8_t type = str_t<Key> ? 0 : (std::is_signed_v<Key> ? 0b000'01'000 : 0b000'10'000);
-            constexpr uint8_t byte_cnt = str_t<Key> ? 0 : byte_count<Key>;
-            constexpr uint8_t header = tag::object | type | (byte_cnt << 5);
-
-            const auto tag = uint8_t(*it);
-            if (tag != header) [[unlikely]] {
-               ctx.error = error_code::syntax_error;
-               return;
-            }
-
-            ++it;
-
-            const auto n = int_from_compressed(ctx, it, end);
-            if (bool(ctx.error)) [[unlikely]] {
-               return;
-            }
-            if (n != 1) [[unlikely]] {
-               ctx.error = error_code::syntax_error;
-               return;
-            }
-
-            constexpr uint8_t key_tag = type == 0 ? tag::string : (tag::number | (byte_cnt << 5));
-            read<binary>::op<opt_true<Opts, &opts::no_header>>(value.first, key_tag, ctx, it, end);
-            read<binary>::op<Opts>(value.second, ctx, it, end);
-         }
-      };
-
-      template <readable_map_t T>
-      struct from_binary<T> final
-      {
-         template <auto Opts>
-         GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, auto&& it, auto&& end) noexcept
-         {
-            using Key = typename T::key_type;
-
-            constexpr uint8_t type = str_t<Key> ? 0 : (std::is_signed_v<Key> ? 0b000'01'000 : 0b000'10'000);
-            constexpr uint8_t byte_cnt = str_t<Key> ? 0 : byte_count<Key>;
-            constexpr uint8_t header = tag::object | type | (byte_cnt << 5);
-
-            const auto tag = uint8_t(*it);
-            if (tag != header) [[unlikely]] {
-               if constexpr (Opts.allow_conversions) {
-                  const auto key_type = tag & 0b000'11'000;
-                  if constexpr (str_t<Key>) {
-                     if (key_type != 0) {
-                        ctx.error = error_code::syntax_error;
-                        return;
-                     }
-                  }
-                  else {
-                     if (key_type == 0) {
-                        ctx.error = error_code::syntax_error;
-                        return;
-                     }
-                  }
-               }
-               else {
-                  ctx.error = error_code::syntax_error;
-                  return;
-               }
-            }
-
-            ++it;
-
-            std::conditional_t<Opts.partial_read, size_t, const size_t> n = int_from_compressed(ctx, it, end);
-            if (bool(ctx.error)) [[unlikely]] {
-               return;
-            }
-
-            if constexpr (Opts.partial_read) {
-               n = value.size();
-            }
-
-            if constexpr (std::is_arithmetic_v<std::decay_t<Key>>) {
-               constexpr uint8_t key_tag = tag::number | type | (byte_cnt << 5);
-               Key key;
-               for (size_t i = 0; i < n; ++i) {
-                  if constexpr (Opts.partial_read) {
-                     read<binary>::op<opt_true<Opts, &opts::no_header>>(key, key_tag, ctx, it, end);
-                     if (auto element = value.find(key); element != value.end()) {
-                        read<binary>::op<Opts>(element->second, ctx, it, end);
-                     }
-                  }
-                  else {
-                     // convert the object tag to the key type tag
-                     read<binary>::op<opt_true<Opts, &opts::no_header>>(key, key_tag, ctx, it, end);
-                     read<binary>::op<Opts>(value[key], ctx, it, end);
-                  }
-               }
-            }
-            else {
-               constexpr uint8_t key_tag = tag::string;
-               static thread_local Key key;
-               for (size_t i = 0; i < n; ++i) {
-                  if constexpr (Opts.partial_read) {
-                     read<binary>::op<opt_true<Opts, &opts::no_header>>(key, key_tag, ctx, it, end);
-                     if (auto element = value.find(key); element != value.end()) {
-                        read<binary>::op<Opts>(element->second, ctx, it, end);
-                     }
-                  }
-                  else {
-                     read<binary>::op<opt_true<Opts, &opts::no_header>>(key, key_tag, ctx, it, end);
-                     read<binary>::op<Opts>(value[key], ctx, it, end);
-                  }
-               }
-            }
-         }
-      };
-
-      template <nullable_t T>
-         requires(std::is_array_v<T>)
-      struct from_binary<T> final
-      {
-         template <auto Opts, class V, size_t N>
-         GLZ_ALWAYS_INLINE static void op(V (&value)[N], is_context auto&& ctx, auto&& it, auto&& end) noexcept
-         {
-            read<binary>::op<Opts>(std::span{value, N}, ctx, it, end);
-         }
-      };
-
-      template <nullable_t T>
-         requires(!std::is_array_v<T>)
-      struct from_binary<T> final
-      {
-         template <auto Opts>
-         GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, auto&& it, auto&& end) noexcept
-         {
-            const auto tag = uint8_t(*it);
-
-            if (tag == tag::null) {
-               ++it;
-               if constexpr (is_specialization_v<T, std::optional>)
-                  value = std::nullopt;
-               else if constexpr (is_specialization_v<T, std::unique_ptr>)
-                  value = nullptr;
-               else if constexpr (is_specialization_v<T, std::shared_ptr>)
-                  value = nullptr;
-            }
-            else {
-               if (!value) {
-                  if constexpr (is_specialization_v<T, std::optional>)
-                     value = std::make_optional<typename T::value_type>();
-                  else if constexpr (is_specialization_v<T, std::unique_ptr>)
-                     value = std::make_unique<typename T::element_type>();
-                  else if constexpr (is_specialization_v<T, std::shared_ptr>)
-                     value = std::make_shared<typename T::element_type>();
-                  else if constexpr (constructible<T>) {
-                     value = meta_construct_v<T>();
-                  }
-                  else {
-                     ctx.error = error_code::invalid_nullable_read;
-                     return;
-                     // Cannot read into unset nullable that is not std::optional, std::unique_ptr, or std::shared_ptr
-                  }
-               }
-               read<binary>::op<Opts>(*value, ctx, it, end);
-            }
-         }
-      };
-
-      template <is_includer T>
-      struct from_binary<T>
-      {
-         template <auto Opts>
-         GLZ_ALWAYS_INLINE static void op(auto&&, is_context auto&& ctx, auto&& it, auto&& end) noexcept
-         {
-            if constexpr (Opts.no_header) {
-               skip_compressed_int(ctx, it, end);
-            }
-            else {
-               constexpr uint8_t header = tag::string;
-
-               const auto tag = uint8_t(*it);
-               if (tag != header) [[unlikely]] {
-                  ctx.error = error_code::syntax_error;
-                  return;
-               }
-
-               ++it;
-
-               skip_compressed_int(ctx, it, end);
-            }
-         }
-      };
-
-      template <class T>
-         requires(glaze_object_t<T> || reflectable<T>)
-      struct from_binary<T> final
-      {
-         template <auto Opts>
-            requires(Opts.structs_as_arrays == true)
-         static void op(auto&& value, is_context auto&& ctx, auto&& it, auto&& end) noexcept
-         {
-            if constexpr (reflectable<T>) {
-               auto t = to_tuple(value);
-               read<binary>::op<Opts>(t, ctx, it, end);
-            }
-            else {
-               const auto tag = uint8_t(*it);
-               if (tag != tag::generic_array) [[unlikely]] {
-                  ctx.error = error_code::syntax_error;
-                  return;
-               }
-               ++it;
-
-               using V = std::decay_t<T>;
-               constexpr auto N = glz::tuple_size_v<meta_t<V>>;
-               if (int_from_compressed(ctx, it, end) != N) {
-                  ctx.error = error_code::syntax_error;
-                  return;
-               }
-
-               for_each<N>([&](auto I) {
-                  static constexpr auto item = get<I>(meta_v<V>);
-                  using T0 = std::decay_t<decltype(get<0>(item))>;
-                  constexpr bool use_reflection = std::is_member_pointer_v<T0>;
-                  constexpr auto member_index = use_reflection ? 0 : 1;
-                  read<binary>::op<Opts>(get_member(value, get<member_index>(item)), ctx, it, end);
-               });
-            }
-         }
-
-         template <auto Opts>
-            requires(Opts.structs_as_arrays == false)
-         static void op(auto&& value, is_context auto&& ctx, auto&& it, auto&& end) noexcept
-         {
-            constexpr uint8_t type = 0; // string key
-            constexpr uint8_t header = tag::object | type;
-
-            const auto tag = uint8_t(*it);
-            if (tag != header) [[unlikely]] {
-               ctx.error = error_code::syntax_error;
-               return;
-            }
-
-            ++it;
-
-            static constexpr auto N = reflection_count<T>;
-
-            static constexpr bit_array<N> all_fields = [] {
-               bit_array<N> arr{};
-               for (size_t i = 0; i < N; ++i) {
-                  arr[i] = true;
-               }
-               return arr;
-            }();
-
-            decltype(auto) fields = [&]() -> decltype(auto) {
-               if constexpr (is_partial_read<T> || Opts.partial_read) {
-                  return bit_array<N>{};
-               }
-               else {
-                  return nullptr;
-               }
-            }();
-
-            const auto n_keys = int_from_compressed(ctx, it, end);
-            if (bool(ctx.error)) [[unlikely]] {
-               return;
-            }
-
-            decltype(auto) storage = [&]() -> decltype(auto) {
-               using V = decay_keep_volatile_t<decltype(value)>;
-               if constexpr (reflectable<T>) {
-#if ((defined _MSC_VER) && (!defined __clang__))
-                  static thread_local auto cmap = make_map<V, Opts.use_hash_comparison>();
-#else
-                  static thread_local constinit auto cmap = make_map<V, Opts.use_hash_comparison>();
-#endif
-                  populate_map(value, cmap); // Function required for MSVC to build
-                  return cmap;
-               }
-               else {
-                  static constexpr auto cmap = make_map<T, Opts.use_hash_comparison>();
-                  return cmap;
-               }
-            }();
-
-            for (size_t i = 0; i < n_keys; ++i) {
-               if constexpr (is_partial_read<T> || Opts.partial_read) {
-                  if ((all_fields & fields) == all_fields) {
-                     return;
-                  }
-               }
-
-               const auto length = int_from_compressed(ctx, it, end);
-               if (bool(ctx.error)) [[unlikely]] {
-                  return;
-               }
-
-               const std::string_view key{it, length};
-
-               it += length;
-
-               if constexpr (N > 0) {
-                  if (const auto& p = storage.find(key); p != storage.end()) [[likely]] {
-                     if constexpr (is_partial_read<T> || Opts.partial_read) {
-                        auto index = p - storage.begin();
-                        fields[index] = true;
-                     }
-
-                     std::visit(
-                        [&](auto&& member_ptr) { read<binary>::op<Opts>(get_member(value, member_ptr), ctx, it, end); },
-                        p->second);
-
-                     if (bool(ctx.error)) [[unlikely]] {
-                        return;
-                     }
-                  }
-                  else [[unlikely]] {
-                     if constexpr (Opts.error_on_unknown_keys) {
-                        ctx.error = error_code::unknown_key;
-                        return;
-                     }
-                     else {
-                        skip_value_binary<Opts>(ctx, it, end);
-                        if (bool(ctx.error)) [[unlikely]]
-                           return;
-                     }
-                  }
-               }
-               else if constexpr (Opts.error_on_unknown_keys) {
-                  ctx.error = error_code::unknown_key;
-                  return;
-               }
-               else {
-                  skip_value_binary<Opts>(ctx, it, end);
-                  if (bool(ctx.error)) [[unlikely]]
-                     return;
-               }
-            }
-         }
-      };
-
-      template <class T>
-         requires glaze_array_t<T>
-      struct from_binary<T> final
-      {
-         template <auto Opts>
-         GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, auto&& it, auto&& end) noexcept
-         {
-            const auto tag = uint8_t(*it);
-            if (tag != tag::generic_array) [[unlikely]] {
-               ctx.error = error_code::syntax_error;
-               return;
-            }
-            ++it;
-
-            using V = std::decay_t<T>;
-            constexpr auto N = glz::tuple_size_v<meta_t<V>>;
-            if (int_from_compressed(ctx, it, end) != N) {
-               ctx.error = error_code::syntax_error;
-               return;
-            }
-
-            for_each<N>(
-               [&](auto I) { read<binary>::op<Opts>(get_member(value, glz::get<I>(meta_v<V>)), ctx, it, end); });
-         }
-      };
-
-      template <class T>
-         requires(tuple_t<T> || is_std_tuple<T>)
-      struct from_binary<T> final
-      {
-         template <auto Opts>
-         GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, auto&& it, auto&& end) noexcept
-         {
-            const auto tag = uint8_t(*it);
-            if (tag != tag::generic_array) [[unlikely]] {
-               ctx.error = error_code::syntax_error;
-               return;
-            }
-            ++it;
-
-            using V = std::decay_t<T>;
-            constexpr auto N = glz::tuple_size_v<V>;
-            if constexpr (Opts.partial_read) {
-               const auto n = int_from_compressed(ctx, it, end);
-
-               if constexpr (is_std_tuple<T>) {
-                  for_each_short_circuit<N>([&](auto I) {
-                     if (I < n) {
-                        read<binary>::op<Opts>(std::get<I>(value), ctx, it, end);
-                        return false; // continue
-                     }
-                     return true; // short circuit
-                  });
-               }
-               else {
-                  for_each_short_circuit<N>([&](auto I) {
-                     if (I < n) {
-                        read<binary>::op<Opts>(glz::get<I>(value), ctx, it, end);
-                        return false; // continue
-                     }
-                     return true; // short circuit
-                  });
-               }
-            }
-            else {
-               if (int_from_compressed(ctx, it, end) != N) {
-                  ctx.error = error_code::syntax_error;
-                  return;
-               }
-
-               if constexpr (is_std_tuple<T>) {
-                  for_each<N>([&](auto I) { read<binary>::op<Opts>(std::get<I>(value), ctx, it, end); });
-               }
-               else {
-                  for_each<N>([&](auto I) { read<binary>::op<Opts>(glz::get<I>(value), ctx, it, end); });
-               }
-            }
-         }
-      };
-
-      template <filesystem_path T>
-      struct from_binary<T>
-      {
-         template <auto Opts>
-         GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, auto&&... args) noexcept
-         {
-            static thread_local std::string buffer{};
-            read<binary>::op<Opts>(buffer, ctx, args...);
-            if (bool(ctx.error)) [[unlikely]] {
-               return;
-            }
-            value = buffer;
-         }
-      };
-   }
-
-   template <read_binary_supported T, class Buffer>
-   [[nodiscard]] inline error_ctx read_binary(T&& value, Buffer&& buffer) noexcept
-   {
-      return read<opts{.format = binary}>(value, std::forward<Buffer>(buffer));
-   }
-
-   template <read_binary_supported T, class Buffer>
-   [[nodiscard]] inline expected<T, error_ctx> read_binary(Buffer&& buffer) noexcept
-   {
-      T value{};
-      const auto pe = read<opts{.format = binary}>(value, std::forward<Buffer>(buffer));
-      if (pe) [[unlikely]] {
-         return unexpected(pe);
-      }
-      return value;
-   }
-
-   template <opts Opts = opts{}, read_binary_supported T>
-   [[nodiscard]] inline error_ctx read_file_binary(T& value, const sv file_name, auto&& buffer) noexcept
-   {
-      context ctx{};
-      ctx.current_file = file_name;
-
-      const auto file_error = file_to_buffer(buffer, ctx.current_file);
-
-      if (bool(file_error)) [[unlikely]] {
-         return error_ctx{file_error};
-      }
-
-      return read<set_binary<Opts>()>(value, buffer, ctx);
-   }
-
-   template <read_binary_supported T, class Buffer>
-   [[nodiscard]] inline error_ctx read_binary_untagged(T&& value, Buffer&& buffer) noexcept
-   {
-      return read<opts{.format = binary, .structs_as_arrays = true}>(std::forward<T>(value),
-                                                                     std::forward<Buffer>(buffer));
-   }
-
-   template <read_binary_supported T, class Buffer>
-   [[nodiscard]] inline expected<T, error_ctx> read_binary_untagged(Buffer&& buffer) noexcept
-   {
-      T value{};
-      const auto pe = read<opts{.format = binary, .structs_as_arrays = true}>(value, std::forward<Buffer>(buffer));
-      if (pe) [[unlikely]] {
-         return unexpected(pe);
-      }
-      return value;
-   }
-
-   template <opts Opts = opts{}, read_binary_supported T>
-   [[nodiscard]] inline error_ctx read_file_binary_untagged(T& value, const std::string& file_name,
-                                                            auto&& buffer) noexcept
-   {
-      return read_file_binary<opt_true<Opts, &opts::structs_as_arrays>>(value, file_name, buffer);
-   }
-}
diff --git a/deps/saucer/include/glaze/binary/skip.hpp b/deps/saucer/include/glaze/binary/skip.hpp
deleted file mode 100644
index c9717b4..0000000
--- a/deps/saucer/include/glaze/binary/skip.hpp
+++ /dev/null
@@ -1,161 +0,0 @@
-// Glaze Library
-// For the license information refer to glaze.hpp
-
-#pragma once
-
-#include "glaze/binary/header.hpp"
-#include "glaze/core/opts.hpp"
-#include "glaze/core/read.hpp"
-#include "glaze/file/file_ops.hpp"
-#include "glaze/util/dump.hpp"
-
-namespace glz::detail
-{
-   template <opts Opts>
-   inline void skip_value_binary(is_context auto&&, auto&&, auto&&) noexcept;
-
-   inline void skip_string_binary(is_context auto&& ctx, auto&& it, auto&& end) noexcept
-   {
-      ++it;
-      const auto n = int_from_compressed(ctx, it, end);
-      if (bool(ctx.error)) [[unlikely]] {
-         return;
-      }
-      it += n;
-   }
-
-   inline void skip_number_binary(is_context auto&&, auto&& it, auto&&) noexcept
-   {
-      const auto tag = uint8_t(*it);
-      const uint8_t byte_count = byte_count_lookup[tag >> 5];
-      ++it;
-      it += byte_count;
-   }
-
-   template <opts Opts>
-   inline void skip_object_binary(is_context auto&& ctx, auto&& it, auto&& end) noexcept
-   {
-      const auto tag = uint8_t(*it);
-      ++it;
-
-      const auto n_keys = int_from_compressed(ctx, it, end);
-
-      if ((tag & 0b00000'111) == tag::string) {
-         for (size_t i = 0; i < n_keys; ++i) {
-            const auto string_length = int_from_compressed(ctx, it, end);
-            it += string_length;
-            if (bool(ctx.error)) [[unlikely]]
-               return;
-
-            skip_value_binary<Opts>(ctx, it, end);
-            if (bool(ctx.error)) [[unlikely]]
-               return;
-         }
-      }
-      else if ((tag & 0b00000'111) == tag::number) {
-         const uint8_t byte_count = byte_count_lookup[tag >> 5];
-         for (size_t i = 0; i < n_keys; ++i) {
-            const auto n = int_from_compressed(ctx, it, end);
-            it += byte_count * n;
-            if (bool(ctx.error)) [[unlikely]]
-               return;
-
-            skip_value_binary<Opts>(ctx, it, end);
-            if (bool(ctx.error)) [[unlikely]]
-               return;
-         }
-      }
-      else {
-         ctx.error = error_code::syntax_error;
-         return;
-      }
-   }
-
-   template <opts Opts>
-   inline void skip_typed_array_binary(is_context auto&& ctx, auto&& it, auto&& end) noexcept
-   {
-      const auto tag = uint8_t(*it);
-      const uint8_t type = (tag & 0b000'11'000) >> 3;
-      switch (type) {
-      case 0: // floating point (fallthrough)
-      case 1: // signed integer (fallthrough)
-      case 2: { // unsigned integer
-         ++it;
-         const auto n = int_from_compressed(ctx, it, end);
-         const uint8_t byte_count = byte_count_lookup[tag >> 5];
-         it += byte_count * n;
-         break;
-      }
-      case 3: { // bool or string
-         const bool is_bool = (tag & 0b00'1'00'000) >> 5;
-         ++it;
-         if (is_bool) {
-            const auto n = int_from_compressed(ctx, it, end);
-            const auto num_bytes = (n + 7) / 8;
-            it += num_bytes;
-         }
-         else {
-            const auto n = int_from_compressed(ctx, it, end);
-            it += n;
-         }
-         break;
-      }
-      default:
-         ctx.error = error_code::syntax_error;
-      }
-   }
-
-   template <opts Opts>
-   inline void skip_untyped_array_binary(is_context auto&& ctx, auto&& it, auto&& end) noexcept
-   {
-      ++it;
-      const auto n = int_from_compressed(ctx, it, end);
-      for (size_t i = 0; i < n; ++i) {
-         skip_value_binary<Opts>(ctx, it, end);
-      }
-   }
-
-   template <opts Opts>
-   inline void skip_additional_binary(is_context auto&& ctx, auto&& it, auto&& end) noexcept
-   {
-      ++it;
-      skip_value_binary<Opts>(ctx, it, end);
-   }
-
-   template <opts Opts>
-   inline void skip_value_binary(is_context auto&& ctx, auto&& it, auto&& end) noexcept
-   {
-      switch (uint8_t(*it) & 0b00000'111) {
-      case tag::null: {
-         ++it;
-         break;
-      }
-      case tag::number: {
-         skip_number_binary(ctx, it, end);
-         break;
-      }
-      case tag::string: {
-         skip_string_binary(ctx, it, end);
-         break;
-      }
-      case tag::object: {
-         skip_object_binary<Opts>(ctx, it, end);
-         break;
-      }
-      case tag::typed_array: {
-         skip_typed_array_binary<Opts>(ctx, it, end);
-         break;
-      }
-      case tag::generic_array: {
-         skip_untyped_array_binary<Opts>(ctx, it, end);
-         break;
-      }
-      case tag::extensions: {
-         skip_additional_binary<Opts>(ctx, it, end);
-         break;
-      }
-      default:
-         ctx.error = error_code::syntax_error;
-      }
-   }
-}
diff --git a/deps/saucer/include/glaze/binary/write.hpp b/deps/saucer/include/glaze/binary/write.hpp
deleted file mode 100644
index bb6a74a..0000000
--- a/deps/saucer/include/glaze/binary/write.hpp
+++ /dev/null
@@ -1,965 +0,0 @@
-// Glaze Library
-// For the license information refer to glaze.hpp
-
-#pragma once
-
-#include <utility>
-
-#include "glaze/binary/header.hpp"
-#include "glaze/core/opts.hpp"
-#include "glaze/core/reflection_tuple.hpp"
-#include "glaze/core/seek.hpp"
-#include "glaze/core/write.hpp"
-#include "glaze/reflection/reflect.hpp"
-#include "glaze/util/dump.hpp"
-#include "glaze/util/for_each.hpp"
-#include "glaze/util/variant.hpp"
-
-namespace glz
-{
-   namespace detail
-   {
-      GLZ_ALWAYS_INLINE void dump_type(auto&& value, auto&& b, auto&& ix) noexcept
-      {
-         using V = std::decay_t<decltype(value)>;
-         constexpr auto n = sizeof(V);
-         if (ix + n > b.size()) [[unlikely]] {
-            b.resize((std::max)(b.size() * 2, ix + n));
-         }
-
-         constexpr auto is_volatile = std::is_volatile_v<std::remove_reference_t<decltype(value)>>;
-
-         if constexpr (is_volatile) {
-            const V temp = value;
-            std::memcpy(b.data() + ix, &temp, n);
-         }
-         else {
-            std::memcpy(b.data() + ix, &value, n);
-         }
-         ix += n;
-      }
-
-      template <uint64_t i, class... Args>
-      GLZ_ALWAYS_INLINE void dump_compressed_int(Args&&... args) noexcept
-      {
-         if constexpr (i < 64) {
-            const uint8_t c = uint8_t(i) << 2;
-            dump_type(c, args...);
-         }
-         else if constexpr (i < 16384) {
-            const uint16_t c = uint16_t(1) | (uint16_t(i) << 2);
-            dump_type(c, args...);
-         }
-         else if constexpr (i < 1073741824) {
-            const uint32_t c = uint32_t(2) | (uint32_t(i) << 2);
-            dump_type(c, args...);
-         }
-         else if constexpr (i < 4611686018427387904) {
-            const uint64_t c = uint64_t(3) | (uint64_t(i) << 2);
-            dump_type(c, args...);
-         }
-         else {
-            static_assert(i >= 4611686018427387904, "size not supported");
-         }
-      }
-
-      template <auto Opts, class... Args>
-      GLZ_ALWAYS_INLINE void dump_compressed_int(uint64_t i, Args&&... args) noexcept
-      {
-         if (i < 64) {
-            const uint8_t c = uint8_t(i) << 2;
-            dump_type(c, args...);
-         }
-         else if (i < 16384) {
-            const uint16_t c = uint16_t(1) | (uint16_t(i) << 2);
-            dump_type(c, args...);
-         }
-         else if (i < 1073741824) {
-            const uint32_t c = uint32_t(2) | (uint32_t(i) << 2);
-            dump_type(c, args...);
-         }
-         else if (i < 4611686018427387904) {
-            const uint64_t c = uint64_t(3) | (uint64_t(i) << 2);
-            dump_type(c, args...);
-         }
-         else {
-            std::abort(); // this should never happen because we should never allocate containers of this size
-         }
-      }
-
-      template <>
-      struct write<binary>
-      {
-         template <auto Opts, class T, is_context Ctx, class B, class IX>
-         GLZ_ALWAYS_INLINE static void op(T&& value, Ctx&& ctx, B&& b, IX&& ix) noexcept
-         {
-            to_binary<std::remove_cvref_t<T>>::template op<Opts>(std::forward<T>(value), std::forward<Ctx>(ctx),
-                                                                 std::forward<B>(b), std::forward<IX>(ix));
-         }
-
-         template <auto Opts, class T, is_context Ctx, class B, class IX>
-         GLZ_ALWAYS_INLINE static void no_header(T&& value, Ctx&& ctx, B&& b, IX&& ix) noexcept
-         {
-            to_binary<std::remove_cvref_t<T>>::template no_header<Opts>(std::forward<T>(value), std::forward<Ctx>(ctx),
-                                                                        std::forward<B>(b), std::forward<IX>(ix));
-         }
-      };
-
-      template <class T>
-         requires(glaze_value_t<T> && !custom_write<T>)
-      struct to_binary<T>
-      {
-         template <auto Opts, class Value, is_context Ctx, class B, class IX>
-         GLZ_ALWAYS_INLINE static void op(Value&& value, Ctx&& ctx, B&& b, IX&& ix) noexcept
-         {
-            using V = std::remove_cvref_t<decltype(get_member(std::declval<Value>(), meta_wrapper_v<T>))>;
-            to_binary<V>::template op<Opts>(get_member(std::forward<Value>(value), meta_wrapper_v<T>),
-                                            std::forward<Ctx>(ctx), std::forward<B>(b), std::forward<IX>(ix));
-         }
-      };
-
-      template <always_null_t T>
-      struct to_binary<T>
-      {
-         template <auto Opts>
-         GLZ_ALWAYS_INLINE static void op(auto&&, is_context auto&&, auto&&... args) noexcept
-         {
-            dump_type(uint8_t{0}, args...);
-         }
-      };
-
-      template <>
-      struct to_binary<hidden>
-      {
-         template <auto Opts>
-         GLZ_ALWAYS_INLINE static void op(auto&& value, auto&&, auto&&...) noexcept
-         {
-            static_assert(false_v<decltype(value)>, "hidden type should not be written");
-         }
-      };
-
-      template <is_bitset T>
-      struct to_binary<T>
-      {
-         template <auto Opts, class... Args>
-         GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&&, auto&&... args) noexcept
-         {
-            constexpr uint8_t type = uint8_t(3) << 3;
-            constexpr uint8_t tag = tag::typed_array | type;
-            dump_type(tag, args...);
-            dump_compressed_int<Opts>(value.size(), args...);
-
-            // constexpr auto num_bytes = (value.size() + 7) / 8;
-            const auto num_bytes = (value.size() + 7) / 8;
-            // .size() should be constexpr, but clang doesn't support this
-            std::vector<uint8_t> bytes(num_bytes);
-            // std::array<uint8_t, num_bytes> bytes{};
-            for (size_t byte_i{}, i{}; byte_i < num_bytes; ++byte_i) {
-               for (size_t bit_i = 0; bit_i < 8 && i < value.size(); ++bit_i, ++i) {
-                  bytes[byte_i] |= uint8_t(value[i]) << uint8_t(bit_i);
-               }
-            }
-            dump(bytes, args...);
-         }
-      };
-
-      template <glaze_flags_t T>
-      struct to_binary<T>
-      {
-         template <auto Opts>
-         GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&&, auto&& b, auto&& ix)
-         {
-            static constexpr auto N = glz::tuple_size_v<meta_t<T>>;
-
-            std::array<uint8_t, byte_length<T>()> data{};
-
-            for_each<N>([&](auto I) {
-               static constexpr auto item = glz::get<I>(meta_v<T>);
-
-               data[I / 8] |= static_cast<uint8_t>(get_member(value, glz::get<1>(item))) << (7 - (I % 8));
-            });
-
-            dump(data, b, ix);
-         }
-      };
-
-      template <is_member_function_pointer T>
-      struct to_binary<T>
-      {
-         template <auto Opts, class... Args>
-         GLZ_ALWAYS_INLINE static void op(auto&&, is_context auto&&, Args&&...) noexcept
-         {}
-      };
-
-      // write includers as empty strings
-      template <is_includer T>
-      struct to_binary<T>
-      {
-         template <auto Opts, class... Args>
-         GLZ_ALWAYS_INLINE static void op(auto&&, is_context auto&&, Args&&... args) noexcept
-         {
-            constexpr uint8_t tag = tag::string;
-
-            dump_type(tag, args...);
-            dump_compressed_int<Opts>(0, args...);
-         }
-      };
-
-      template <boolean_like T>
-      struct to_binary<T> final
-      {
-         template <auto Opts, class... Args>
-         GLZ_ALWAYS_INLINE static void op(const bool value, is_context auto&&, Args&&... args) noexcept
-         {
-            dump_type(value ? tag::bool_true : tag::bool_false, args...);
-         }
-      };
-
-      template <func_t T>
-      struct to_binary<T> final
-      {
-         template <auto Opts, class... Args>
-         GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, Args&&... args) noexcept
-         {
-            write<binary>::op<Opts>(name_v<std::decay_t<decltype(value)>>, ctx, args...);
-         }
-      };
-
-      template <class T>
-      struct to_binary<basic_raw_json<T>> final
-      {
-         template <auto Opts, class... Args>
-         GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, Args&&... args) noexcept
-         {
-            write<binary>::op<Opts>(value.str, ctx, std::forward<Args>(args)...);
-         }
-      };
-
-      template <class T>
-      struct to_binary<basic_text<T>> final
-      {
-         template <auto Opts, class... Args>
-         GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, Args&&... args) noexcept
-         {
-            write<binary>::op<Opts>(value.str, ctx, std::forward<Args>(args)...);
-         }
-      };
-
-      template <class T, class V>
-      constexpr size_t variant_index_v = []<size_t... I>(std::index_sequence<I...>) {
-         return ((std::is_same_v<T, std::variant_alternative_t<I, V>> * I) + ...);
-      }(std::make_index_sequence<std::variant_size_v<V>>{});
-
-      template <is_variant T>
-      struct to_binary<T> final
-      {
-         template <auto Opts, class... Args>
-         GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, Args&&... args) noexcept
-         {
-            using Variant = std::decay_t<decltype(value)>;
-
-            std::visit(
-               [&](auto&& v) {
-                  using V = std::decay_t<decltype(v)>;
-
-                  static constexpr uint64_t index = variant_index_v<V, Variant>;
-
-                  constexpr uint8_t tag = tag::extensions | 0b00001'000;
-
-                  dump_type(tag, args...);
-                  dump_compressed_int<index>(args...);
-                  write<binary>::op<Opts>(v, ctx, args...);
-               },
-               value);
-         }
-      };
-
-      template <class T>
-         requires num_t<T> || char_t<T> || glaze_enum_t<T>
-      struct to_binary<T> final
-      {
-         template <auto Opts, class... Args>
-         GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&&, Args&&... args) noexcept
-         {
-            constexpr uint8_t type = std::floating_point<T> ? 0 : (std::is_signed_v<T> ? 0b000'01'000 : 0b000'10'000);
-            constexpr uint8_t tag = tag::number | type | (byte_count<T> << 5);
-            dump_type(tag, args...);
-            dump_type(value, args...);
-         }
-
-         template <auto Opts>
-         GLZ_ALWAYS_INLINE static void no_header(auto&& value, is_context auto&&, auto&&... args) noexcept
-         {
-            dump_type(value, args...);
-         }
-      };
-
-      template <class T>
-         requires(std::is_enum_v<T> && !glaze_enum_t<T>)
-      struct to_binary<T> final
-      {
-         template <auto Opts, class... Args>
-         GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&&, Args&&... args) noexcept
-         {
-            using V = std::underlying_type_t<std::decay_t<T>>;
-
-            constexpr uint8_t type = std::floating_point<V> ? 0 : (std::is_signed_v<V> ? 0b000'01'000 : 0b000'10'000);
-            constexpr uint8_t tag = tag::number | type | (byte_count<V> << 5);
-            dump_type(tag, args...);
-            dump_type(value, args...);
-         }
-
-         template <auto Opts>
-         GLZ_ALWAYS_INLINE static void no_header(auto&& value, is_context auto&&, auto&&... args) noexcept
-         {
-            dump_type(value, args...);
-         }
-      };
-
-      template <class T>
-         requires complex_t<T>
-      struct to_binary<T> final
-      {
-         template <auto Opts>
-         GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&&, auto&&... args) noexcept
-         {
-            constexpr uint8_t tag = tag::extensions | 0b00011'000;
-            dump_type(tag, args...);
-
-            using V = typename T::value_type;
-            constexpr uint8_t complex_number = 0;
-            constexpr uint8_t type = std::floating_point<V> ? 0 : (std::is_signed_v<V> ? 0b000'01'000 : 0b000'10'000);
-            constexpr uint8_t complex_header = complex_number | type | (byte_count<V> << 5);
-            dump_type(complex_header, args...);
-            dump_type(value.real(), args...);
-            dump_type(value.imag(), args...);
-         }
-
-         template <auto Opts>
-         GLZ_ALWAYS_INLINE static void no_header(auto&& value, is_context auto&&, auto&&... args) noexcept
-         {
-            dump_type(value.real(), args...);
-            dump_type(value.imag(), args...);
-         }
-      };
-
-      template <str_t T>
-      struct to_binary<T> final
-      {
-         template <auto Opts>
-         GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&&, auto&& b, auto&& ix) noexcept
-         {
-            const sv str = [&]() -> const sv {
-               if constexpr (!char_array_t<T> && std::is_pointer_v<std::decay_t<T>>) {
-                  return value ? value : "";
-               }
-               else {
-                  return value;
-               }
-            }();
-
-            constexpr uint8_t tag = tag::string;
-
-            dump_type(tag, b, ix);
-            const auto n = str.size();
-            dump_compressed_int<Opts>(n, b, ix);
-
-            if (ix + n > b.size()) [[unlikely]] {
-               b.resize((std::max)(b.size() * 2, ix + n));
-            }
-
-            std::memcpy(b.data() + ix, str.data(), n);
-            ix += n;
-         }
-
-         template <auto Opts>
-         GLZ_ALWAYS_INLINE static void no_header(auto&& value, is_context auto&&, auto&& b, auto&& ix) noexcept
-         {
-            dump_compressed_int<Opts>(value.size(), b, ix);
-
-            const auto n = value.size();
-            if (ix + n > b.size()) [[unlikely]] {
-               b.resize((std::max)(b.size() * 2, ix + n));
-            }
-
-            std::memcpy(b.data() + ix, value.data(), n);
-            ix += n;
-         }
-      };
-
-      template <writable_array_t T>
-      struct to_binary<T> final
-      {
-         template <auto Opts, class... Args>
-         GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, Args&&... args) noexcept
-         {
-            using V = range_value_t<std::decay_t<T>>;
-
-            if constexpr (boolean_like<V>) {
-               constexpr uint8_t type = uint8_t(3) << 3;
-               constexpr uint8_t tag = tag::typed_array | type;
-               dump_type(tag, args...);
-               dump_compressed_int<Opts>(value.size(), args...);
-
-               // booleans must be dumped using single bits
-               if constexpr (has_static_size<T>) {
-                  constexpr auto num_bytes = (value.size() + 7) / 8;
-                  std::array<uint8_t, num_bytes> bytes{};
-                  for (size_t byte_i{}, i{}; byte_i < num_bytes; ++byte_i) {
-                     for (size_t bit_i = 7; bit_i < 8 && i < value.size(); --bit_i, ++i) {
-                        bytes[byte_i] |= uint8_t(value[i]) << uint8_t(bit_i);
-                     }
-                  }
-                  dump(bytes, args...);
-               }
-               else if constexpr (accessible<T>) {
-                  const auto num_bytes = (value.size() + 7) / 8;
-                  for (size_t byte_i{}, i{}; byte_i < num_bytes; ++byte_i) {
-                     uint8_t byte{};
-                     for (size_t bit_i = 7; bit_i < 8 && i < value.size(); --bit_i, ++i) {
-                        byte |= uint8_t(value[i]) << uint8_t(bit_i);
-                     }
-                     dump_type(byte, args...);
-                  }
-               }
-               else {
-                  static_assert(false_v<T>);
-               }
-            }
-            else if constexpr (num_t<V>) {
-               constexpr uint8_t type =
-                  std::floating_point<V> ? 0 : (std::is_signed_v<V> ? 0b000'01'000 : 0b000'10'000);
-               constexpr uint8_t tag = tag::typed_array | type | (byte_count<V> << 5);
-               dump_type(tag, args...);
-               dump_compressed_int<Opts>(value.size(), args...);
-
-               if constexpr (contiguous<T>) {
-                  constexpr auto is_volatile =
-                     std::is_volatile_v<std::remove_reference_t<std::remove_pointer_t<decltype(value.data())>>>;
-
-                  auto dump_array = [&](auto&& b, auto&& ix) {
-                     const auto n = value.size() * sizeof(V);
-                     if (ix + n > b.size()) [[unlikely]] {
-                        b.resize((std::max)(b.size() * 2, ix + n));
-                     }
-
-                     if constexpr (is_volatile) {
-                        V temp;
-                        const auto n_elements = value.size();
-                        for (size_t i = 0; i < n_elements; ++i) {
-                           temp = value[i];
-                           std::memcpy(b.data() + ix, &temp, sizeof(V));
-                           ix += sizeof(V);
-                        }
-                     }
-                     else {
-                        std::memcpy(b.data() + ix, value.data(), n);
-                        ix += n;
-                     }
-                  };
-
-                  dump_array(args...);
-               }
-               else {
-                  for (auto& x : value) {
-                     dump_type(x, args...);
-                  }
-               }
-            }
-            else if constexpr (str_t<V>) {
-               constexpr uint8_t type = uint8_t(3) << 3;
-               constexpr uint8_t string_indicator = uint8_t(1) << 5;
-               constexpr uint8_t tag = tag::typed_array | type | string_indicator;
-               dump_type(tag, args...);
-               dump_compressed_int<Opts>(value.size(), args...);
-
-               for (auto& x : value) {
-                  dump_compressed_int<Opts>(x.size(), args...);
-
-                  auto dump_array = [&](auto&& b, auto&& ix) {
-                     const auto n = x.size();
-                     if (ix + n > b.size()) [[unlikely]] {
-                        b.resize((std::max)(b.size() * 2, ix + n));
-                     }
-
-                     std::memcpy(b.data() + ix, x.data(), n);
-                     ix += n;
-                  };
-
-                  dump_array(args...);
-               }
-            }
-            else if constexpr (complex_t<V>) {
-               constexpr uint8_t tag = tag::extensions | 0b00011'000;
-               dump_type(tag, args...);
-
-               using X = typename V::value_type;
-               constexpr uint8_t complex_array = 1;
-               constexpr uint8_t type =
-                  std::floating_point<X> ? 0 : (std::is_signed_v<X> ? 0b000'01'000 : 0b000'10'000);
-               constexpr uint8_t complex_header = complex_array | type | (byte_count<X> << 5);
-               dump_type(complex_header, args...);
-
-               dump_compressed_int<Opts>(value.size(), args...);
-
-               for (auto&& x : value) {
-                  write<binary>::no_header<Opts>(x, ctx, args...);
-               }
-            }
-            else {
-               constexpr uint8_t tag = tag::generic_array;
-               dump_type(tag, args...);
-               dump_compressed_int<Opts>(value.size(), args...);
-
-               for (auto&& x : value) {
-                  write<binary>::op<Opts>(x, ctx, args...);
-               }
-            }
-         }
-      };
-
-      template <pair_t T>
-      struct to_binary<T> final
-      {
-         template <auto Opts, class... Args>
-         GLZ_ALWAYS_INLINE static auto op(auto&& value, is_context auto&& ctx, Args&&... args) noexcept
-         {
-            using Key = typename T::first_type;
-
-            constexpr uint8_t type = str_t<Key> ? 0 : (std::is_signed_v<Key> ? 0b000'01'000 : 0b000'10'000);
-            constexpr uint8_t byte_cnt = str_t<Key> ? 0 : byte_count<Key>;
-            constexpr uint8_t tag = tag::object | type | (byte_cnt << 5);
-            dump_type(tag, args...);
-
-            dump_compressed_int<Opts>(1, args...);
-            const auto& [k, v] = value;
-            write<binary>::no_header<Opts>(k, ctx, args...);
-            write<binary>::op<Opts>(v, ctx, args...);
-         }
-      };
-
-      template <writable_map_t T>
-      struct to_binary<T> final
-      {
-         template <auto Opts, class... Args>
-         static auto op(auto&& value, is_context auto&& ctx, Args&&... args) noexcept
-         {
-            using Key = typename T::key_type;
-
-            constexpr uint8_t type = str_t<Key> ? 0 : (std::is_signed_v<Key> ? 0b000'01'000 : 0b000'10'000);
-            constexpr uint8_t byte_cnt = str_t<Key> ? 0 : byte_count<Key>;
-            constexpr uint8_t tag = tag::object | type | (byte_cnt << 5);
-            dump_type(tag, args...);
-
-            dump_compressed_int<Opts>(value.size(), args...);
-            for (auto&& [k, v] : value) {
-               write<binary>::no_header<Opts>(k, ctx, args...);
-               write<binary>::op<Opts>(v, ctx, args...);
-            }
-         }
-      };
-
-      template <nullable_t T>
-         requires(std::is_array_v<T>)
-      struct to_binary<T>
-      {
-         template <auto Opts, class V, size_t N, class... Args>
-         GLZ_ALWAYS_INLINE static void op(const V (&value)[N], is_context auto&& ctx, Args&&... args) noexcept
-         {
-            write<binary>::op<Opts>(std::span{value, N}, ctx, std::forward<Args>(args)...);
-         }
-      };
-
-      template <nullable_t T>
-         requires(!std::is_array_v<T>)
-      struct to_binary<T> final
-      {
-         template <auto Opts, class... Args>
-         GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, Args&&... args) noexcept
-         {
-            if (value) {
-               write<binary>::op<Opts>(*value, ctx, args...);
-            }
-            else {
-               dump<tag::null>(args...);
-            }
-         }
-      };
-
-      template <class T>
-         requires is_specialization_v<T, glz::obj> || is_specialization_v<T, glz::obj_copy>
-      struct to_binary<T>
-      {
-         template <auto Options>
-         static void op(auto&& value, is_context auto&& ctx, auto&&... args) noexcept
-         {
-            using V = std::decay_t<decltype(value.value)>;
-            static constexpr auto N = glz::tuple_size_v<V> / 2;
-
-            if constexpr (!Options.opening_handled) {
-               constexpr uint8_t type = 0; // string key
-               constexpr uint8_t tag = tag::object | type;
-               dump_type(tag, args...);
-               dump_compressed_int<N>(args...);
-            }
-
-            for_each<N>([&](auto I) {
-               constexpr auto Opts = opening_handled_off<Options>();
-               write<binary>::no_header<Opts>(get<2 * I>(value.value), ctx, args...);
-               write<binary>::op<Opts>(get<2 * I + 1>(value.value), ctx, args...);
-            });
-         }
-      };
-
-      template <class T>
-         requires is_specialization_v<T, glz::merge>
-      consteval size_t merge_element_count()
-      {
-         size_t count{};
-         using Tuple = std::decay_t<decltype(std::declval<T>().value)>;
-         for_each<glz::tuple_size_v<Tuple>>([&](auto I) constexpr {
-            using Value = std::decay_t<glz::tuple_element_t<I, Tuple>>;
-            if constexpr (is_specialization_v<Value, glz::obj> || is_specialization_v<Value, glz::obj_copy>) {
-               count += glz::tuple_size_v<decltype(std::declval<Value>().value)> / 2;
-            }
-            else {
-               count += reflection_count<Value>;
-            }
-         });
-         return count;
-      }
-
-      template <class T>
-         requires is_specialization_v<T, glz::merge>
-      struct to_binary<T>
-      {
-         template <auto Opts>
-         static void op(auto&& value, is_context auto&& ctx, auto&& b, auto&& ix) noexcept
-         {
-            using V = std::decay_t<decltype(value.value)>;
-            static constexpr auto N = glz::tuple_size_v<V>;
-
-            constexpr uint8_t type = 0; // string key
-            constexpr uint8_t tag = tag::object | type;
-            dump_type(tag, b, ix);
-            dump_compressed_int<merge_element_count<T>()>(b, ix);
-
-            [&]<size_t... I>(std::index_sequence<I...>) {
-               (write<binary>::op<opening_handled<Opts>()>(glz::get<I>(value.value), ctx, b, ix), ...);
-            }(std::make_index_sequence<N>{});
-         }
-      };
-
-      template <class T>
-         requires(glaze_object_t<T> || reflectable<T>)
-      struct to_binary<T> final
-      {
-         static constexpr auto N = reflection_count<T>;
-         static constexpr size_t count_to_write = [] {
-            size_t count{};
-            for_each<N>([&](auto I) {
-               using Element = glaze_tuple_element<I, N, T>;
-               using V = std::remove_cvref_t<typename Element::type>;
-
-               if constexpr (std::same_as<V, hidden> || std::same_as<V, skip>) {
-                  // do not serialize
-                  // not serializing is_includer<V> would be a breaking change
-               }
-               else {
-                  ++count;
-               }
-            });
-            return count;
-         }();
-
-         template <auto Opts, class... Args>
-            requires(Opts.structs_as_arrays == true)
-         static void op(auto&& value, is_context auto&& ctx, Args&&... args) noexcept
-         {
-            dump<tag::generic_array>(args...);
-            dump_compressed_int<count_to_write>(args...);
-            decltype(auto) t = reflection_tuple<T>(value);
-            for_each<N>([&](auto I) {
-               using Element = glaze_tuple_element<I, N, T>;
-               static constexpr size_t member_index = Element::member_index;
-               using val_t = std::remove_cvref_t<typename Element::type>;
-
-               if constexpr (std::same_as<val_t, hidden> || std::same_as<val_t, skip>) {
-                  return;
-               }
-               else {
-                  decltype(auto) member = [&]() -> decltype(auto) {
-                     if constexpr (reflectable<T>) {
-                        return std::get<I>(t);
-                     }
-                     else {
-                        return get<member_index>(get<I>(meta_v<std::decay_t<T>>));
-                     }
-                  }();
-
-                  write<binary>::op<Opts>(get_member(value, member), ctx, args...);
-               }
-            });
-         }
-
-         template <auto Options, class... Args>
-            requires(Options.structs_as_arrays == false)
-         static void op(auto&& value, is_context auto&& ctx, Args&&... args) noexcept
-         {
-            if constexpr (!Options.opening_handled) {
-               constexpr uint8_t type = 0; // string key
-               constexpr uint8_t tag = tag::object | type;
-               dump_type(tag, args...);
-               dump_compressed_int<count_to_write>(args...);
-            }
-            constexpr auto Opts = opening_handled_off<Options>();
-
-            decltype(auto) t = reflection_tuple<T>(value);
-            for_each<N>([&](auto I) {
-               using Element = glaze_tuple_element<I, N, T>;
-               static constexpr size_t member_index = Element::member_index;
-               static constexpr bool use_reflection = Element::use_reflection;
-               using val_t = std::remove_cvref_t<typename Element::type>;
-
-               if constexpr (std::same_as<val_t, hidden> || std::same_as<val_t, skip>) {
-                  return;
-               }
-               else {
-                  static constexpr sv key = key_name<I, T, use_reflection>;
-                  write<binary>::no_header<Opts>(key, ctx, args...);
-
-                  decltype(auto) member = [&]() -> decltype(auto) {
-                     if constexpr (reflectable<T>) {
-                        return std::get<I>(t);
-                     }
-                     else {
-                        return get<member_index>(get<I>(meta_v<std::decay_t<T>>));
-                     }
-                  }();
-
-                  write<binary>::op<Opts>(get_member(value, member), ctx, args...);
-               }
-            });
-         }
-      };
-
-      template <class T>
-         requires glaze_array_t<T>
-      struct to_binary<T> final
-      {
-         template <auto Opts, class... Args>
-         GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, Args&&... args) noexcept
-         {
-            dump<tag::generic_array>(args...);
-
-            static constexpr auto N = glz::tuple_size_v<meta_t<T>>;
-            dump_compressed_int<N>(args...);
-
-            using V = std::decay_t<T>;
-            for_each<glz::tuple_size_v<meta_t<V>>>(
-               [&](auto I) { write<binary>::op<Opts>(get_member(value, glz::get<I>(meta_v<V>)), ctx, args...); });
-         }
-      };
-
-      template <class T>
-         requires(tuple_t<T> || is_std_tuple<T>)
-      struct to_binary<T> final
-      {
-         template <auto Opts, class... Args>
-         GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, Args&&... args) noexcept
-         {
-            dump<tag::generic_array>(args...);
-
-            static constexpr auto N = glz::tuple_size_v<T>;
-            dump_compressed_int<N>(args...);
-
-            if constexpr (is_std_tuple<T>) {
-               [&]<size_t... I>(std::index_sequence<I...>) {
-                  (write<binary>::op<Opts>(std::get<I>(value), ctx, args...), ...);
-               }(std::make_index_sequence<N>{});
-            }
-            else {
-               [&]<size_t... I>(std::index_sequence<I...>) {
-                  (write<binary>::op<Opts>(glz::get<I>(value), ctx, args...), ...);
-               }(std::make_index_sequence<N>{});
-            }
-         }
-      };
-
-      template <filesystem_path T>
-      struct to_binary<T>
-      {
-         template <auto Opts, class... Args>
-         GLZ_ALWAYS_INLINE static void op(auto&& value, Args&&... args) noexcept
-         {
-            to_binary<decltype(value.string())>::template op<Opts>(value.string(), std::forward<Args>(args)...);
-         }
-      };
-
-      template <class T = void>
-      struct to_binary_partial
-      {};
-
-      template <auto& Partial, auto Opts, class T, class Ctx, class B, class IX>
-      concept write_binary_partial_invocable = requires(T&& value, Ctx&& ctx, B&& b, IX&& ix) {
-         to_binary_partial<std::remove_cvref_t<T>>::template op<Partial, Opts>(
-            std::forward<T>(value), std::forward<Ctx>(ctx), std::forward<B>(b), std::forward<IX>(ix));
-      };
-
-      template <>
-      struct write_partial<binary>
-      {
-         template <auto& Partial, auto Opts, class T, is_context Ctx, class B, class IX>
-         static void op(T&& value, Ctx&& ctx, B&& b, IX&& ix) noexcept
-         {
-            if constexpr (std::count(Partial.begin(), Partial.end(), "") > 0) {
-               detail::write<binary>::op<Opts>(value, ctx, b, ix);
-            }
-            else if constexpr (write_binary_partial_invocable<Partial, Opts, T, Ctx, B, IX>) {
-               to_binary_partial<std::remove_cvref_t<T>>::template op<Partial, Opts>(
-                  std::forward<T>(value), std::forward<Ctx>(ctx), std::forward<B>(b), std::forward<IX>(ix));
-            }
-            else {
-               static_assert(false_v<T>, "Glaze metadata is probably needed for your type");
-            }
-         }
-      };
-
-      // Only object types are supported for partial
-      template <class T>
-         requires(glaze_object_t<T> || writable_map_t<T> || reflectable<T>)
-      struct to_binary_partial<T> final
-      {
-         template <auto& Partial, auto Opts, class... Args>
-         static void op(auto&& value, is_context auto&& ctx, auto&& b, auto&& ix) noexcept
-         {
-            static constexpr auto sorted = sort_json_ptrs(Partial);
-            static constexpr auto groups = glz::group_json_ptrs<sorted>();
-            static constexpr auto N = glz::tuple_size_v<std::decay_t<decltype(groups)>>;
-
-            constexpr uint8_t type = 0; // string
-            constexpr uint8_t tag = tag::object | type;
-            detail::dump_type(tag, b, ix);
-
-            detail::dump_compressed_int<N>(b, ix);
-
-            if constexpr (glaze_object_t<T>) {
-               for_each<N>([&](auto I) {
-                  if (bool(ctx.error)) [[unlikely]] {
-                     return;
-                  }
-
-                  static constexpr auto group = glz::get<I>(groups);
-
-                  static constexpr auto key = get<0>(group);
-                  static constexpr auto sub_partial = get<1>(group);
-                  static constexpr auto frozen_map = detail::make_map<T>();
-                  static constexpr auto member_it = frozen_map.find(key);
-                  static_assert(member_it != frozen_map.end(), "Invalid key passed to partial write");
-                  static constexpr auto index = member_it->second.index();
-                  static constexpr decltype(auto) member_ptr = get<index>(member_it->second);
-
-                  detail::write<binary>::no_header<Opts>(key, ctx, b, ix);
-                  write_partial<binary>::op<sub_partial, Opts>(glz::detail::get_member(value, member_ptr), ctx, b, ix);
-               });
-            }
-            else if constexpr (writable_map_t<T>) {
-               for_each<N>([&](auto I) {
-                  if (bool(ctx.error)) [[unlikely]] {
-                     return;
-                  }
-
-                  static constexpr auto group = glz::get<I>(groups);
-
-                  static constexpr auto key_value = get<0>(group);
-                  static constexpr auto sub_partial = get<1>(group);
-                  if constexpr (findable<std::decay_t<T>, decltype(key_value)>) {
-                     detail::write<binary>::no_header<Opts>(key_value, ctx, b, ix);
-                     auto it = value.find(key_value);
-                     if (it != value.end()) {
-                        write_partial<binary>::op<sub_partial, Opts>(it->second, ctx, b, ix);
-                     }
-                     else {
-                        ctx.error = error_code::invalid_partial_key;
-                        return;
-                     }
-                  }
-                  else {
-                     static thread_local auto key =
-                        typename std::decay_t<T>::key_type(key_value); // TODO handle numeric keys
-                     detail::write<binary>::no_header<Opts>(key, ctx, b, ix);
-                     auto it = value.find(key);
-                     if (it != value.end()) {
-                        write_partial<binary>::op<sub_partial, Opts>(it->second, ctx, b, ix);
-                     }
-                     else {
-                        ctx.error = error_code::invalid_partial_key;
-                        return;
-                     }
-                  }
-               });
-            }
-         }
-      };
-   }
-
-   template <write_binary_supported T, class Buffer>
-   [[nodiscard]] error_ctx write_binary(T&& value, Buffer&& buffer) noexcept
-   {
-      return write<opts{.format = binary}>(std::forward<T>(value), std::forward<Buffer>(buffer));
-   }
-
-   template <opts Opts = opts{}, write_binary_supported T>
-   [[nodiscard]] glz::expected<std::string, error_ctx> write_binary(T&& value) noexcept
-   {
-      return write<set_binary<Opts>()>(std::forward<T>(value));
-   }
-
-   template <auto& Partial, write_binary_supported T, class Buffer>
-   [[nodiscard]] error_ctx write_binary(T&& value, Buffer&& buffer) noexcept
-   {
-      return write<Partial, opts{.format = binary}>(std::forward<T>(value), std::forward<Buffer>(buffer));
-   }
-
-   // requires file_name to be null terminated
-   template <opts Opts = opts{}, write_binary_supported T>
-   [[nodiscard]] error_ctx write_file_binary(T&& value, const sv file_name, auto&& buffer) noexcept
-   {
-      static_assert(sizeof(decltype(*buffer.data())) == 1);
-
-      const auto ec = write<set_binary<Opts>()>(std::forward<T>(value), buffer);
-      if (bool(ec)) [[unlikely]] {
-         return ec;
-      }
-
-      std::ofstream file(file_name.data(), std::ios::binary);
-
-      if (file) {
-         file.write(reinterpret_cast<const char*>(buffer.data()), buffer.size());
-      }
-      else {
-         return {error_code::file_open_failure};
-      }
-
-      return {};
-   }
-
-   template <write_binary_supported T, class Buffer>
-   [[nodiscard]] error_ctx write_binary_untagged(T&& value, Buffer&& buffer) noexcept
-   {
-      return write<opts{.format = binary, .structs_as_arrays = true}>(std::forward<T>(value),
-                                                                      std::forward<Buffer>(buffer));
-   }
-
-   template <write_binary_supported T>
-   [[nodiscard]] error_ctx write_binary_untagged(T&& value) noexcept
-   {
-      return write<opts{.format = binary, .structs_as_arrays = true}>(std::forward<T>(value));
-   }
-
-   template <opts Opts = opts{}, write_binary_supported T>
-   [[nodiscard]] error_ctx write_file_binary_untagged(T&& value, const std::string& file_name, auto&& buffer) noexcept
-   {
-      return write_file_binary<opt_true<Opts, &opts::structs_as_arrays>>(std::forward<T>(value), file_name, buffer);
-   }
-}
diff --git a/deps/saucer/include/glaze/compare/approx.hpp b/deps/saucer/include/glaze/compare/approx.hpp
index c6181bd..b05f11c 100644
--- a/deps/saucer/include/glaze/compare/approx.hpp
+++ b/deps/saucer/include/glaze/compare/approx.hpp
@@ -4,21 +4,22 @@
 #pragma once
 
 #include "glaze/core/common.hpp"
+#include "glaze/core/reflect.hpp"
 
 namespace glz
 {
    // Test that two meta objects are equal, with epsilon support for floating point values
    struct approx_equal_to final
    {
-      template <detail::glaze_object_t T>
+      template <glaze_object_t T>
       constexpr bool operator()(T&& lhs, T&& rhs) noexcept
       {
-         constexpr auto N = glz::tuple_size_v<meta_t<T>>;
+         constexpr auto N = reflect<T>::size;
 
          bool equal = true;
-         for_each_short_circuit<N>([&](auto I) {
-            auto& l = detail::get_member(lhs, get<1>(get<I>(meta_v<T>)));
-            auto& r = detail::get_member(rhs, get<1>(get<I>(meta_v<T>)));
+         for_each_short_circuit<N>([&]<auto I>() {
+            auto& l = get_member(lhs, get<I>(reflect<T>::values));
+            auto& r = get_member(rhs, get<I>(reflect<T>::values));
             using V = std::decay_t<decltype(l)>;
             if constexpr (std::floating_point<V> && requires { meta<std::decay_t<T>>::compare_epsilon; }) {
                if (std::abs(l - r) >= meta<std::decay_t<T>>::compare_epsilon) {
diff --git a/deps/saucer/include/glaze/compare/compare.hpp b/deps/saucer/include/glaze/compare/compare.hpp
index 1579119..bda107a 100644
--- a/deps/saucer/include/glaze/compare/compare.hpp
+++ b/deps/saucer/include/glaze/compare/compare.hpp
@@ -6,24 +6,25 @@
 #include <functional>
 
 #include "glaze/core/common.hpp"
+#include "glaze/core/reflect.hpp"
 
 namespace glz
 {
    struct equal_to final
    {
-      template <detail::glaze_object_t T>
+      template <glaze_object_t T>
       constexpr bool operator()(T&& lhs, T&& rhs) noexcept
       {
          if constexpr (std::equality_comparable<T>) {
             return lhs == rhs;
          }
          else {
-            constexpr auto N = glz::tuple_size_v<meta_t<T>>;
+            constexpr auto N = reflect<T>::size;
 
             bool equal = true;
-            for_each_short_circuit<N>([&](auto I) {
-               auto& l = detail::get_member(lhs, get<1>(get<I>(meta_v<T>)));
-               auto& r = detail::get_member(rhs, get<1>(get<I>(meta_v<T>)));
+            for_each_short_circuit<N>([&]<auto I>() {
+               auto& l = get_member(lhs, get<I>(reflect<T>::values));
+               auto& r = get_member(rhs, get<I>(reflect<T>::values));
                if (!std::equal_to{}(l, r)) {
                   equal = false;
                   return true; // exit
@@ -38,15 +39,15 @@ namespace glz
 
    struct less final
    {
-      template <detail::glaze_object_t T>
+      template <glaze_object_t T>
       constexpr bool operator()(T&& lhs, T&& rhs) noexcept
       {
-         constexpr auto N = glz::tuple_size_v<meta_t<T>>;
+         constexpr auto N = reflect<T>::size;
 
          bool less_than = true;
-         for_each_short_circuit<N>([&](auto I) {
-            auto& l = detail::get_member(lhs, get<1>(get<I>(meta_v<T>)));
-            auto& r = detail::get_member(rhs, get<1>(get<I>(meta_v<T>)));
+         for_each_short_circuit<N>([&]<auto I>() {
+            auto& l = get_member(lhs, get<I>(reflect<T>::values));
+            auto& r = get_member(rhs, get<I>(reflect<T>::values));
             if (!std::less{}(l, r)) {
                less_than = false;
                return true; // exit
@@ -60,15 +61,15 @@ namespace glz
 
    struct less_equal final
    {
-      template <detail::glaze_object_t T>
+      template <glaze_object_t T>
       constexpr bool operator()(T&& lhs, T&& rhs) noexcept
       {
-         constexpr auto N = glz::tuple_size_v<meta_t<T>>;
+         constexpr auto N = reflect<T>::size;
 
          bool less_than = true;
-         for_each_short_circuit<N>([&](auto I) {
-            auto& l = detail::get_member(lhs, get<1>(get<I>(meta_v<T>)));
-            auto& r = detail::get_member(rhs, get<1>(get<I>(meta_v<T>)));
+         for_each_short_circuit<N>([&]<auto I>() {
+            auto& l = get_member(lhs, get<I>(reflect<T>::values));
+            auto& r = get_member(rhs, get<I>(reflect<T>::values));
             if (!std::less_equal{}(l, r)) {
                less_than = false;
                return true; // exit
@@ -82,15 +83,15 @@ namespace glz
 
    struct greater final
    {
-      template <detail::glaze_object_t T>
+      template <glaze_object_t T>
       constexpr bool operator()(T&& lhs, T&& rhs) noexcept
       {
-         constexpr auto N = glz::tuple_size_v<meta_t<T>>;
+         constexpr auto N = reflect<T>::size;
 
          bool greater_than = true;
-         for_each_short_circuit<N>([&](auto I) {
-            auto& l = detail::get_member(lhs, get<1>(get<I>(meta_v<T>)));
-            auto& r = detail::get_member(rhs, get<1>(get<I>(meta_v<T>)));
+         for_each_short_circuit<N>([&]<auto I>() {
+            auto& l = get_member(lhs, get<I>(reflect<T>::values));
+            auto& r = get_member(rhs, get<I>(reflect<T>::values));
             if (!std::greater{}(l, r)) {
                greater_than = false;
                return true; // exit
@@ -104,15 +105,15 @@ namespace glz
 
    struct greater_equal final
    {
-      template <detail::glaze_object_t T>
+      template <glaze_object_t T>
       constexpr bool operator()(T&& lhs, T&& rhs) noexcept
       {
-         constexpr auto N = glz::tuple_size_v<meta_t<T>>;
+         constexpr auto N = reflect<T>::size;
 
          bool greater_than = true;
-         for_each_short_circuit<N>([&](auto I) {
-            auto& l = detail::get_member(lhs, get<1>(get<I>(meta_v<T>)));
-            auto& r = detail::get_member(rhs, get<1>(get<I>(meta_v<T>)));
+         for_each_short_circuit<N>([&]<auto I>() {
+            auto& l = get_member(lhs, get<I>(reflect<T>::values));
+            auto& r = get_member(rhs, get<I>(reflect<T>::values));
             if (!std::greater_equal{}(l, r)) {
                greater_than = false;
                return true; // exit
diff --git a/deps/saucer/include/glaze/concepts/container_concepts.hpp b/deps/saucer/include/glaze/concepts/container_concepts.hpp
index 2acd437..b6925be 100644
--- a/deps/saucer/include/glaze/concepts/container_concepts.hpp
+++ b/deps/saucer/include/glaze/concepts/container_concepts.hpp
@@ -8,12 +8,31 @@
 #include <ranges>
 #include <utility>
 #include <vector>
+#include <version>
+
+// Over time we want most concepts to use the nomenclature:
+// is_
+// has_
+// _like
+// Avoid the use of _t as that makes it seem like a type and not a concept
 
 namespace glz
 {
    template <class T, class... U>
    concept is_any_of = (std::same_as<T, U> || ...);
 
+   template <class T>
+   concept has_value_type = requires { typename T::value_type; };
+
+   template <class T>
+   concept has_element_type = requires { typename T::element_type; };
+
+   template <class T>
+   concept has_first_type = requires { typename T::first_type; };
+
+   template <class T>
+   concept has_second_type = requires { typename T::second_type; };
+
    template <class T>
    concept resizable = requires(T v) { v.resize(0); };
 
@@ -25,9 +44,7 @@ namespace glz
 
    template <class T>
    concept has_empty = requires(T v) {
-      {
-         v.empty()
-      } -> std::convertible_to<bool>;
+      { v.empty() } -> std::convertible_to<bool>;
    };
 
    template <class T>
@@ -38,9 +55,7 @@ namespace glz
 
    template <class T>
    concept has_capacity = requires(T t) {
-      {
-         t.capacity()
-      } -> std::integral;
+      { t.capacity() } -> std::integral;
    };
 
    template <class T>
@@ -50,23 +65,25 @@ namespace glz
    concept non_const_buffer = !std::is_const_v<Buffer>;
 }
 
-namespace glz::detail
+namespace glz
 {
    template <class T>
-   concept char_t = std::same_as<std::decay_t<T>, char>;
+   concept char_t = std::same_as<std::remove_cvref_t<T>, char>;
 
    template <class T>
-   concept wide_char_t = std::same_as<std::decay_t<T>, char16_t> || std::same_as<std::decay_t<T>, char32_t> ||
-                         std::same_as<std::decay_t<T>, wchar_t>;
+   concept wide_char_t =
+      std::same_as<std::remove_cvref_t<T>, char16_t> || std::same_as<std::remove_cvref_t<T>, char32_t> ||
+      std::same_as<std::remove_cvref_t<T>, wchar_t>;
 
    template <class T>
-   concept bool_t = std::same_as<std::decay_t<T>, bool> || std::same_as<std::decay_t<T>, std::vector<bool>::reference>;
+   concept bool_t =
+      std::same_as<std::remove_cvref_t<T>, bool> || std::same_as<std::remove_cvref_t<T>, std::vector<bool>::reference>;
 
    template <class T>
-   concept int_t = std::integral<std::decay_t<T>> && !char_t<T> && !wide_char_t<T> && !bool_t<T>;
+   concept int_t = std::integral<std::remove_cvref_t<T>> && !char_t<T> && !wide_char_t<T> && !bool_t<T>;
 
    template <class T>
-   concept num_t = std::floating_point<std::decay_t<T>> || int_t<T>;
+   concept num_t = std::floating_point<std::remove_cvref_t<T>> || int_t<T>;
 
    template <class T>
    concept is_float128 = requires(T x) {
@@ -76,94 +93,84 @@ namespace glz::detail
 
    template <typename T>
    concept complex_t = requires(T a, T b) {
-      {
-         a.real()
-      } -> std::convertible_to<typename T::value_type>;
-      {
-         a.imag()
-      } -> std::convertible_to<typename T::value_type>;
-      {
-         T(a.real(), a.imag())
-      } -> std::same_as<T>;
-      {
-         a + b
-      } -> std::same_as<T>;
-      {
-         a - b
-      } -> std::same_as<T>;
-      {
-         a* b
-      } -> std::same_as<T>;
-      {
-         a / b
-      } -> std::same_as<T>;
+      { a.real() } -> std::convertible_to<typename T::value_type>;
+      { a.imag() } -> std::convertible_to<typename T::value_type>;
+      { T(a.real(), a.imag()) } -> std::same_as<T>;
+      { a + b } -> std::same_as<T>;
+      { a - b } -> std::same_as<T>;
+      { a * b } -> std::same_as<T>;
+      { a / b } -> std::same_as<T>;
+   };
+
+   template <class T>
+   concept optional_like = requires(T t, typename T::value_type v) {
+      { T() } -> std::same_as<T>;
+      { T(v) } -> std::same_as<T>;
+      { t.has_value() } -> std::convertible_to<bool>;
+      { t.value() };
+      { t = v };
+      { t.reset() };
+      { t.emplace() };
    };
 
    template <class T>
    concept pair_t = requires(T pair) {
-      {
-         pair.first
-      };
-      {
-         pair.second
-      };
+      typename std::decay_t<T>::first_type;
+      typename std::decay_t<T>::second_type;
+      { pair.first };
+      { pair.second };
    };
 
    template <class T>
    concept emplaceable = requires(T container) {
-      {
-         container.emplace(std::declval<typename T::value_type>())
-      };
+      { container.emplace(std::declval<typename T::value_type>()) };
    };
 
    template <class T>
    concept push_backable = requires(T container) {
-      {
-         container.push_back(std::declval<typename T::value_type>())
-      };
+      { container.push_back(std::declval<typename T::value_type>()) };
    };
 
    template <class T>
    concept emplace_backable = requires(T container) {
-      {
-         container.emplace_back()
-      } -> std::same_as<typename T::reference>;
+      { container.emplace_back() } -> std::same_as<typename T::reference>;
+   };
+
+   template <class T>
+   concept has_try_emplace_back = requires(T container) {
+      { container.try_emplace_back() } -> std::same_as<typename T::pointer>;
    };
 
    template <class T>
-   concept has_push_back = requires(T t, typename T::value_type v) { t.push_back(v); };
+   concept has_append = requires(T t, typename T::const_iterator it) { t.append(it, it); };
+
+   template <class T>
+   concept has_assign = requires(T t, const typename T::value_type* v, typename T::size_type sz) { t.assign(v, sz); };
 
    template <class T>
    concept accessible = requires(T container) {
-      {
-         container[size_t{}]
-      } -> std::same_as<typename T::reference>;
+      { container[size_t{}] } -> std::same_as<typename T::reference>;
    };
 
    template <class T>
-   concept vector_like = resizable<T> && accessible<T> && has_data<T>;
+   concept vector_like =
+      resizable<std::remove_cvref_t<T>> && accessible<std::remove_cvref_t<T>> && has_data<std::remove_cvref_t<T>>;
+
+   template <class T>
+   concept is_inplace_vector =
+      has_try_emplace_back<T> && accessible<std::remove_cvref_t<T>> && has_data<std::remove_cvref_t<T>>;
 
    template <class T>
    concept map_subscriptable = requires(T container) {
-      {
-         container[std::declval<typename T::key_type>()]
-      } -> std::same_as<typename T::mapped_type&>;
+      { container[std::declval<typename T::key_type>()] };
    };
 
    template <typename T>
    concept string_like = requires(T s) {
-      {
-         s.size()
-      } -> std::integral;
-      {
-         s.data()
-      };
-      {
-         s.empty()
-      } -> std::convertible_to<bool>;
-      {
-         s.substr(0, 1)
-      };
+      { s.size() } -> std::integral;
+      { s.data() };
+      { s.empty() } -> std::convertible_to<bool>;
+      { s.substr(0, 1) };
    };
 
    template <typename T>
@@ -171,9 +178,7 @@ namespace glz::detail
       bitset.flip();
       bitset.set(0);
       requires string_like<decltype(bitset.to_string())>;
-      {
-         bitset.count()
-      } -> std::same_as<size_t>;
+      { bitset.count() } -> std::same_as<size_t>;
    };
 
    template <class T>
@@ -195,12 +200,8 @@ namespace glz::detail
       path.filename();
       path.extension();
       path.parent_path();
-      {
-         path.has_filename()
-      } -> std::convertible_to<bool>;
-      {
-         path.has_extension()
-      } -> std::convertible_to<bool>;
+      { path.has_filename() } -> std::convertible_to<bool>;
+      { path.has_extension() } -> std::convertible_to<bool>;
    };
 }
 
@@ -213,6 +214,25 @@ namespace glz
       requires std::input_iterator<decltype(t.begin())>;
    };
 
+   // Concept for a matrix type (not a vector, which is a range)
+   template <class T>
+   concept matrix_t = requires(T matrix) {
+      matrix.resize(2, 4);
+      matrix.data();
+      { matrix.rows() } -> std::convertible_to<int>;
+      { matrix.cols() } -> std::convertible_to<int>;
+      { matrix.size() } -> std::convertible_to<int>;
+   } && !range<T>;
+
+   // concept for the Eigen library: matrices and vectors
+   template <class T>
+   concept eigen_t = requires(T matrix) {
+      matrix.data();
+      { matrix.rows() } -> std::convertible_to<int>;
+      { matrix.cols() } -> std::convertible_to<int>;
+      { matrix.size() } -> std::convertible_to<int>;
+   };
+
    // range like
    template <class T>
    using iterator_t = decltype(std::begin(std::declval<T&>()));
@@ -228,16 +248,12 @@ namespace glz
 #else
       // in lieu of std::ranges::empty
       if constexpr (requires() {
-                       {
-                          rng.empty()
-                       } -> std::convertible_to<bool>;
+                       { rng.empty() } -> std::convertible_to<bool>;
                     }) {
          return rng.empty();
       }
       else if constexpr (requires() {
-                            {
-                               rng.size()
-                            } -> std::same_as<std::size_t>;
+                            { rng.size() } -> std::same_as<std::size_t>;
                          }) {
          return rng.size() == std::size_t{0};
       }
@@ -255,4 +271,54 @@ namespace glz
 
    template <class Buffer>
    concept output_buffer = range<Buffer> && (sizeof(range_value_t<Buffer>) == sizeof(char)) && non_const_buffer<Buffer>;
+
+   template <class T>
+   constexpr bool const_value_v = std::is_const_v<std::remove_pointer_t<std::remove_reference_t<T>>>;
+}
+
+namespace glz::detail
+{
+   template <class Container>
+   using iterator_pair_type =
+      typename std::iterator_traits<decltype(std::begin(std::declval<Container&>()))>::value_type;
+
+   template <class Container, typename Iterator = iterator_pair_type<Container>>
+   struct iterator_second_impl;
+
+   template <class Container, typename Iterator>
+      requires has_value_type<Iterator>
+   struct iterator_second_impl<Container, Iterator>
+   {
+      using type = typename Iterator::value_type;
+   };
+
+   template <class Container, typename Iterator>
+      requires(!has_value_type<Iterator> && has_second_type<Iterator>)
+   struct iterator_second_impl<Container, Iterator>
+   {
+      using type = typename Iterator::second_type;
+   };
+
+   template <class Container>
+   using iterator_second_type = typename iterator_second_impl<Container>::type;
+
+   template <class Container, typename Iterator = iterator_pair_type<Container>>
+   struct iterator_first_impl;
+
+   template <class Container, typename Iterator>
+      requires has_value_type<Iterator>
+   struct iterator_first_impl<Container, Iterator>
+   {
+      using type = typename Iterator::value_type;
+   };
+
+   template <class Container, typename Iterator>
+      requires(!has_value_type<Iterator> && has_first_type<Iterator>)
+   struct iterator_first_impl<Container, Iterator>
+   {
+      using type = typename Iterator::first_type;
+   };
+
+   template <class Container>
+   using iterator_first_type = typename iterator_first_impl<Container>::type;
 }
diff --git a/deps/saucer/include/glaze/containers/flat_map.hpp b/deps/saucer/include/glaze/containers/flat_map.hpp
new file mode 100644
index 0000000..03a97af
--- /dev/null
+++ b/deps/saucer/include/glaze/containers/flat_map.hpp
@@ -0,0 +1,327 @@
+// Glaze Library
+// For the license information refer to glaze.hpp
+
+#pragma once
+
+#include <algorithm>
+#include <concepts>
+#include <functional>
+#include <initializer_list>
+#include <iterator>
+#include <stdexcept>
+#include <utility>
+#include <vector>
+
+#include "glaze/util/expected.hpp"
+
+#ifndef GLZ_THROW_OR_ABORT
+#if __cpp_exceptions
+#define GLZ_THROW_OR_ABORT(EXC) (throw(EXC))
+#define GLZ_NOEXCEPT noexcept(false)
+#else
+#define GLZ_THROW_OR_ABORT(EXC) (std::abort())
+#define GLZ_NOEXCEPT noexcept(true)
+#endif
+#endif
+
+// A flat_map. This version uses a single container for key/value pairs for the sake of cache locality. The
+// std::flat_map uses separate key/value arrays.
+
+namespace glz
+{
+   template <typename K1, typename K2>
+   concept KeyEqualComparable = requires(const K1& k1, const K2& k2) {
+      { k1 == k2 } -> std::convertible_to<bool>;
+      { k2 == k1 } -> std::convertible_to<bool>;
+   };
+
+   template <class Key, class T, class Compare = std::less<>, class Container = std::vector<std::pair<Key, T>>>
+   struct flat_map
+   {
+      // Member types
+      using key_type = Key;
+      using mapped_type = T;
+      using value_type = std::pair<Key, T>;
+      using key_compare = Compare;
+      using size_type = typename Container::size_type;
+      using difference_type = typename Container::difference_type;
+      using reference = value_type&;
+      using const_reference = const value_type&;
+      using iterator = typename Container::iterator;
+      using const_iterator = typename Container::const_iterator;
+      using reverse_iterator = typename Container::reverse_iterator;
+      using const_reverse_iterator = typename Container::const_reverse_iterator;
+
+     private:
+      Container data_;
+      key_compare comp_;
+
+      template <typename Comp>
+      static constexpr bool IsDefaultComparator = std::same_as<Comp, std::less<>> || std::same_as<Comp, std::less<Key>>;
+
+     public:
+      // Constructors
+      flat_map() : data_(), comp_() {}
+
+      explicit flat_map(const Compare& comp) : data_(), comp_(comp) {}
+
+      template <class InputIt>
+      flat_map(InputIt first, InputIt last, const Compare& comp = Compare()) : data_(), comp_(comp)
+      {
+         insert(first, last);
+      }
+
+      flat_map(std::initializer_list<value_type> init, const Compare& comp = Compare()) : data_(), comp_(comp)
+      {
+         insert(init.begin(), init.end());
+      }
+
+      // Copy and Move Constructors
+      flat_map(const flat_map& other) = default;
+      flat_map(flat_map&& other) noexcept = default;
+
+      // Assignment Operators
+      flat_map& operator=(const flat_map& other) = default;
+      flat_map& operator=(flat_map&& other) noexcept = default;
+
+      // Iterators
+      iterator begin() noexcept { return data_.begin(); }
+      const_iterator begin() const noexcept { return data_.begin(); }
+      const_iterator cbegin() const noexcept { return data_.cbegin(); }
+
+      iterator end() noexcept { return data_.end(); }
+      const_iterator end() const noexcept { return data_.end(); }
+      const_iterator cend() const noexcept { return data_.cend(); }
+
+      // Capacity
+      [[nodiscard]] bool empty() const noexcept { return data_.empty(); }
+      size_type size() const noexcept { return data_.size(); }
+      void reserve(size_type new_cap) { data_.reserve(new_cap); }
+      size_type capacity() const noexcept { return data_.capacity(); }
+      void shrink_to_fit() { data_.shrink_to_fit(); }
+
+      // Modifiers
+      void clear() noexcept { data_.clear(); }
+
+      std::pair<iterator, bool> insert(const value_type& value)
+      {
+         auto it = lower_bound(value.first);
+         if (it != data_.end()) {
+            if constexpr (IsDefaultComparator<Compare> &&
+                          KeyEqualComparable<decltype(value.first), decltype(it->first)>) {
+               if (value.first == it->first) {
+                  return {it, false};
+               }
+            }
+            else {
+               if (!comp_(value.first, it->first) && !comp_(it->first, value.first)) {
+                  return {it, false};
+               }
+            }
+         }
+         return {data_.insert(it, value), true};
+      }
+
+      std::pair<iterator, bool> insert(value_type&& value)
+      {
+         auto it = lower_bound(value.first);
+         if (it != data_.end()) {
+            if constexpr (IsDefaultComparator<Compare> &&
+                          KeyEqualComparable<decltype(value.first), decltype(it->first)>) {
+               if (value.first == it->first) {
+                  return {it, false};
+               }
+            }
+            else {
+               if (!comp_(value.first, it->first) && !comp_(it->first, value.first)) {
+                  return {it, false};
+               }
+            }
+         }
+         return {data_.emplace(it, std::move(value)), true};
+      }
+
+      template <class InputIt>
+      void insert(InputIt first, InputIt last)
+      {
+         if (first == last) return;
+         data_.reserve(data_.size() + std::distance(first, last));
+         for (; first != last; ++first) {
+            insert(*first);
+         }
+      }
+
+      void insert(std::initializer_list<value_type> ilist) { insert(ilist.begin(), ilist.end()); }
+
+      template <class... Args>
+      std::pair<iterator, bool> emplace(Args&&... args)
+      {
+         value_type value(std::forward<Args>(args)...);
+         return insert(std::move(value));
+      }
+
+      iterator erase(const_iterator pos) { return data_.erase(pos); }
+
+      iterator erase(const_iterator first, const_iterator last) { return data_.erase(first, last); }
+
+      template <typename K>
+      size_type erase(const K& key)
+      {
+         auto it = find(key);
+         if (it != end()) {
+            data_.erase(it);
+            return 1;
+         }
+         return 0;
+      }
+
+      void swap(flat_map& other) noexcept(
+         std::allocator_traits<typename Container::allocator_type>::is_always_equal::value &&
+         std::is_nothrow_swappable_v<Compare>)
+      {
+         data_.swap(other.data_);
+         std::swap(comp_, other.comp_);
+      }
+
+      // Lookup
+      template <typename K>
+      size_type count(const K& key) const
+      {
+         return find(key) != end() ? 1 : 0;
+      }
+
+      template <typename K>
+      iterator find(const K& key)
+      {
+         auto it = lower_bound(key);
+         if (it != data_.end()) {
+            if constexpr (IsDefaultComparator<Compare> && KeyEqualComparable<K, decltype(it->first)>) {
+               if (key == it->first) {
+                  return it;
+               }
+            }
+            else {
+               if (!comp_(key, it->first) && !comp_(it->first, key)) {
+                  return it;
+               }
+            }
+         }
+         return data_.end();
+      }
+
+      template <typename K>
+      const_iterator find(const K& key) const
+      {
+         auto it = lower_bound(key);
+         if (it != data_.end()) {
+            if constexpr (IsDefaultComparator<Compare> && KeyEqualComparable<K, decltype(it->first)>) {
+               if (key == it->first) {
+                  return it;
+               }
+            }
+            else {
+               if (!comp_(key, it->first) && !comp_(it->first, key)) {
+                  return it;
+               }
+            }
+         }
+         return data_.end();
+      }
+
+      template <typename K>
+      bool contains(const K& key) const
+      {
+         return find(key) != end();
+      }
+
+      template <typename K>
+      iterator lower_bound(const K& key)
+      {
+         return std::lower_bound(data_.begin(), data_.end(), key,
+                                 [this](const value_type& lhs, const K& rhs) { return comp_(lhs.first, rhs); });
+      }
+
+      template <typename K>
+      const_iterator lower_bound(const K& key) const
+      {
+         return std::lower_bound(data_.begin(), data_.end(), key,
+                                 [this](const value_type& lhs, const K& rhs) { return comp_(lhs.first, rhs); });
+      }
+
+      template <typename K>
+      iterator upper_bound(const K& key)
+      {
+         return std::upper_bound(data_.begin(), data_.end(), key,
+                                 [this](const K& lhs, const value_type& rhs) { return comp_(lhs, rhs.first); });
+      }
+
+      template <typename K>
+      const_iterator upper_bound(const K& key) const
+      {
+         return std::upper_bound(data_.begin(), data_.end(), key,
+                                 [this](const K& lhs, const value_type& rhs) { return comp_(lhs, rhs.first); });
+      }
+
+      // Element Access
+      mapped_type& operator[](const key_type& key)
+      {
+         auto it = lower_bound(key);
+         if (it == data_.end() || comp_(key, it->first)) {
+            it = data_.emplace(it, key, mapped_type());
+         }
+         return it->second;
+      }
+
+      mapped_type& operator[](key_type&& key)
+      {
+         auto it = lower_bound(key);
+         if (it == data_.end() || comp_(key, it->first)) {
+            it = data_.emplace(it, std::move(key), mapped_type());
+         }
+         return it->second;
+      }
+
+      template <typename K>
+      mapped_type& at(const K& key)
+      {
+         auto it = find(key);
+         if (it == data_.end()) {
+            GLZ_THROW_OR_ABORT(std::out_of_range("flat_map::at: key not found"));
+         }
+         return it->second;
+      }
+
+      template <typename K>
+      const mapped_type& at(const K& key) const
+      {
+         auto it = find(key);
+         if (it == data_.end()) {
+            GLZ_THROW_OR_ABORT(std::out_of_range("flat_map::at: key not found"));
+         }
+         return it->second;
+      }
+
+      // Observers
+      key_compare key_comp() const { return comp_; }
+   };
+
+   // Non-member functions
+   template <class Key, class T, class Compare, class Container>
+   bool operator==(const flat_map<Key, T, Compare, Container>& lhs, const flat_map<Key, T, Compare, Container>& rhs)
+   {
+      return lhs.data_ == rhs.data_;
+   }
+
+   template <class Key, class T, class Compare, class Container>
+   bool operator!=(const flat_map<Key, T, Compare, Container>& lhs, const flat_map<Key, T, Compare, Container>& rhs)
+   {
+      return !(lhs == rhs);
+   }
+
+   template <class Key, class T, class Compare, class Container>
+   void swap(flat_map<Key, T, Compare, Container>& lhs,
+             flat_map<Key, T, Compare, Container>& rhs) noexcept(noexcept(lhs.swap(rhs)))
+   {
+      lhs.swap(rhs);
+   }
+}
diff --git a/deps/saucer/include/glaze/containers/inplace_vector.hpp b/deps/saucer/include/glaze/containers/inplace_vector.hpp
new file mode 100644
index 0000000..aa6f97b
--- /dev/null
+++ b/deps/saucer/include/glaze/containers/inplace_vector.hpp
@@ -0,0 +1,1111 @@
+// Glaze Library
+// For the license information refer to glaze.hpp
+
+#pragma once
+
+#include <algorithm>
+#include <compare>
+#include <cstddef>
+#include <cstring>
+#include <initializer_list>
+#include <iterator>
+#include <memory>
+#include <new>
+#include <ranges>
+#include <stdexcept>
+#include <type_traits>
+#include <utility>
+
+#ifndef GLZ_THROW_OR_ABORT
+#if __cpp_exceptions
+#define GLZ_THROW_OR_ABORT(EXC) (throw(EXC))
+#define GLZ_NOEXCEPT noexcept(false)
+#else
+#include <cstdlib> // for std::abort
+#define GLZ_THROW_OR_ABORT(EXC) (std::abort())
+#define GLZ_NOEXCEPT noexcept(true)
+#endif
+#endif
+
+namespace glz
+{
+   namespace detail::inplace_vector
+   {
+      template <class T, size_t N>
+      struct byte_storage
+      {
+         alignas(T) unsigned char storage[sizeof(T) * N];
+         size_t size_ = 0;
+         constexpr T* data_ptr() noexcept { return std::launder(reinterpret_cast<T*>(storage)); }
+         constexpr const T* data_ptr() const noexcept { return std::launder(reinterpret_cast<const T*>(storage)); }
+         constexpr size_t storage_size() const noexcept { return size_; }
+         constexpr void set_storage_size(size_t new_size) noexcept { size_ = new_size; }
+      };
+
+      template <class T>
+      struct zero_storage
+      {
+         constexpr T* data_ptr() noexcept { return nullptr; }
+         constexpr const T* data_ptr() const noexcept { return nullptr; }
+         constexpr size_t storage_size() const noexcept { return 0; }
+         constexpr void set_storage_size(size_t) noexcept {};
+      };
+
+      template <class T, size_t N>
+      using storage_type = std::conditional_t<N == 0, zero_storage<T>, byte_storage<T, N>>;
+
+      template <class T, size_t N>
+      class inplace_vector_base : protected storage_type<T, N>
+      {
+        protected:
+         using storage_t = storage_type<T, N>;
+
+         using storage_t::data_ptr;
+         using storage_t::set_storage_size;
+         using storage_t::storage_size;
+
+        public:
+         using value_type = T;
+         using pointer = T*;
+         using const_pointer = const T*;
+         using reference = value_type&;
+         using const_reference = const value_type&;
+         using size_type = size_t;
+         using difference_type = std::ptrdiff_t;
+         using iterator = T*;
+         using const_iterator = const T*;
+         using reverse_iterator = std::reverse_iterator<iterator>;
+         using const_reverse_iterator = std::reverse_iterator<const_iterator>;
+
+        protected:
+         // Helper to destroy a range of elements
+         constexpr void destroy_range(size_type start, size_type end) noexcept
+         {
+            if constexpr (!std::is_trivially_destructible_v<T>) {
+               for (size_type i = start; i < end; ++i) {
+                  std::destroy_at(this->data_ptr() + i);
+               }
+            }
+         }
+
+        public:
+         // Constructors
+
+         constexpr inplace_vector_base() noexcept = default;
+
+         // Trivially copyable copy constructor
+         constexpr inplace_vector_base(const inplace_vector_base& other)
+            requires std::is_trivially_copyable_v<T>
+         = default;
+
+         // Non-trivially copyable copy constructor
+         constexpr inplace_vector_base(const inplace_vector_base& other)
+            requires(!std::is_trivially_copyable_v<T>)
+         {
+            assign(other.begin(), other.end());
+         }
+
+         // Trivially copyable move constructor
+         constexpr inplace_vector_base(inplace_vector_base&& other) noexcept(N == 0 ||
+                                                                             std::is_nothrow_move_constructible_v<T>)
+            requires std::is_trivially_copyable_v<T>
+         = default;
+
+         // Non-trivially copyable move constructor
+         constexpr inplace_vector_base(inplace_vector_base&& other) noexcept(N == 0 ||
+                                                                             std::is_nothrow_move_constructible_v<T>)
+            requires(!std::is_trivially_copyable_v<T>)
+         {
+            assign(std::make_move_iterator(other.begin()), std::make_move_iterator(other.end()));
+            other.clear();
+         }
+
+         // Trivially destructible destructor
+         constexpr ~inplace_vector_base()
+            requires std::is_trivially_destructible_v<T>
+         = default;
+
+         // Non-trivially destructible destructor
+         constexpr ~inplace_vector_base()
+            requires(!std::is_trivially_destructible_v<T>)
+         {
+            destroy_range(0, storage_size());
+         }
+
+         // Trivially copyable copy assignment
+         constexpr inplace_vector_base& operator=(const inplace_vector_base& other)
+            requires std::is_trivially_copyable_v<T>
+         = default;
+
+         // Non-trivially copyable copy assignment
+         constexpr inplace_vector_base& operator=(const inplace_vector_base& other)
+            requires(!std::is_trivially_copyable_v<T>)
+         {
+            if (this != &other) {
+               assign(other.begin(), other.end());
+            }
+            return *this;
+         }
+
+         // Trivially copyable move assignment
+         constexpr inplace_vector_base& operator=(inplace_vector_base&& other) noexcept(
+            N == 0 || (std::is_nothrow_move_assignable_v<T> && std::is_nothrow_move_constructible_v<T>))
+            requires std::is_trivially_copyable_v<T>
+         = default;
+
+         // Non-trivially copyable move assignment
+         constexpr inplace_vector_base& operator=(inplace_vector_base&& other) noexcept(
+            N == 0 || (std::is_nothrow_move_assignable_v<T> && std::is_nothrow_move_constructible_v<T>))
+            requires(!std::is_trivially_copyable_v<T>)
+         {
+            if (this != &other) {
+               clear();
+               assign(std::make_move_iterator(other.begin()), std::make_move_iterator(other.end()));
+               other.clear();
+            }
+            return *this;
+         }
+
+         // Iterators
+         constexpr iterator begin() noexcept { return this->data_ptr(); }
+
+         constexpr const_iterator begin() const noexcept { return this->data_ptr(); }
+
+         constexpr iterator end() noexcept { return this->data_ptr() + storage_size(); }
+
+         constexpr const_iterator end() const noexcept { return this->data_ptr() + storage_size(); }
+
+         constexpr reverse_iterator rbegin() noexcept { return reverse_iterator(end()); }
+
+         constexpr const_reverse_iterator rbegin() const noexcept { return const_reverse_iterator(end()); }
+
+         constexpr reverse_iterator rend() noexcept { return reverse_iterator(begin()); }
+
+         constexpr const_reverse_iterator rend() const noexcept { return const_reverse_iterator(begin()); }
+
+         constexpr const_iterator cbegin() const noexcept { return begin(); }
+
+         constexpr const_iterator cend() const noexcept { return end(); }
+
+         constexpr const_reverse_iterator crbegin() const noexcept { return rbegin(); }
+
+         constexpr const_reverse_iterator crend() const noexcept { return rend(); }
+
+         // Capacity
+         constexpr bool empty() const noexcept { return storage_size() == 0; }
+
+         constexpr size_type size() const noexcept { return storage_size(); }
+
+         static constexpr size_type max_size() noexcept { return N; }
+
+         static constexpr size_type capacity() noexcept { return N; }
+
+         static constexpr void shrink_to_fit() noexcept
+         {
+            // No-op for inplace_vector since capacity is fixed
+         }
+
+         // Element access
+         constexpr reference operator[](size_type n) { return this->data_ptr()[n]; }
+
+         constexpr const_reference operator[](size_type n) const { return this->data_ptr()[n]; }
+
+         constexpr reference front() { return this->data_ptr()[0]; }
+
+         constexpr const_reference front() const { return this->data_ptr()[0]; }
+
+         constexpr reference back() { return this->data_ptr()[storage_size() - 1]; }
+
+         constexpr const_reference back() const { return this->data_ptr()[storage_size() - 1]; }
+
+         constexpr T* data() noexcept { return this->data_ptr(); }
+
+         constexpr const T* data() const noexcept { return this->data_ptr(); }
+
+         // Standard modifiers
+         constexpr void pop_back()
+         {
+            std::destroy_at(&back());
+            set_storage_size(storage_size() - 1);
+         }
+
+         // Fallible APIs
+         template <class... Args>
+         constexpr T* try_emplace_back(Args&&... args)
+            requires(std::constructible_from<T, Args...>)
+         {
+            if (storage_size() >= N) return nullptr;
+
+            std::construct_at(this->data_ptr() + storage_size(), std::forward<Args>(args)...);
+            set_storage_size(storage_size() + 1);
+            return &back();
+         }
+
+         constexpr T* try_push_back(const T& x)
+         {
+            if (storage_size() >= N) return nullptr;
+
+            if constexpr (std::is_trivially_copyable_v<T>) {
+               std::memcpy(this->data_ptr() + storage_size(), &x, sizeof(T));
+            }
+            else {
+               std::construct_at(this->data_ptr() + storage_size(), x);
+            }
+            set_storage_size(storage_size() + 1);
+            return &back();
+         }
+
+         constexpr T* try_push_back(T&& x)
+         {
+            if (storage_size() >= N) return nullptr;
+
+            std::construct_at(this->data_ptr() + storage_size(), std::move(x));
+            set_storage_size(storage_size() + 1);
+            return &back();
+         }
+
+         template <std::ranges::input_range R>
+            requires std::convertible_to<std::ranges::range_reference_t<R>, T>
+         constexpr auto try_append_range(R&& rg) -> std::ranges::borrowed_iterator_t<R>
+         {
+            auto it = std::ranges::begin(rg);
+            const auto end = std::ranges::end(rg);
+            for (; storage_size() != N && it != end; ++it) {
+               try_emplace_back(*it);
+            }
+            return it;
+         }
+
+         // Unchecked APIs
+         template <class... Args>
+         constexpr reference unchecked_emplace_back(Args&&... args)
+         {
+            return *try_emplace_back(std::forward<Args>(args)...);
+         }
+
+         constexpr reference unchecked_push_back(const T& x) { return *try_push_back(x); }
+
+         constexpr reference unchecked_push_back(T&& x) { return *try_push_back(std::move(x)); }
+
+         // Erase operations
+         constexpr iterator erase(const_iterator position)
+         {
+            size_type pos_idx = position - cbegin();
+
+            // Destroy element at position
+            std::destroy_at(this->data_ptr() + pos_idx);
+
+            if constexpr (std::is_trivially_copyable_v<T> && std::is_trivially_destructible_v<T>) {
+               if (pos_idx < storage_size() - 1) {
+                  std::memmove(this->data_ptr() + pos_idx, this->data_ptr() + pos_idx + 1,
+                               (storage_size() - pos_idx - 1) * sizeof(T));
+               }
+            }
+            else {
+               // Move elements after position one position to the left
+               for (size_type i = pos_idx; i < storage_size() - 1; ++i)
+                  this->data_ptr()[i] = std::move(this->data_ptr()[i + 1]);
+
+               // Destroy the last element that was moved from
+               std::destroy_at(this->data_ptr() + storage_size() - 1);
+            }
+
+            set_storage_size(storage_size() - 1);
+
+            return begin() + pos_idx;
+         }
+
+         constexpr iterator erase(const_iterator first, const_iterator last)
+         {
+            size_type first_idx = first - cbegin();
+            size_type last_idx = last - cbegin();
+            size_type count = last_idx - first_idx;
+
+            if (count == 0) return begin() + first_idx;
+
+            // Destroy elements in range [first, last)
+            for (size_type i = first_idx; i < last_idx; ++i) std::destroy_at(this->data_ptr() + i);
+
+            if constexpr (std::is_trivially_copyable_v<T> && std::is_trivially_destructible_v<T>) {
+               if (last_idx < storage_size()) {
+                  std::memmove(this->data_ptr() + first_idx, this->data_ptr() + last_idx,
+                               (storage_size() - last_idx) * sizeof(T));
+               }
+            }
+            else {
+               // Move elements after last count positions to the left
+               for (size_type i = first_idx; i < storage_size() - count; ++i)
+                  this->data_ptr()[i] = std::move(this->data_ptr()[i + count]);
+
+               // Destroy the last elements that were moved from
+               for (size_type i = storage_size() - count; i < storage_size(); ++i)
+                  std::destroy_at(this->data_ptr() + i);
+            }
+
+            set_storage_size(storage_size() - count);
+
+            return begin() + first_idx;
+         }
+
+         constexpr void clear() noexcept
+         {
+            destroy_range(0, storage_size());
+            set_storage_size(0);
+         }
+
+         constexpr void swap(inplace_vector_base& x) noexcept(N == 0 || (std::is_nothrow_swappable_v<T> &&
+                                                                         std::is_nothrow_move_constructible_v<T>))
+         {
+            if (this == &x) return;
+
+            if constexpr (std::is_trivially_copyable_v<T>) {
+               // For trivially copyable types, we can use a temporary buffer
+               alignas(T) unsigned char temp[sizeof(T) * N];
+               std::memcpy(temp, data_ptr(), storage_size() * sizeof(T));
+               std::memcpy(data_ptr(), x.data_ptr(), x.storage_size() * sizeof(T));
+               std::memcpy(x.data_ptr(), temp, storage_size() * sizeof(T));
+               size_type temp_size = storage_size();
+               set_storage_size(x.storage_size());
+               x.set_storage_size(temp_size);
+            }
+            else {
+               const auto min_size = std::min(storage_size(), x.storage_size());
+
+               // Swap common elements
+               for (size_type i = 0; i < min_size; ++i) std::swap(this->data_ptr()[i], x.data_ptr()[i]);
+
+               // Handle the case where sizes are different
+               if (storage_size() > x.storage_size()) {
+                  // Move our excess elements to x
+                  for (size_type i = min_size; i < storage_size(); ++i)
+                     std::construct_at(x.data_ptr() + i, std::move(this->data_ptr()[i]));
+
+                  // Destroy our excess elements
+                  for (size_type i = min_size; i < storage_size(); ++i) std::destroy_at(this->data_ptr() + i);
+               }
+               else if (storage_size() < x.storage_size()) {
+                  // Move x's excess elements to us
+                  for (size_type i = min_size; i < x.storage_size(); ++i)
+                     std::construct_at(this->data_ptr() + i, std::move(x.data_ptr()[i]));
+
+                  // Destroy x's excess elements
+                  for (size_type i = min_size; i < x.storage_size(); ++i) std::destroy_at(x.data_ptr() + i);
+               }
+
+               // Swap sizes
+               std::swap(storage_size(), x.storage_size());
+            }
+         }
+
+         // Comparison operators
+         friend constexpr bool operator==(const inplace_vector_base& lhs, const inplace_vector_base& rhs)
+         {
+            if constexpr (N == 0) {
+               return true; // Both are inplace_vector<T, 0>, always empty and thus equal.
+            }
+            else {
+               if (lhs.storage_size() != rhs.storage_size()) return false;
+
+               if constexpr (std::is_trivially_copyable_v<T>) {
+                  return std::memcmp(lhs.data_ptr(), rhs.data_ptr(), lhs.storage_size() * sizeof(T)) == 0;
+               }
+               else {
+                  return std::equal(lhs.begin(), lhs.end(), rhs.begin());
+               }
+            }
+         }
+
+         friend constexpr auto operator<=>(const inplace_vector_base& lhs, const inplace_vector_base& rhs)
+         {
+            return std::lexicographical_compare_three_way(lhs.begin(), lhs.end(), rhs.begin(), rhs.end(),
+                                                          std::compare_three_way{});
+         }
+      };
+
+   }
+
+   // Non-member functions
+   template <class T, size_t N>
+   constexpr void swap(detail::inplace_vector::inplace_vector_base<T, N>& x,
+                       detail::inplace_vector::inplace_vector_base<T, N>& y) noexcept(noexcept(x.swap(y)))
+   {
+      x.swap(y);
+   }
+
+   template <class T, size_t N, class U>
+   constexpr typename detail::inplace_vector::inplace_vector_base<T, N>::size_type erase(
+      detail::inplace_vector::inplace_vector_base<T, N>& c, const U& value)
+   {
+      auto it = std::remove(c.begin(), c.end(), value);
+      auto r = c.end() - it;
+      c.erase(it, c.end());
+      return r;
+   }
+
+   template <class T, size_t N, class Predicate>
+   constexpr typename detail::inplace_vector::inplace_vector_base<T, N>::size_type erase_if(
+      detail::inplace_vector::inplace_vector_base<T, N>& c, Predicate pred)
+   {
+      auto it = std::remove_if(c.begin(), c.end(), pred);
+      auto r = c.end() - it;
+      c.erase(it, c.end());
+      return r;
+   }
+
+   template <class T, size_t N>
+   class inplace_vector : public detail::inplace_vector::inplace_vector_base<T, N>
+   {
+     public:
+      // types
+      using value_type = T;
+      using pointer = T*;
+      using const_pointer = const T*;
+      using reference = value_type&;
+      using const_reference = const value_type&;
+      using size_type = size_t;
+      using difference_type = std::ptrdiff_t;
+      using iterator = T*;
+      using const_iterator = const T*;
+      using reverse_iterator = std::reverse_iterator<iterator>;
+      using const_reverse_iterator = std::reverse_iterator<const_iterator>;
+
+     public:
+      // Constructors
+      constexpr inplace_vector() noexcept = default;
+
+      constexpr explicit inplace_vector(size_type n) // freestanding-deleted
+      {
+         if (n > N) GLZ_THROW_OR_ABORT(std::bad_alloc());
+
+         // Use std::uninitialized_value_construct_n for proper value-initialization
+         std::uninitialized_value_construct_n(this->data_ptr(), n);
+         this->set_storage_size(n);
+      }
+
+      constexpr inplace_vector(size_type n, const T& value) // freestanding-deleted
+      {
+         if (n > N) GLZ_THROW_OR_ABORT(std::bad_alloc());
+
+         if constexpr (std::is_trivially_copyable_v<T>) {
+            // Construct first element then copy it
+            if (n > 0) {
+               std::construct_at(this->data_ptr(), value);
+               for (size_type i = 1; i < n; ++i) {
+                  std::memcpy(this->data_ptr() + i, this->data_ptr(), sizeof(T));
+               }
+            }
+         }
+         else {
+            for (size_type i = 0; i < n; ++i) std::construct_at(this->data_ptr() + i, value);
+         }
+
+         this->set_storage_size(n);
+      }
+
+      template <class InputIterator>
+      constexpr inplace_vector(InputIterator first, InputIterator last) // freestanding-deleted
+      {
+         assign(first, last);
+      }
+
+#ifdef __cpp_lib_containers_ranges
+      template <std::ranges::input_range R>
+         requires std::convertible_to<std::ranges::range_reference_t<R>, T>
+      constexpr inplace_vector(std::from_range_t, R&& rg) // freestanding-deleted
+      {
+         assign_range(std::forward<R>(rg));
+      }
+#endif
+
+      constexpr inplace_vector(std::initializer_list<T> il) // freestanding-deleted
+      {
+         assign(il.begin(), il.end());
+      }
+      constexpr inplace_vector& operator=(std::initializer_list<T> il) // freestanding-deleted
+      {
+         assign(il.begin(), il.end());
+         return *this;
+      }
+
+      // Assign methods
+      template <std::input_iterator InputIterator>
+      constexpr void assign(InputIterator first, InputIterator last) // freestanding-deleted
+      {
+         this->clear();
+
+         // Calculate distance if possible (for random access iterators)
+         if constexpr (std::random_access_iterator<InputIterator>) {
+            if (std::distance(first, last) > static_cast<difference_type>(N)) GLZ_THROW_OR_ABORT(std::bad_alloc());
+         }
+
+         if constexpr (std::is_trivially_copyable_v<T> && std::contiguous_iterator<InputIterator>) {
+            // Fast path for contiguous trivially copyable types
+            auto count = std::distance(first, last);
+            if (count > 0) {
+               std::memcpy(this->storage, std::to_address(first), count * sizeof(T));
+               this->set_storage_size(static_cast<size_type>(count));
+            }
+         }
+         else {
+            // General path
+            while (first != last) {
+               if (this->storage_size() >= N) GLZ_THROW_OR_ABORT(std::bad_alloc());
+
+               std::construct_at(this->data_ptr() + this->storage_size(), *first);
+               this->set_storage_size(this->storage_size() + 1);
+               ++first;
+            }
+         }
+      }
+
+      template <std::ranges::input_range R>
+         requires std::convertible_to<std::ranges::range_reference_t<R>, T>
+      constexpr void assign_range(R&& rg) // freestanding-deleted
+      {
+         this->clear();
+
+         // Check size if possible
+         if constexpr (std::ranges::sized_range<R>) {
+            if (std::ranges::size(rg) > N) GLZ_THROW_OR_ABORT(std::bad_alloc());
+         }
+
+         // Fast path for contiguous ranges of trivially copyable types
+         if constexpr (std::is_trivially_copyable_v<T> && std::ranges::contiguous_range<R> &&
+                       std::same_as<std::remove_cvref_t<std::ranges::range_reference_t<R>>, T>) {
+            auto count = std::ranges::size(rg);
+            if (count > 0) {
+               std::memcpy(this->storage, std::ranges::data(rg), count * sizeof(T));
+               this->set_storage_size(static_cast<size_type>(count));
+            }
+         }
+         else {
+            // General path
+            for (auto&& item : rg) {
+               if (this->storage_size() >= N) GLZ_THROW_OR_ABORT(std::bad_alloc());
+
+               std::construct_at(this->data_ptr() + this->storage_size(), std::forward<decltype(item)>(item));
+               this->set_storage_size(this->storage_size() + 1);
+            }
+         }
+      }
+
+      constexpr void assign(size_type n, const T& value) // freestanding-deleted
+      {
+         if (n > N) GLZ_THROW_OR_ABORT(std::bad_alloc());
+
+         this->clear();
+
+         if constexpr (std::is_trivially_copyable_v<T>) {
+            if (n > 0) {
+               // Construct first element, then use memcpy for the rest
+               std::construct_at(this->data_ptr(), value);
+               for (size_type i = 1; i < n; ++i) {
+                  std::memcpy(this->data_ptr() + i, this->data_ptr(), sizeof(T));
+               }
+               this->set_storage_size(n);
+            }
+         }
+         else {
+            for (size_type i = 0; i < n; ++i) {
+               std::construct_at(this->data_ptr() + this->storage_size(), value);
+               this->set_storage_size(this->storage_size() + 1);
+            }
+         }
+      }
+
+      // TODO add assign(initializer_list<T>)
+
+      // Capacity
+
+      constexpr void resize(size_type sz) // freestanding-deleted
+      {
+         if (sz > N) GLZ_THROW_OR_ABORT(std::bad_alloc());
+
+         if (sz > this->storage_size()) {
+            // Value-initialize the new elements
+            std::uninitialized_value_construct_n(this->data_ptr() + this->storage_size(), sz - this->storage_size());
+            this->set_storage_size(sz);
+         }
+         else if (sz < this->storage_size()) {
+            // Destroy excess elements
+            this->destroy_range(sz, this->storage_size());
+            this->set_storage_size(sz);
+         }
+      }
+
+      constexpr void resize(size_type sz, const T& c) // freestanding-deleted
+      {
+         if (sz > N) GLZ_THROW_OR_ABORT(std::bad_alloc());
+
+         if (sz > this->storage_size()) {
+            if constexpr (std::is_trivially_copyable_v<T>) {
+               // For trivially copyable types, construct one and copy the rest
+               if (this->storage_size() < sz) {
+                  if (this->storage_size() == 0 && sz > 0) {
+                     std::construct_at(this->data_ptr(), c);
+                     for (size_type i = 1; i < sz; ++i) {
+                        std::memcpy(this->data_ptr() + i, this->data_ptr(), sizeof(T));
+                     }
+                  }
+                  else {
+                     for (size_type i = this->storage_size(); i < sz; ++i) {
+                        std::memcpy(this->data_ptr() + i, &c, sizeof(T));
+                     }
+                  }
+               }
+            }
+            else {
+               // Expand and copy-construct new elements
+               for (size_type i = this->storage_size(); i < sz; ++i) std::construct_at(this->data_ptr() + i, c);
+            }
+            this->set_storage_size(sz);
+         }
+         else if (sz < this->storage_size()) {
+            // Destroy excess elements
+            this->destroy_range(sz, this->storage_size());
+            this->set_storage_size(sz);
+         }
+      }
+
+      static constexpr void reserve(size_type n) // freestanding-deleted
+      {
+         if (n > N) GLZ_THROW_OR_ABORT(std::bad_alloc());
+         // No-op otherwise since capacity is fixed
+      }
+
+      // Element access
+
+      constexpr reference at(size_type n) // freestanding-deleted
+      {
+         if (n >= this->storage_size()) GLZ_THROW_OR_ABORT(std::out_of_range("inplace_vector::at: index out of range"));
+         return this->data_ptr()[n];
+      }
+
+      constexpr const_reference at(size_type n) const // freestanding-deleted
+      {
+         if (n >= this->storage_size()) GLZ_THROW_OR_ABORT(std::out_of_range("inplace_vector::at: index out of range"));
+         return this->data_ptr()[n];
+      }
+
+      // Standard modifiers
+      template <class... Args>
+      constexpr reference emplace_back(Args&&... args) // freestanding-deleted
+      {
+         if (this->storage_size() >= N) GLZ_THROW_OR_ABORT(std::bad_alloc());
+         return this->unchecked_emplace_back(std::forward<Args>(args)...);
+      }
+
+      constexpr reference push_back(const T& x) // freestanding-deleted
+      {
+         if (this->storage_size() >= N) GLZ_THROW_OR_ABORT(std::bad_alloc());
+         return this->unchecked_emplace_back(x);
+      }
+
+      constexpr reference push_back(T&& x) // freestanding-deleted
+      {
+         return emplace_back(std::move(x));
+      }
+
+      template <std::ranges::input_range R>
+         requires std::convertible_to<std::ranges::range_reference_t<R>, T>
+      constexpr void append_range(R&& rg) // freestanding-deleted
+      {
+         // Check size if possible
+         if constexpr (std::ranges::sized_range<R>) {
+            if (this->storage_size() + std::ranges::size(rg) > N) GLZ_THROW_OR_ABORT(std::bad_alloc());
+         }
+
+         for (auto&& item : rg) {
+            emplace_back(std::forward<decltype(item)>(item));
+         }
+      }
+
+      // Insert operations
+      template <class... Args>
+      constexpr iterator emplace(const_iterator position, Args&&... args) // freestanding-deleted
+      {
+         if (this->storage_size() >= N) GLZ_THROW_OR_ABORT(std::bad_alloc());
+
+         // Calculate position index
+         size_type pos_idx = position - this->cbegin();
+
+         if (pos_idx == this->storage_size()) {
+            // Fast path: insert at end
+            std::construct_at(this->data_ptr() + this->storage_size(), std::forward<Args>(args)...);
+            this->set_storage_size(this->storage_size() + 1);
+            return this->begin() + pos_idx;
+         }
+
+         // Move elements after position one position to the right
+         if constexpr (std::is_trivially_copyable_v<T> && std::is_trivially_destructible_v<T>) {
+            if (this->storage_size() > pos_idx) {
+               std::memmove(this->data_ptr() + pos_idx + 1, this->data_ptr() + pos_idx,
+                            (this->storage_size() - pos_idx) * sizeof(T));
+            }
+         }
+         else {
+            // Construct a new element at the end
+            std::construct_at(this->data_ptr() + this->storage_size(),
+                              std::move(this->data_ptr()[this->storage_size() - 1]));
+
+            // Move each element one position to the right, starting from the end
+            for (size_type i = this->storage_size() - 1; i > pos_idx; --i) {
+               this->data_ptr()[i] = std::move(this->data_ptr()[i - 1]);
+            }
+
+            // Destroy the element at position
+            std::destroy_at(this->data_ptr() + pos_idx);
+         }
+
+         // Construct new element
+         std::construct_at(this->data_ptr() + pos_idx, std::forward<Args>(args)...);
+         this->set_storage_size(this->storage_size() + 1);
+
+         return this->begin() + pos_idx;
+      }
+
+      constexpr iterator insert(const_iterator position, const T& x) // freestanding-deleted
+      {
+         return emplace(position, x);
+      }
+
+      constexpr iterator insert(const_iterator position, T&& x) // freestanding-deleted
+      {
+         return emplace(position, std::move(x));
+      }
+
+      constexpr iterator insert(const_iterator position, size_type n, const T& x) // freestanding-deleted
+      {
+         if (this->storage_size() + n > N) GLZ_THROW_OR_ABORT(std::bad_alloc());
+
+         if (n == 0) return this->begin() + (position - this->cbegin());
+
+         // Calculate position index
+         size_type pos_idx = position - this->cbegin();
+
+         if constexpr (std::is_trivially_copyable_v<T> && std::is_trivially_destructible_v<T>) {
+            // Move existing elements to make space
+            if (pos_idx < this->storage_size()) {
+               std::memmove(this->data_ptr() + pos_idx + n, this->data_ptr() + pos_idx,
+                            (this->storage_size() - pos_idx) * sizeof(T));
+            }
+
+            // Copy the new elements
+            for (size_type i = 0; i < n; ++i) {
+               if constexpr (std::is_trivially_copyable_v<T>) {
+                  std::memcpy(this->data_ptr() + pos_idx + i, &x, sizeof(T));
+               }
+               else {
+                  std::construct_at(this->data_ptr() + pos_idx + i, x);
+               }
+            }
+         }
+         else {
+            // General case for non-trivial types
+            // First, move elements at the end to their new positions
+            for (size_type i = 0; i < std::min(n, this->storage_size() - pos_idx); ++i) {
+               std::construct_at(this->data_ptr() + this->storage_size() + n - 1 - i,
+                                 std::move(this->data_ptr()[this->storage_size() - 1 - i]));
+            }
+
+            // Move the remaining elements that need to be shifted but not constructed
+            for (size_type i = this->storage_size() - std::min(n, this->storage_size() - pos_idx) - 1;
+                 i >= pos_idx && i < this->storage_size(); --i) {
+               this->data_ptr()[i + n] = std::move(this->data_ptr()[i]);
+            }
+
+            // Destroy elements that will be overwritten
+            for (size_type i = pos_idx; i < std::min(pos_idx + n, this->storage_size()); ++i) {
+               std::destroy_at(this->data_ptr() + i);
+            }
+
+            // Construct new elements
+            for (size_type i = 0; i < n; ++i) {
+               std::construct_at(this->data_ptr() + pos_idx + i, x);
+            }
+         }
+
+         this->set_storage_size(this->storage_size() + n);
+         return this->begin() + pos_idx;
+      }
+
+      template <class InputIterator>
+      constexpr iterator insert(const_iterator position, InputIterator first,
+                                InputIterator last) // freestanding-deleted
+      {
+         // Calculate position index
+         size_type pos_idx = position - this->cbegin();
+
+         // For random access iterators, we can check size upfront
+         if constexpr (std::random_access_iterator<InputIterator>) {
+            auto count = std::distance(first, last);
+            if (this->storage_size() + count > N) GLZ_THROW_OR_ABORT(std::bad_alloc());
+
+            if (count == 0) return this->begin() + pos_idx;
+
+            if constexpr (std::is_trivially_copyable_v<T> && std::contiguous_iterator<InputIterator> &&
+                          std::is_trivially_destructible_v<T> &&
+                          std::same_as<std::remove_cvref_t<std::iter_reference_t<InputIterator>>, T>) {
+               // Move existing elements to make space
+               if (pos_idx < this->storage_size()) {
+                  std::memmove(this->data_ptr() + pos_idx + count, this->data_ptr() + pos_idx,
+                               (this->storage_size() - pos_idx) * sizeof(T));
+               }
+
+               // Copy the new elements directly
+               std::memcpy(this->data_ptr() + pos_idx, std::to_address(first), count * sizeof(T));
+               this->set_storage_size(this->storage_size() + count);
+            }
+            else {
+               // General implementation
+               // Make space first
+               if (pos_idx < this->storage_size()) {
+                  // Move elements after position count positions to the right
+                  for (size_type i = 0; i < std::min(count, this->storage_size() - pos_idx); ++i) {
+                     std::construct_at(this->data_ptr() + this->storage_size() + count - 1 - i,
+                                       std::move(this->data_ptr()[this->storage_size() - 1 - i]));
+                  }
+
+                  // Move the remaining elements
+                  for (size_type i = this->storage_size() - std::min(count, this->storage_size() - pos_idx) - 1;
+                       i >= pos_idx && i < this->storage_size(); --i) {
+                     this->data_ptr()[i + count] = std::move(this->data_ptr()[i]);
+                  }
+
+                  // Destroy elements that will be overwritten
+                  for (size_type i = pos_idx; i < std::min(pos_idx + count, this->storage_size()); ++i) {
+                     std::destroy_at(this->data_ptr() + i);
+                  }
+               }
+
+               // Insert new elements
+               for (size_type i = 0; i < count; ++i, ++first) {
+                  std::construct_at(this->data_ptr() + pos_idx + i, *first);
+               }
+
+               this->set_storage_size(this->storage_size() + count);
+            }
+         }
+         else {
+            // For non-random access iterators, copy to temporary buffer first
+            inplace_vector<T, N> temp(first, last);
+
+            if (this->storage_size() + temp.size() > N) GLZ_THROW_OR_ABORT(std::bad_alloc());
+
+            insert(position, temp.begin(), temp.end());
+         }
+
+         return this->begin() + pos_idx;
+      }
+
+      template <std::ranges::input_range R>
+         requires std::convertible_to<std::ranges::range_reference_t<R>, T>
+      constexpr iterator insert_range(const_iterator position, R&& rg) // freestanding-deleted
+      {
+         // Calculate position index
+         size_type pos_idx = position - this->cbegin();
+
+         if constexpr (std::ranges::sized_range<R>) {
+            auto count = std::ranges::size(rg);
+            if (this->storage_size() + count > N) GLZ_THROW_OR_ABORT(std::bad_alloc());
+
+            if (count == 0) return this->begin() + pos_idx;
+
+            if constexpr (std::is_trivially_copyable_v<T> && std::ranges::contiguous_range<R> &&
+                          std::is_trivially_destructible_v<T> &&
+                          std::same_as<std::remove_cvref_t<std::ranges::range_reference_t<R>>, T>) {
+               // Move existing elements to make space
+               if (pos_idx < this->storage_size()) {
+                  std::memmove(this->data_ptr() + pos_idx + count, this->data_ptr() + pos_idx,
+                               (this->storage_size() - pos_idx) * sizeof(T));
+               }
+
+               // Copy the new elements directly
+               std::memcpy(this->data_ptr() + pos_idx, std::ranges::data(rg), count * sizeof(T));
+               this->set_storage_size(this->storage_size() + count);
+            }
+            else {
+               // General implementation
+               // Make space first
+               if (pos_idx < this->storage_size()) {
+                  // Move elements after position count positions to the right
+                  for (size_type i = 0; i < std::min(count, this->storage_size() - pos_idx); ++i) {
+                     std::construct_at(this->data_ptr() + this->storage_size() + count - 1 - i,
+                                       std::move(this->data_ptr()[this->storage_size() - 1 - i]));
+                  }
+
+                  // Move the remaining elements
+                  for (size_type i = this->storage_size() - std::min(count, this->storage_size() - pos_idx) - 1;
+                       i >= pos_idx && i < this->storage_size(); --i) {
+                     this->data_ptr()[i + count] = std::move(this->data_ptr()[i]);
+                  }
+
+                  // Destroy elements that will be overwritten
+                  for (size_type i = pos_idx; i < std::min(pos_idx + count, this->storage_size()); ++i) {
+                     std::destroy_at(this->data_ptr() + i);
+                  }
+               }
+
+               // Insert new elements
+               size_type i = 0;
+               for (auto&& item : rg) {
+                  std::construct_at(this->data_ptr() + pos_idx + i, std::forward<decltype(item)>(item));
+                  ++i;
+               }
+
+               this->set_storage_size(this->storage_size() + count);
+            }
+         }
+         else {
+            // For non-sized ranges, convert to temporary buffer first
+#ifdef __cpp_lib_containers_ranges
+            inplace_vector<T, N> temp(std::from_range, std::forward<R>(rg));
+#else
+            inplace_vector<T, N> temp;
+            for (auto&& item : rg) {
+               temp.push_back(std::forward<decltype(item)>(item));
+            }
+#endif
+
+            if (this->storage_size() + temp.size() > N) GLZ_THROW_OR_ABORT(std::bad_alloc());
+
+            insert(position, temp.begin(), temp.end());
+         }
+
+         return this->begin() + pos_idx;
+      }
+
+      constexpr iterator insert(const_iterator position, std::initializer_list<T> il) // freestanding-deleted
+      {
+         return insert(position, il.begin(), il.end());
+      }
+   };
+
+   namespace freestanding
+   {
+      template <class T, size_t N>
+      class inplace_vector : public detail::inplace_vector::inplace_vector_base<T, N>
+      {
+        public:
+         // types
+         using value_type = T;
+         using pointer = T*;
+         using const_pointer = const T*;
+         using reference = value_type&;
+         using const_reference = const value_type&;
+         using size_type = size_t;
+         using difference_type = std::ptrdiff_t;
+         using iterator = T*;
+         using const_iterator = const T*;
+         using reverse_iterator = std::reverse_iterator<iterator>;
+         using const_reverse_iterator = std::reverse_iterator<const_iterator>;
+
+        public:
+
+        public:
+         // Constructors
+
+         constexpr inplace_vector() noexcept = default;
+
+         constexpr explicit inplace_vector(size_type n) // freestanding-deleted
+            = delete;
+
+         constexpr inplace_vector(size_type n, const T& value) // freestanding-deleted
+            = delete;
+
+         template <class InputIterator>
+         constexpr inplace_vector(InputIterator first, InputIterator last) // freestanding-deleted
+            = delete;
+
+#ifdef __cpp_lib_containers_ranges
+         template <std::ranges::input_range R>
+            requires std::convertible_to<std::ranges::range_reference_t<R>, T>
+         constexpr inplace_vector(std::from_range_t, R&& rg) // freestanding-deleted
+            = delete;
+#endif
+
+         constexpr inplace_vector(std::initializer_list<T> il) // freestanding-deleted
+            = delete;
+         constexpr inplace_vector& operator=(std::initializer_list<T> il) // freestanding-deleted
+            = delete;
+
+         // Assign methods
+         template <std::input_iterator InputIterator>
+         constexpr void assign(InputIterator first, InputIterator last) // freestanding-deleted
+            = delete;
+
+         template <std::ranges::input_range R>
+            requires std::convertible_to<std::ranges::range_reference_t<R>, T>
+         constexpr void assign_range(R&& rg) // freestanding-deleted
+            = delete;
+
+         constexpr void assign(size_type n, const T& value) // freestanding-deleted
+            = delete;
+
+         // TODO add assign(initializer_list<T>)
+
+         // Capacity
+
+         constexpr void resize(size_type sz) // freestanding-deleted
+            = delete;
+
+         constexpr void resize(size_type sz, const T& c) // freestanding-deleted
+            = delete;
+
+         static constexpr void reserve(size_type n) // freestanding-deleted
+            = delete;
+
+         // Element access
+
+         constexpr reference at(size_type n) // freestanding-deleted
+            = delete;
+
+         constexpr const_reference at(size_type n) const // freestanding-deleted
+            = delete;
+
+         // Standard modifiers
+         template <class... Args>
+         constexpr reference emplace_back(Args&&... args) // freestanding-deleted
+            = delete;
+
+         constexpr reference push_back(const T& x) // freestanding-deleted
+            = delete;
+
+         constexpr reference push_back(T&& x) // freestanding-deleted
+            = delete;
+
+         template <std::ranges::input_range R>
+            requires std::convertible_to<std::ranges::range_reference_t<R>, T>
+         constexpr void append_range(R&& rg) // freestanding-deleted
+            = delete;
+
+         // Insert operations
+         template <class... Args>
+         constexpr iterator emplace(const_iterator position, Args&&... args) // freestanding-deleted
+            = delete;
+
+         constexpr iterator insert(const_iterator position, const T& x) // freestanding-deleted
+            = delete;
+
+         constexpr iterator insert(const_iterator position, T&& x) // freestanding-deleted
+            = delete;
+
+         constexpr iterator insert(const_iterator position, size_type n, const T& x) // freestanding-deleted
+            = delete;
+
+         template <class InputIterator>
+         constexpr iterator insert(const_iterator position, InputIterator first,
+                                   InputIterator last) // freestanding-deleted
+            = delete;
+
+         template <std::ranges::input_range R>
+            requires std::convertible_to<std::ranges::range_reference_t<R>, T>
+         constexpr iterator insert_range(const_iterator position, R&& rg) // freestanding-deleted
+            = delete;
+
+         constexpr iterator insert(const_iterator position, std::initializer_list<T> il) // freestanding-deleted
+            = delete;
+      };
+
+   }
+}
diff --git a/deps/saucer/include/glaze/core/array_apply.hpp b/deps/saucer/include/glaze/core/array_apply.hpp
new file mode 100644
index 0000000..8336a11
--- /dev/null
+++ b/deps/saucer/include/glaze/core/array_apply.hpp
@@ -0,0 +1,52 @@
+// Glaze Library
+// For the license information refer to glaze.hpp
+
+#pragma once
+
+#include <cstdint>
+
+namespace glz
+{
+   template <class Adapter>
+   struct array_apply_t
+   {
+      Adapter adapter{};
+      size_t m_size{};
+
+      struct dummy_iterator
+      {
+         using difference_type = std::ptrdiff_t;
+         using value_type = Adapter;
+
+         Adapter& operator*() const { return *adapter; }
+
+         bool operator!=(const dummy_iterator& rhs) const { return position != rhs.position; }
+
+         dummy_iterator& operator++()
+         {
+            ++position;
+            return *this;
+         }
+         dummy_iterator operator++(int)
+         {
+            ++position;
+            return dummy_iterator{adapter, position - 1};
+         }
+         Adapter* adapter{};
+         size_t position{};
+      };
+
+      using reference = Adapter&;
+
+      void clear() {};
+      void resize(size_t newSize) { m_size = newSize; }
+      reference emplace_back() { return adapter; }
+      size_t size() const { return m_size; }
+
+      dummy_iterator begin() { return dummy_iterator{&adapter, 0}; }
+      dummy_iterator end() { return dummy_iterator{&adapter, m_size}; }
+   };
+
+   template <auto Adapter>
+   constexpr auto array_apply = [] { return [](auto&& v) { return array_apply_t{Adapter(v)}; }; }();
+}
diff --git a/deps/saucer/include/glaze/core/cast.hpp b/deps/saucer/include/glaze/core/cast.hpp
new file mode 100644
index 0000000..7e74286
--- /dev/null
+++ b/deps/saucer/include/glaze/core/cast.hpp
@@ -0,0 +1,94 @@
+// Glaze Library
+// For the license information refer to glaze.hpp
+
+#pragma once
+
+#include "glaze/core/context.hpp"
+#include "glaze/core/opts.hpp"
+#include "glaze/tuplet/tuple.hpp"
+
+namespace glz
+{
+   // `cast` allows a user to register a type that Glaze will deserialize/serialize to
+   // and then cast to the underlying value
+   // glz::cast<&T::integer, double>
+   // ^^^ This example would read and write the integer as a double
+   template <class T, auto Target, class CastType>
+   struct cast_t
+   {
+      static constexpr auto glaze_reflect = false;
+      using target_t = decltype(Target);
+      using cast_type = CastType;
+      T& val;
+      static constexpr auto target = Target;
+   };
+
+   template <class T>
+   concept is_cast = requires {
+      requires !T::glaze_reflect;
+      typename T::target_t;
+      typename T::cast_type;
+   };
+
+   template <uint32_t Format, is_cast T>
+   struct from<Format, T>
+   {
+      template <auto Opts>
+      static void op(auto&& value, is_context auto&& ctx, auto&& it, auto&& end)
+      {
+         using V = std::decay_t<decltype(value)>;
+         using Target = typename V::target_t;
+         using Cast = typename V::cast_type;
+
+         Cast temp{};
+         parse<Format>::template op<Opts>(temp, ctx, it, end);
+         if (bool(ctx.error)) [[unlikely]]
+            return;
+
+         if constexpr (std::is_member_object_pointer_v<Target>) {
+            auto& field = value.val.*(value.target);
+            using Field = std::remove_cvref_t<decltype(field)>;
+            field = static_cast<Field>(temp);
+         }
+         else if constexpr (std::invocable<Target, decltype(value.val)>) {
+            auto& field = value.target(value.val);
+            using Field = std::remove_cvref_t<decltype(field)>;
+            field = static_cast<Field>(temp);
+         }
+         else {
+            static_assert(false_v<Target>, "invalid type for cast_t");
+         }
+      }
+   };
+
+   template <uint32_t Format, is_cast T>
+   struct to<Format, T>
+   {
+      template <auto Opts>
+      static void op(auto&& value, is_context auto&& ctx, auto&&... args)
+      {
+         using V = std::decay_t<decltype(value)>;
+         using Target = typename V::target_t;
+         using Cast = typename V::cast_type;
+
+         if constexpr (std::is_member_object_pointer_v<Target>) {
+            serialize<Format>::template op<Opts>(static_cast<Cast>(value.val.*(value.target)), ctx, args...);
+         }
+         else if constexpr (std::invocable<Target, decltype(value.val)>) {
+            serialize<Format>::template op<Opts>(static_cast<Cast>(value.target(value.val)), ctx, args...);
+         }
+         else {
+            static_assert(false_v<T>, "invalid type for cast_t");
+         }
+      }
+   };
+
+   template <auto Target, class CastType>
+   constexpr auto cast_impl() noexcept
+   {
+      return [](auto&& v) { return cast_t<std::remove_cvref_t<decltype(v)>, Target, CastType>{v}; };
+   }
+
+   template <auto Target, class CastType>
+   constexpr auto cast = cast_impl<Target, CastType>();
+}
diff --git a/deps/saucer/include/glaze/core/common.hpp b/deps/saucer/include/glaze/core/common.hpp
index 95a1f68..764d469 100644
--- a/deps/saucer/include/glaze/core/common.hpp
+++ b/deps/saucer/include/glaze/core/common.hpp
@@ -12,10 +12,14 @@
 #include <vector>
 
 #include "glaze/concepts/container_concepts.hpp"
+#include "glaze/core/array_apply.hpp"
+#include "glaze/core/cast.hpp"
+#include "glaze/core/constraint.hpp"
 #include "glaze/core/context.hpp"
+#include "glaze/core/error_category.hpp"
+#include "glaze/core/feature_test.hpp"
 #include "glaze/core/meta.hpp"
 #include "glaze/util/bit_array.hpp"
-#include "glaze/util/comment.hpp"
 #include "glaze/util/expected.hpp"
 #include "glaze/util/for_each.hpp"
 #include "glaze/util/hash_map.hpp"
@@ -41,7 +45,7 @@ namespace glz
    template <class... T>
    struct obj final
    {
-      glz::tuplet::tuple<std::conditional_t<std::is_convertible_v<std::decay_t<T>, sv>, sv, T>...> value;
+      glz::tuple<std::conditional_t<std::is_convertible_v<std::decay_t<T>, sv>, sv, T>...> value;
       static constexpr auto glaze_reflect = false;
    };
 
@@ -51,7 +55,7 @@ namespace glz
    template <class... T>
    struct obj_copy final
    {
-      glz::tuplet::tuple<T...> value;
+      glz::tuple<T...> value;
       static constexpr auto glaze_reflect = false;
    };
 
@@ -61,7 +65,7 @@ namespace glz
    template <class... T>
    struct arr final
    {
-      glz::tuplet::tuple<std::conditional_t<std::is_convertible_v<std::decay_t<T>, sv>, sv, T>...> value;
+      glz::tuple<std::conditional_t<std::is_convertible_v<std::decay_t<T>, sv>, sv, T>...> value;
       static constexpr auto glaze_reflect = false;
    };
 
@@ -71,7 +75,7 @@ namespace glz
    template <class... T>
    struct arr_copy final
    {
-      glz::tuplet::tuple<T...> value;
+      glz::tuple<T...> value;
    };
 
    template <class... T>
@@ -81,7 +85,7 @@ namespace glz
    template <class... T>
    struct merge final
    {
-      glz::tuplet::tuple<std::conditional_t<std::is_convertible_v<std::decay_t<T>, sv>, sv, T>...> value;
+      glz::tuple<std::conditional_t<std::is_convertible_v<std::decay_t<T>, sv>, sv, T>...> value;
       static constexpr auto glaze_reflect = false;
    };
 
@@ -93,9 +97,6 @@ namespace glz
    {
       using T::operator()...;
    };
-   // explicit deduction guide (not needed as of C++20)
-   template <class... T>
-   overload(T...) -> overload<T...>;
 
    struct hidden
    {};
@@ -149,20 +150,8 @@ namespace glz
    template <class T>
    concept is_member_function_pointer = std::is_member_function_pointer_v<T>;
 
-   namespace detail
-   {
-      template <uint32_t Format>
-      struct read
-      {};
-
-      template <uint32_t Format>
-      struct write
-      {};
-
-      template <uint32_t Format>
-      struct write_partial
-      {};
-   } // namespace detail
+   template <class T>
+   using core_t = std::remove_cvref_t<T>;
 
    // Use std::stringview if you know the buffer is going to outlive this
    template <class string_type = std::string>
@@ -173,7 +162,7 @@ namespace glz
       basic_raw_json() = default;
 
       template <class T>
-         requires(!std::same_as<std::decay_t<T>, basic_raw_json>)
+         requires(!std::same_as<std::decay_t<T>, basic_raw_json> && std::constructible_from<string_type, T>)
       basic_raw_json(T&& s) : str(std::forward<T>(s))
       {}
 
@@ -215,634 +204,323 @@ namespace glz
    using text = basic_text<std::string>;
    using text_view = basic_text<std::string_view>;
 
-   namespace detail
-   {
-      template <class T>
-      concept constructible = requires { meta<std::decay_t<T>>::construct; } || local_construct_t<std::decay_t<T>>;
-
-      template <class T>
-      concept meta_value_t = glaze_t<std::decay_t<T>>;
-
-      template <class T>
-      concept str_t = !std::same_as<std::nullptr_t, T> && std::convertible_to<std::decay_t<T>, std::string_view>;
-
-      // this concept requires that T is string and copies the string in json
-      template <class T>
-      concept string_t = str_t<T> && !std::same_as<std::decay_t<T>, std::string_view> && has_push_back<T>;
-
-      template <class T>
-      concept char_array_t = str_t<T> && std::is_array_v<std::remove_pointer_t<std::remove_reference_t<T>>>;
-
-      // this concept requires that T is just a view
-      template <class T>
-      concept string_view_t = std::same_as<std::decay_t<T>, std::string_view>;
+   template <class T>
+   concept constructible = requires { meta<std::decay_t<T>>::construct; } || local_construct_t<std::decay_t<T>>;
 
-      template <class T>
-      concept readable_map_t = !custom_read<T> && !meta_value_t<T> && !str_t<T> && range<T> &&
-                               pair_t<range_value_t<T>> && map_subscriptable<T>;
+   template <class T>
+   concept meta_value_t = glaze_t<std::decay_t<T>>;
 
-      template <class T>
-      concept writable_map_t =
-         !custom_write<T> && !meta_value_t<T> && !str_t<T> && range<T> && pair_t<range_value_t<T>>;
-
-      template <class Map>
-      concept heterogeneous_map = requires {
-         typename Map::key_compare;
-         requires(std::same_as<typename Map::key_compare, std::less<>> ||
-                  std::same_as<typename Map::key_compare, std::greater<>> ||
-                  requires { typename Map::key_compare::is_transparent; });
-      };
+   // this concept requires that T is just a view
+   template <class T>
+   concept string_view_t = std::same_as<std::decay_t<T>, std::string_view>;
 
-      template <class T>
-      concept array_t = (!meta_value_t<T> && !str_t<T> && !(readable_map_t<T> || writable_map_t<T>)&&range<T>);
+   template <class T>
+   concept array_char_t =
+      requires { std::tuple_size<T>::value; } && std::same_as<T, std::array<char, std::tuple_size_v<T>>>;
 
-      template <class T>
-      concept readable_array_t =
-         (range<T> && !custom_read<T> && !meta_value_t<T> && !str_t<T> && !readable_map_t<T> && !filesystem_path<T>);
+   template <class T>
+   concept str_t = (!std::same_as<std::nullptr_t, T> && std::constructible_from<std::string_view, std::decay_t<T>>) ||
+                   array_char_t<T>;
 
-      template <class T>
-      concept writable_array_t =
-         (range<T> && !custom_write<T> && !meta_value_t<T> && !str_t<T> && !writable_map_t<T> && !filesystem_path<T>);
+   template <class T>
+   concept is_static_string =
+      requires { meta<std::decay_t<T>>::glaze_static_string == true; } || std::decay_t<T>::glaze_static_string == true;
 
-      template <class T>
-      concept fixed_array_value_t = array_t<std::decay_t<decltype(std::declval<T>()[0])>> &&
-                                    !resizable<std::decay_t<decltype(std::declval<T>()[0])>>;
+   // this concept requires that T is a writeable string. It can be resized, appended to, or assigned to
+   template <class T>
+   concept string_t = str_t<T> && !string_view_t<T> &&
+                      (has_assign<T> || (resizable<T> && has_data<T>) || has_append<T>) && !is_static_string<T>;
 
-      template <class T>
-      concept boolean_like = std::same_as<T, bool> || std::same_as<T, std::vector<bool>::reference> ||
-                             std::same_as<T, std::vector<bool>::const_reference>;
+   // static string; very like `string_t`, but with a fixed max capacity
+   template <class T>
+   concept static_string_t = str_t<T> && !string_view_t<T> &&
+                             (has_assign<T> || (resizable<T> && has_data<T>) || has_append<T>) && is_static_string<T>;
 
-      template <class T>
-      concept is_no_reflect = requires(T t) { requires T::glaze_reflect == false; };
+   template <class T>
+   concept char_array_t = str_t<T> && std::is_array_v<std::remove_pointer_t<std::remove_reference_t<T>>>;
 
-      /// \brief check if container has fixed size and its subsequent T::value_type
-      template <class T>
-      concept has_static_size =
-         (is_span<T> && !is_dynamic_span<T>) || (
-                                                   requires(T container) {
-                                                      {
-                                                         std::bool_constant<(std::decay_t<T>{}.size(), true)>()
-                                                      } -> std::same_as<std::true_type>;
-                                                   } && std::decay_t<T>{}.size() > 0 &&
-                                                   requires {
-                                                      typename T::value_type;
-                                                      requires std::is_trivially_copyable_v<typename T::value_type>;
-                                                   });
-      static_assert(has_static_size<std::array<int, 2>>);
-      static_assert(!has_static_size<std::array<std::string, 2>>);
+   template <class T>
+   concept readable_map_t = !custom_read<T> && !meta_value_t<T> && !str_t<T> && range<T> && pair_t<range_value_t<T>> &&
+                            map_subscriptable<std::decay_t<T>>;
 
-      template <class T>
-      constexpr bool is_std_array = false;
-      template <class T, std::size_t N>
-      constexpr bool is_std_array<std::array<T, N>> = true;
+   template <class T>
+   concept writable_map_t = !custom_write<T> && !meta_value_t<T> && !str_t<T> && range<T> && pair_t<range_value_t<T>> &&
+                            map_subscriptable<std::decay_t<T>>;
+
+   template <class Map>
+   concept heterogeneous_map = requires {
+      typename Map::key_compare;
+      requires(std::same_as<typename Map::key_compare, std::less<>> ||
+               std::same_as<typename Map::key_compare, std::greater<>> ||
+               requires { typename Map::key_compare::is_transparent; });
+   };
 
-      template <class T>
-      concept has_fixed_size_container = std::is_array_v<T> || is_std_array<T>;
-      static_assert(has_fixed_size_container<std::array<std::string, 2>>);
-      static_assert(has_fixed_size_container<int[54]>);
+   template <class T>
+   concept array_t = (!meta_value_t<T> && !str_t<T> && !(readable_map_t<T> || writable_map_t<T>) && range<T>);
 
-      template <class T>
-      constexpr size_t get_size() noexcept
-      {
-         if constexpr (is_span<T>) {
-            return T::extent;
-         }
-         else if constexpr (std::is_array_v<T>) {
-            return std::extent_v<T>;
-         }
-         else if constexpr (is_std_array<T>) {
-            return glz::tuple_size_v<T>;
-         }
-         else {
-            return std::decay_t<T>{}.size();
-         }
-      }
+   template <class T>
+   concept readable_array_t =
+      (range<T> && !custom_read<T> && !meta_value_t<T> && !str_t<T> && !readable_map_t<T> && !filesystem_path<T>);
 
-      template <class T>
-      concept is_reference_wrapper = is_specialization_v<T, std::reference_wrapper>;
+   template <class T>
+   concept writable_array_t =
+      (range<T> && !custom_write<T> && !meta_value_t<T> && !str_t<T> && !writable_map_t<T> && !filesystem_path<T>);
 
-      template <class T>
-      concept tuple_t = requires(T t) {
-         glz::tuple_size<T>::value;
-         glz::get<0>(t);
-      } && !meta_value_t<T> && !range<T>;
+   template <class T>
+   concept fixed_array_value_t =
+      array_t<std::decay_t<decltype(std::declval<T>()[0])>> && !resizable<std::decay_t<decltype(std::declval<T>()[0])>>;
 
-      template <class T>
-      concept glaze_wrapper = requires { requires T::glaze_wrapper == true; };
+   template <class T>
+   concept boolean_like = std::same_as<std::remove_cvref_t<T>, bool> || std::same_as<T, std::vector<bool>::reference> ||
+                          std::same_as<T, std::vector<bool>::const_reference>;
 
-      template <class T>
-      concept always_null_t =
-         std::same_as<T, std::nullptr_t> || std::convertible_to<T, std::monostate> || std::same_as<T, std::nullopt_t>;
+   template <class T>
+   concept is_no_reflect = requires(T t) { requires std::remove_cvref_t<T>::glaze_reflect == false; };
 
-      template <class T>
-      concept nullable_t = !meta_value_t<T> && !str_t<T> && requires(T t) {
-         bool(t);
-         {
-            *t
-         };
-      };
+   /// \brief check if container has fixed size and its subsequent T::value_type
+   template <class T>
+   concept has_static_size =
+      (is_span<T> && !is_dynamic_span<T>) || (
+                                                requires(T container) {
+                                                   {
+                                                      std::bool_constant<(std::decay_t<T>{}.size(), true)>()
+                                                   } -> std::same_as<std::true_type>;
+                                                } && std::decay_t<T>{}.size() > 0 &&
+                                                requires {
+                                                   typename T::value_type;
+                                                   requires std::is_trivially_copyable_v<typename T::value_type>;
+                                                });
+   static_assert(has_static_size<std::array<int, 2>>);
+   static_assert(!has_static_size<std::array<std::string, 2>>);
 
-      template <class T>
-      concept nullable_wrapper = glaze_wrapper<T> && nullable_t<typename T::value_type>;
+   template <class T>
+   constexpr bool is_std_array = false;
+   template <class T, std::size_t N>
+   constexpr bool is_std_array<std::array<T, N>> = true;
 
-      template <class T>
-      concept null_t = nullable_t<T> || always_null_t<T> || nullable_wrapper<T>;
+   template <class T>
+   concept has_fixed_size_container = std::is_array_v<T> || is_std_array<T>;
+   static_assert(has_fixed_size_container<std::array<std::string, 2>>);
+   static_assert(has_fixed_size_container<int[54]>);
 
-      template <class T>
-      concept func_t = requires(T t) {
-         typename T::result_type;
-         std::function(t);
-      } && !glaze_t<T>;
+   template <class T>
+   constexpr size_t get_size() noexcept
+   {
+      if constexpr (is_span<T>) {
+         return T::extent;
+      }
+      else if constexpr (std::is_array_v<T>) {
+         return std::extent_v<T>;
+      }
+      else if constexpr (is_std_array<T>) {
+         return glz::tuple_size_v<T>;
+      }
+      else {
+         return std::decay_t<T>{}.size();
+      }
+   }
 
-      template <class T>
-      concept glaze_array_t = glaze_t<T> && is_specialization_v<meta_wrapper_t<T>, Array>;
+   template <class T>
+   concept is_reference_wrapper = is_specialization_v<T, std::reference_wrapper>;
 
-      template <class T>
-      concept glaze_object_t = glaze_t<T> && is_specialization_v<meta_wrapper_t<T>, Object>;
+   template <class T>
+   concept tuple_t = requires(T t) {
+      glz::tuple_size<T>::value;
+      glz::get<0>(t);
+   } && !meta_value_t<T> && !range<T>;
 
-      template <class T>
-      concept glaze_enum_t = glaze_t<T> && is_specialization_v<meta_wrapper_t<T>, Enum>;
+   template <class T>
+   concept glaze_wrapper = requires { requires T::glaze_wrapper == true; };
 
-      template <class T>
-      concept glaze_flags_t = glaze_t<T> && is_specialization_v<meta_wrapper_t<T>, Flags>;
+   template <class T>
+   concept always_null_t =
+      std::same_as<T, std::nullptr_t> || std::convertible_to<T, std::monostate> || std::same_as<T, std::nullopt_t>;
 
-      template <class T>
-      concept glaze_value_t =
-         glaze_t<T> && !(glaze_array_t<T> || glaze_object_t<T> || glaze_enum_t<T> || glaze_flags_t<T>);
+   template <class T>
+   concept always_skipped = is_includer<T> || std::same_as<T, hidden> || std::same_as<T, skip>;
 
-      template <class T>
-      concept reflectable = std::is_aggregate_v<std::remove_cvref_t<T>> && std::is_class_v<std::remove_cvref_t<T>> &&
-                            !(is_no_reflect<T> || glaze_value_t<T> || glaze_object_t<T> || glaze_array_t<T> ||
-                              glaze_flags_t<T> || range<T> || pair_t<T> || null_t<T>);
+   template <class T>
+   concept nullable_t = !meta_value_t<T> && !str_t<T> && requires(T t) {
+      bool(t);
+      { *t };
+   };
 
-      template <class T>
-      concept glaze_const_value_t = glaze_value_t<T> && std::is_pointer_v<glz::meta_wrapper_t<T>> &&
-                                    std::is_const_v<std::remove_pointer_t<glz::meta_wrapper_t<T>>>;
+   template <class T>
+   concept nullable_like = nullable_t<T> && (!is_expected<T> && !std::is_array_v<T>);
 
-      template <class From, class To>
-      concept non_narrowing_convertable = requires(From from, To to) {
-#if __GNUC__
-         // TODO: guard gcc against narrowing conversions when fixed
-         to = from;
-#else
-         To{from};
-#endif
-      };
+   // For optional like types that cannot overload `operator bool()`
+   template <class T>
+   concept nullable_value_t = !meta_value_t<T> && requires(T t) {
+      t.value();
+      { t.has_value() } -> std::convertible_to<bool>;
+   };
 
-      // from
-      // https://stackoverflow.com/questions/55941964/how-to-filter-duplicate-types-from-tuple-c
-      template <class T, class... Ts>
-      struct unique
-      {
-         using type = T;
-      };
+   template <class T>
+   concept nullable_wrapper = glaze_wrapper<T> && nullable_t<typename T::value_type>;
 
-      template <template <class...> class T, class... Ts, class U, class... Us>
-      struct unique<T<Ts...>, U, Us...>
-         : std::conditional_t<(std::is_same_v<U, Ts> || ...), unique<T<Ts...>, Us...>, unique<T<Ts..., U>, Us...>>
-      {};
+   template <class T>
+   concept null_t = nullable_t<T> || nullable_value_t<T> || always_null_t<T> || nullable_wrapper<T>;
 
-      template <class T>
-      struct tuple_variant;
+   template <class T>
+   concept func_t = requires(T t) {
+      typename T::result_type;
+      std::function(t);
+   } && !glaze_t<T>;
 
-      template <class... Ts>
-      struct tuple_variant<glz::tuplet::tuple<Ts...>> : unique<std::variant<>, Ts...>
-      {};
+   template <class T>
+   concept glaze_array_t = glaze_t<T> && is_specialization_v<meta_wrapper_t<T>, detail::Array>;
 
-      template <class T>
-      struct tuple_ptr_variant;
+   template <class T>
+   concept glaze_object_t = glaze_t<T> && (is_specialization_v<meta_wrapper_t<T>, detail::Object> ||
+                                           (not std::is_enum_v<std::decay_t<T>> && meta_keys<T>));
 
-      template <class... Ts>
-      struct tuple_ptr_variant<glz::tuplet::tuple<Ts...>> : unique<std::variant<>, std::add_pointer_t<Ts>...>
-      {};
+   template <class T>
+   concept glaze_enum_t = glaze_t<T> && is_specialization_v<meta_wrapper_t<T>, detail::Enum>;
 
-      template <class... Ts>
-      struct tuple_ptr_variant<std::tuple<Ts...>> : unique<std::variant<>, std::add_pointer_t<Ts>...>
-      {};
+   template <class T>
+   concept is_named_enum = ((glaze_enum_t<T> || (meta_keys<T> && std::is_enum_v<T>)) && !custom_read<T>);
 
-      template <class... Ts>
-      struct tuple_ptr_variant<std::pair<Ts...>> : unique<std::variant<>, std::add_pointer_t<Ts>...>
-      {};
+   template <class T>
+   concept glaze_flags_t = glaze_t<T> && is_specialization_v<meta_wrapper_t<T>, detail::Flags>;
 
-      template <class Tuple, class = std::make_index_sequence<glz::tuple_size<Tuple>::value>>
-      struct value_tuple_variant;
+   template <class T>
+   concept glaze_value_t =
+      glaze_t<T> && !(glaze_array_t<T> || glaze_object_t<T> || glaze_enum_t<T> || meta_keys<T> || glaze_flags_t<T>);
 
-      template <class Tuple, size_t I>
-      struct member_type
-      {
-         using T0 = decay_keep_volatile_t<glz::tuple_element_t<0, glz::tuple_element_t<I, Tuple>>>;
-         using type = glz::tuple_element_t<std::is_member_pointer_v<T0> ? 0 : 1, glz::tuple_element_t<I, Tuple>>;
-      };
+   template <class T>
+   concept reflectable = std::is_aggregate_v<std::remove_cvref_t<T>> && std::is_class_v<std::remove_cvref_t<T>> &&
+                         !(is_no_reflect<T> || glaze_value_t<T> || glaze_object_t<T> || glaze_array_t<T> ||
+                           glaze_flags_t<T> || range<T> || pair_t<T> || null_t<T> || meta_keys<T>);
 
-      template <class Tuple, size_t... I>
-      struct value_tuple_variant<Tuple, std::index_sequence<I...>>
-      {
-         using type = typename tuple_variant<decltype(glz::tuplet::tuple_cat(
-            std::declval<tuplet::tuple<typename member_type<Tuple, I>::type>>()...))>::type;
-      };
+   template <class T>
+   concept is_memory_object = is_memory_type<T> && (glaze_object_t<memory_type<T>> || reflectable<memory_type<T>>);
 
-      template <class Tuple>
-      using value_tuple_variant_t = typename value_tuple_variant<Tuple>::type;
+   template <class T>
+   concept glaze_const_value_t = glaze_value_t<T> && std::is_pointer_v<glz::meta_wrapper_t<T>> &&
+                                 std::is_const_v<std::remove_pointer_t<glz::meta_wrapper_t<T>>>;
 
-      template <class T>
-      inline constexpr auto make_array()
-      {
-         return []<size_t... I>(std::index_sequence<I...>) {
-            using value_t = typename tuple_variant<meta_t<T>>::type;
-            return std::array<value_t, glz::tuple_size_v<meta_t<T>>>{glz::get<I>(meta_v<T>)...};
-         }(std::make_index_sequence<glz::tuple_size_v<meta_t<T>>>{});
-      }
+   template <class From, class To>
+   concept non_narrowing_convertable = requires(From from, To to) {
+#if __GNUC__
+      // TODO: guard gcc against narrowing conversions when fixed
+      to = from;
+#else
+      To{from};
+#endif
+   };
 
-      template <class Tuple, std::size_t... Is>
-      inline constexpr auto tuple_runtime_getter(std::index_sequence<Is...>)
-      {
-         using value_t = typename tuple_ptr_variant<Tuple>::type;
-         using tuple_ref = std::add_lvalue_reference_t<Tuple>;
-         using getter_t = value_t (*)(tuple_ref);
-         return std::array<getter_t, glz::tuple_size_v<Tuple>>{+[](tuple_ref t) -> value_t {
-            if constexpr (is_std_tuple<Tuple>) {
-               return &std::get<Is>(t);
-            }
-            else {
-               return &glz::get<Is>(t);
-            }
-         }...};
-      }
+   template <is_variant T, size_t... I>
+   constexpr auto make_variant_sv_id_map_impl(std::index_sequence<I...>, auto&& variant_ids)
+   {
+      return normal_map<sv, size_t, std::variant_size_v<T>>(std::array{pair<sv, size_t>{sv(variant_ids[I]), I}...});
+   }
 
-      template <class Tuple>
-      inline auto get_runtime(Tuple&& t, const size_t index)
-      {
-         using T = std::decay_t<Tuple>;
-         static constexpr auto indices = std::make_index_sequence<glz::tuple_size_v<T>>{};
-         static constexpr auto runtime_getter = tuple_runtime_getter<T>(indices);
-         return runtime_getter[index](t);
-      }
+   template <is_variant T, size_t... I>
+   constexpr auto make_variant_id_map_impl(std::index_sequence<I...>, auto&& variant_ids)
+   {
+      using id_type = std::decay_t<decltype(ids_v<T>[0])>;
+      return normal_map<id_type, size_t, std::variant_size_v<T>>(std::array{pair{variant_ids[I], I}...});
+   }
 
-      template <class T, size_t I>
-      constexpr auto key_value() noexcept
-      {
-         using value_t = value_tuple_variant_t<meta_t<T>>;
-         constexpr auto first = get<0>(get<I>(meta_v<T>));
-         using T0 = std::decay_t<decltype(first)>;
-         if constexpr (std::is_member_pointer_v<T0>) {
-            return pair<sv, value_t>{get_name<first>(), first};
-         }
-         else {
-            return pair<sv, value_t>{sv(first), get<1>(get<I>(meta_v<T>))};
-         }
-      }
+   template <is_variant T>
+   constexpr auto make_variant_id_map()
+   {
+      constexpr auto indices = std::make_index_sequence<std::variant_size_v<T>>{};
 
-      template <class T, size_t I>
-      constexpr sv get_key() noexcept
-      {
-         constexpr auto first = get<0>(get<I>(meta_v<T>));
-         using T0 = std::decay_t<decltype(first)>;
-         if constexpr (std::is_member_pointer_v<T0>) {
-            return get_name<first>();
-         }
-         else {
-            return {first};
-         }
-      }
+      using id_type = std::decay_t<decltype(ids_v<T>[0])>;
 
-      template <class T, size_t I>
-      constexpr sv get_enum_key() noexcept
-      {
-         constexpr auto first = get<0>(get<I>(meta_v<T>));
-         using T0 = std::decay_t<decltype(first)>;
-         if constexpr (std::is_enum_v<T0>) {
-            return get_name<first>();
-         }
-         else {
-            return {first};
-         }
+      if constexpr (std::integral<id_type>) {
+         return make_variant_id_map_impl<T>(indices, ids_v<T>);
       }
-
-      template <class T, size_t I>
-      constexpr auto get_enum_value() noexcept
-      {
-         constexpr auto first = get<0>(get<I>(meta_v<T>));
-         using T0 = std::decay_t<decltype(first)>;
-         if constexpr (std::is_enum_v<T0>) {
-            return first;
-         }
-         else {
-            return get<1>(get<I>(meta_v<T>));
-         }
+      else {
+         return make_variant_sv_id_map_impl<T>(indices, ids_v<T>);
       }
+   }
 
-      template <class T, size_t I>
-      struct meta_sv
-      {
-         static constexpr sv value = get_key<T, I>();
-      };
-
-      template <class T, bool use_hash_comparison, size_t... I>
-      constexpr auto make_map_impl(std::index_sequence<I...>)
-      {
-         using value_t = value_tuple_variant_t<meta_t<T>>;
-         constexpr auto n = glz::tuple_size_v<meta_t<T>>;
-
-         if constexpr (n == 0) {
-            return nullptr; // Hack to fix MSVC
-            // static_assert(false_v<T>, "Empty object map is illogical. Handle empty upstream.");
-         }
-         else if constexpr (n == 1) {
-            return micro_map1<value_t, meta_sv<T, I>::value...>{key_value<T, I>()...};
-         }
-         else if constexpr (n == 2) {
-            return micro_map2<value_t, meta_sv<T, I>::value...>{key_value<T, I>()...};
-         }
-         else if constexpr (n < 64) // don't even attempt a first character hash if we have too many keys
-         {
-            constexpr std::array<sv, n> keys{get_key<T, I>()...};
-            constexpr auto front_desc = single_char_hash<n>(keys);
-
-            if constexpr (front_desc.valid) {
-               return make_single_char_map<value_t, front_desc>({key_value<T, I>()...});
-            }
-            else {
-               constexpr single_char_hash_opts rear_hash{.is_front_hash = false};
-               constexpr auto back_desc = single_char_hash<n, rear_hash>(keys);
-
-               if constexpr (back_desc.valid) {
-                  return make_single_char_map<value_t, back_desc>({key_value<T, I>()...});
-               }
-               else {
-                  constexpr single_char_hash_opts sum_hash{.is_front_hash = true, .is_sum_hash = true};
-                  constexpr auto sum_desc = single_char_hash<n, sum_hash>(keys);
-
-                  if constexpr (sum_desc.valid) {
-                     return make_single_char_map<value_t, sum_desc>({key_value<T, I>()...});
-                  }
-                  else {
-                     if constexpr (n <= naive_map_max_size) {
-                        constexpr auto naive_desc = naive_map_hash<use_hash_comparison, n>(keys);
-                        return glz::detail::make_naive_map<value_t, naive_desc>(std::array{key_value<T, I>()...});
-                     }
-                     else {
-                        return glz::detail::normal_map<sv, value_t, n, use_hash_comparison>(
-                           std::array{key_value<T, I>()...});
-                     }
-                  }
-               }
-            }
+   /**
+    * @brief Extracts the underlying member from a struct.
+    *
+    * Core Glaze function to extract the underlying member. Typically, the `value` parameter
+    * is the struct containing the member field. The `element` parameter denotes a member object
+    * pointer or an invocable function, which allows member extraction from the struct.
+    *
+    * @tparam Value   The type of the value, usually a struct containing the member.
+    * @tparam Element The type of the element, either a member pointer, an invocable function, or reference/pointer.
+    * @param value    The struct from which to extract the member.
+    * @param element  The member pointer or invocable function used to extract the member.
+    * @return         The extracted member.
+    */
+   template <class Value, class Element>
+   GLZ_ALWAYS_INLINE decltype(auto) get_member(Value&& value, Element&& element)
+   {
+      using V = std::decay_t<decltype(element)>;
+      if constexpr (std::is_member_object_pointer_v<V>) {
+         return value.*element;
+      }
+      else if constexpr (std::is_member_function_pointer_v<V>) {
+         return element;
+      }
+      else if constexpr (std::invocable<Element, Value> && not eigen_t<Element>) {
+         // Eigen places a static_assert inside of the operator()(), so we must target
+         // matrix types and reject them from the invocable check
+         // Eigen ought to put the check in the `enable_if` for operator()()
+         return std::invoke(std::forward<Element>(element), std::forward<Value>(value));
+      }
+      else if constexpr (std::is_pointer_v<V>) {
+         if constexpr (std::invocable<decltype(*element), Value>) {
+            return std::invoke(*element, std::forward<Value>(value));
          }
          else {
-            return glz::detail::normal_map<sv, value_t, n, use_hash_comparison>(std::array{key_value<T, I>()...});
+            return *element;
          }
       }
-
-      template <class T, bool use_hash_comparison = false>
-         requires(!reflectable<T>)
-      constexpr auto make_map()
-      {
-         constexpr auto indices = std::make_index_sequence<glz::tuple_size_v<meta_t<T>>>{};
-         return make_map_impl<decay_keep_volatile_t<T>, use_hash_comparison>(indices);
-      }
-
-      template <class T>
-      constexpr auto make_key_int_map()
-      {
-         constexpr auto N = glz::tuple_size_v<meta_t<T>>;
-         return [&]<size_t... I>(std::index_sequence<I...>) {
-            return normal_map<sv, size_t, glz::tuple_size_v<meta_t<T>>>(pair<sv, size_t>{get_enum_key<T, I>(), I}...);
-         }(std::make_index_sequence<N>{});
-      }
-
-      template <class T>
-      constexpr auto make_enum_to_string_map()
-      {
-         constexpr auto N = glz::tuple_size_v<meta_t<T>>;
-         return [&]<size_t... I>(std::index_sequence<I...>) {
-            using key_t = std::underlying_type_t<T>;
-            return normal_map<key_t, sv, N>(std::array<pair<key_t, sv>, N>{
-               pair<key_t, sv>{static_cast<key_t>(get_enum_value<T, I>()), get_enum_key<T, I>()}...});
-         }(std::make_index_sequence<N>{});
-      }
-
-      // TODO: This faster approach can be used if the enum has an integer type base and sequential numbering
-      template <class T>
-      constexpr auto make_enum_to_string_array() noexcept
-      {
-         return []<size_t... I>(std::index_sequence<I...>) {
-            return std::array<sv, sizeof...(I)>{get_enum_key<T, I>()...};
-         }(std::make_index_sequence<glz::tuple_size_v<meta_t<T>>>{});
-      }
-
-      template <class T>
-      constexpr auto make_string_to_enum_map() noexcept
-      {
-         constexpr auto N = glz::tuple_size_v<meta_t<T>>;
-         return [&]<size_t... I>(std::index_sequence<I...>) {
-            return normal_map<sv, T, N>(
-               std::array<pair<sv, T>, N>{pair<sv, T>{get_enum_key<T, I>(), T(get_enum_value<T, I>())}...});
-         }(std::make_index_sequence<N>{});
-      }
-
-      // get a std::string_view from an enum value
-      template <class T>
-         requires(detail::glaze_t<T> && std::is_enum_v<std::decay_t<T>>)
-      constexpr auto get_enum_name(T&& enum_value)
-      {
-         using V = std::decay_t<T>;
-         using U = std::underlying_type_t<V>;
-         constexpr auto arr = glz::detail::make_enum_to_string_array<V>();
-         return arr[static_cast<U>(enum_value)];
-      }
-
-      template <class T, size_t N>
-      constexpr size_t get_max_keys = [] {
-         size_t res{};
-         for_each<N>([&](auto I) {
-            using V = std::decay_t<std::variant_alternative_t<I, T>>;
-            if constexpr (reflectable<V>) {
-               res += count_members<V>;
-            }
-            else {
-               res += glz::tuple_size_v<meta_t<V>>;
-            }
-         });
-         return res;
-      }();
-
-      template <class T>
-      constexpr auto get_combined_keys_from_variant()
-      {
-         constexpr auto N = std::variant_size_v<T>;
-
-         std::array<std::string_view, get_max_keys<T, N>> keys{};
-         // This intermediate pointer is necessary for GCC 13 (otherwise segfaults with reflection logic)
-         auto* data_ptr = &keys;
-         size_t index = 0;
-         for_each<N>([&](auto I) {
-            using V = std::decay_t<std::variant_alternative_t<I, T>>;
-            if constexpr (reflectable<V>) {
-               for_each<glz::tuple_size_v<decltype(member_names<V>)>>(
-                  [&](auto J) { (*data_ptr)[index++] = glz::get<J>(member_names<V>); });
-            }
-            else {
-               for_each<glz::tuple_size_v<meta_t<V>>>([&](auto J) {
-                  constexpr auto item = get<J>(meta_v<V>);
-                  using T0 = std::decay_t<decltype(get<0>(item))>;
-                  auto key_getter = [&] {
-                     if constexpr (std::is_member_pointer_v<T0>) {
-                        return get_name<get<0>(get<J>(meta_v<V>))>();
-                     }
-                     else {
-                        return get<0>(get<J>(meta_v<V>));
-                     }
-                  };
-                  (*data_ptr)[index++] = key_getter();
-               });
-            }
-         });
-
-         std::sort(keys.begin(), keys.end());
-         const auto end = std::unique(keys.begin(), keys.end());
-         const auto size = std::distance(keys.begin(), end);
-
-         return std::pair{keys, size};
-      }
-
-      template <class T, size_t... I>
-      consteval auto make_variant_deduction_base_map(std::index_sequence<I...>, auto&& keys)
-      {
-         using V = bit_array<std::variant_size_v<T>>;
-         return normal_map<sv, V, sizeof...(I)>(
-            std::array<pair<sv, V>, sizeof...(I)>{pair<sv, V>{sv(std::get<I>(keys)), V{}}...});
-      }
-
-      template <class T>
-      constexpr auto make_variant_deduction_map()
-      {
-         constexpr auto key_size_pair = get_combined_keys_from_variant<T>();
-
-         auto deduction_map =
-            make_variant_deduction_base_map<T>(std::make_index_sequence<key_size_pair.second>{}, key_size_pair.first);
-
-         constexpr auto N = std::variant_size_v<T>;
-         for_each<N>([&](auto I) {
-            using V = decay_keep_volatile_t<std::variant_alternative_t<I, T>>;
-            if constexpr (reflectable<V>) {
-               for_each<glz::tuple_size_v<decltype(member_names<V>)>>(
-                  [&](auto J) { deduction_map.find(get<J>(member_names<V>))->second[I] = true; });
-            }
-            else {
-               for_each<glz::tuple_size_v<meta_t<V>>>([&](auto J) {
-                  constexpr auto item = get<J>(meta_v<V>);
-                  using T0 = std::decay_t<decltype(get<0>(item))>;
-                  auto key_getter = [&] {
-                     if constexpr (std::is_member_pointer_v<T0>) {
-                        return get_name<get<0>(get<J>(meta_v<V>))>();
-                     }
-                     else {
-                        return get<0>(get<J>(meta_v<V>));
-                     }
-                  };
-                  deduction_map.find(key_getter())->second[I] = true;
-               });
-            }
-         });
-
-         return deduction_map;
-      }
-
-      template <is_variant T, size_t... I>
-      constexpr auto make_variant_id_map_impl(std::index_sequence<I...>, auto&& variant_ids)
-      {
-         return normal_map<sv, size_t, std::variant_size_v<T>>(std::array{pair<sv, size_t>{sv(variant_ids[I]), I}...});
-      }
-
-      template <is_variant T>
-      constexpr auto make_variant_id_map()
-      {
-         constexpr auto indices = std::make_index_sequence<std::variant_size_v<T>>{};
-
-         return make_variant_id_map_impl<T>(indices, ids_v<T>);
-      }
-
-      template <class Value, class MemPtr>
-      inline decltype(auto) get_member(Value&& value, MemPtr&& member_ptr)
-      {
-         using V = std::decay_t<decltype(member_ptr)>;
-         if constexpr (std::is_member_object_pointer_v<V>) {
-            return value.*member_ptr;
-         }
-         else if constexpr (std::is_member_function_pointer_v<V>) {
-            return member_ptr;
-         }
-         else if constexpr (std::invocable<MemPtr, Value>) {
-            return std::invoke(std::forward<MemPtr>(member_ptr), std::forward<Value>(value));
-         }
-         else if constexpr (std::is_pointer_v<V>) {
-            if constexpr (std::invocable<decltype(*member_ptr), Value>) {
-               return std::invoke(*member_ptr, std::forward<Value>(value));
-            }
-            else {
-               return *member_ptr;
-            }
-         }
-         else {
-            return member_ptr;
-         }
+      else {
+         return element;
       }
+   }
 
-      // member_ptr and lambda wrapper helper
-      template <template <class> class Wrapper, class Wrapped>
-      struct wrap
-      {
-         Wrapped wrapped;
-         constexpr decltype(auto) operator()(auto&& value) const
-         {
-            return Wrapper<std::decay_t<decltype(get_member(value, wrapped))>>{get_member(value, wrapped)};
-         }
-
-         constexpr decltype(auto) unwrap(auto&& value) const { return get_member(value, wrapped); }
-      };
-
-      template <class T, class mptr_t>
-      using member_t = decltype(get_member(std::declval<T>(), std::declval<std::decay_t<mptr_t>&>()));
-
-      template <class T, class = std::make_index_sequence<glz::tuple_size<meta_t<T>>::value>>
-      struct members_from_meta;
-
-      template <class T, size_t... I>
-      inline constexpr auto members_from_meta_impl()
+   /**
+    * @brief Alias for the expected return type of `get_member`.
+    *
+    * This template alias deduces the return type of the `get_member` function when called with
+    * the specified `Value` and `Element` types.
+    *
+    * @tparam Value   The type of the value parameter, typically a struct containing the member.
+    * @tparam Element The type of the element, either a member pointer, an invocable function, or reference/pointer.
+    *
+    * @see get_member
+    */
+   template <class Value, class Element>
+   using member_t = decltype(get_member(std::declval<std::add_lvalue_reference_t<Value>>(), std::declval<Element>()));
+
+   // member_ptr and lambda wrapper helper
+   template <template <class> class Wrapper, class Wrapped>
+   struct wrap
+   {
+      Wrapped wrapped;
+      constexpr decltype(auto) operator()(auto&& value) const
       {
-         if constexpr (glaze_object_t<std::decay_t<T>>) {
-            return glz::tuplet::tuple<std::decay_t<member_t<T, typename member_type<meta_t<T>, I>::type>>...>{};
-         }
-         else {
-            return glz::tuplet::tuple{};
-         }
+         return Wrapper<std::decay_t<decltype(get_member(value, wrapped))>>{get_member(value, wrapped)};
       }
 
-      template <class T, size_t... I>
-      struct members_from_meta<T, std::index_sequence<I...>>
-      {
-         using type = decltype(members_from_meta_impl<T, I...>());
-      };
-
-      template <class T>
-      using member_tuple_t = typename members_from_meta<T>::type;
+      constexpr decltype(auto) unwrap(auto&& value) const { return get_member(value, wrapped); }
+   };
 
-      // Output variants in the following format  ["variant_type", variant_json_data] with
-      // glz::detail:array_variant(&T::var);
-      template <is_variant T>
-      struct array_variant_wrapper
-      {
-         T& value;
-      };
-      // TODO: Could do this if the compiler supports alias template deduction
-      // template <class T>
-      // using array_var = wrap<array_var_wrapper, T>;
-      template <class T>
-      struct array_variant : wrap<array_variant_wrapper, T>
-      {};
-      template <class T>
-      array_variant(T) -> array_variant<T>; // Only needed on older compilers until we move to template alias deduction
-   } // namespace detail
+   // Output variants in the following format  ["variant_type", variant_json_data] with
+   // glz::detail:array_variant(&T::var);
+   template <is_variant T>
+   struct array_variant_wrapper final
+   {
+      T& value;
+   };
+   // TODO: Could do this if the compiler supports alias template deduction
+   // template <class T>
+   // using array_var = wrap<array_var_wrapper, T>;
+   template <class T>
+   struct array_variant : wrap<array_variant_wrapper, T>
+   {};
+   template <class T>
+   array_variant(T) -> array_variant<T>; // Only needed on older compilers until we move to template alias deduction
 
    constexpr decltype(auto) conv_sv(auto&& value) noexcept
    {
@@ -855,132 +533,25 @@ namespace glz
       }
    }
 
-   constexpr auto array(auto&&... args) noexcept { return detail::Array{glz::tuplet::tuple{conv_sv(args)...}}; }
+   constexpr auto array(auto&&... args) noexcept { return detail::Array{glz::tuple{conv_sv(args)...}}; }
 
-   constexpr auto object(auto&&... args) noexcept
+   template <class... Args>
+   constexpr auto object(Args&&... args) noexcept
    {
-      if constexpr (sizeof...(args) == 0) {
-         return glz::detail::Object{glz::tuplet::tuple{}};
-      }
-      else {
-         using Tuple = std::decay_t<decltype(glz::tuplet::tuple{conv_sv(args)...})>;
-         return glz::detail::Object{group_builder<Tuple>::op(glz::tuplet::tuple{conv_sv(args)...})};
-      }
+      return detail::Object{tuple{std::forward<Args>(args)...}};
    }
 
-   constexpr auto enumerate(auto&&... args) noexcept
-   {
-      using Tuple = std::decay_t<decltype(glz::tuplet::tuple{conv_sv(args)...})>;
-      return glz::detail::Enum{group_builder<Tuple>::op(glz::tuplet::tuple{conv_sv(args)...})};
-   }
+   constexpr auto enumerate(auto&&... args) noexcept { return detail::Enum{tuple{args...}}; }
 
-   // A faster compiling version of enumerate that does not support reflection
-   constexpr auto enumerate_no_reflect(auto&&... args) noexcept
-   {
-      return [t = glz::tuplet::tuple{args...}]<size_t... I>(std::index_sequence<I...>) noexcept {
-         return glz::detail::Enum{std::array{pair{conv_sv(get<2 * I>(t)), get<2 * I + 1>(t)}...}};
-      }(std::make_index_sequence<sizeof...(args) / 2>{});
-   }
-
-   constexpr auto flags(auto&&... args) noexcept
-   {
-      using Tuple = std::decay_t<decltype(glz::tuplet::tuple{conv_sv(args)...})>;
-      return glz::detail::Flags{group_builder<Tuple>::op(glz::tuplet::tuple{conv_sv(args)...})};
-   }
-
-   template <detail::glaze_flags_t T>
-   consteval auto byte_length() noexcept
-   {
-      constexpr auto N = glz::tuple_size_v<meta_t<T>>;
-
-      if constexpr (N % 8 == 0) {
-         return N / 8;
-      }
-      else {
-         return (N / 8) + 1;
-      }
-   }
+   constexpr auto flags(auto&&... args) noexcept { return detail::Flags{tuple{args...}}; }
 }
 
-namespace glz
-{
-   template <class T>
-   inline constexpr auto reflection_count = [] {
-      if constexpr (detail::reflectable<T>) {
-         return detail::count_members<T>;
-      }
-      else {
-         return glz::tuple_size_v<meta_t<T>>;
-      }
-   }();
-}
-
-template <>
-struct glz::meta<glz::error_code>
-{
-   static constexpr sv name = "glz::error_code";
-   using enum glz::error_code;
-   static constexpr auto value =
-      enumerate_no_reflect("none", none, //
-                           "no_read_input", no_read_input, //
-                           "data_must_be_null_terminated", data_must_be_null_terminated, //
-                           "parse_number_failure", parse_number_failure, //
-                           "expected_brace", expected_brace, //
-                           "expected_bracket", expected_bracket, //
-                           "expected_quote", expected_quote, //
-                           "expected_comma", expected_comma, //
-                           "expected_colon", expected_colon, //
-                           "exceeded_static_array_size", exceeded_static_array_size, //
-                           "unexpected_end", unexpected_end, //
-                           "expected_end_comment", expected_end_comment, //
-                           "syntax_error", syntax_error, //
-                           "key_not_found", key_not_found, //
-                           "unexpected_enum", unexpected_enum, //
-                           "attempt_const_read", attempt_const_read, //
-                           "attempt_member_func_read", attempt_member_func_read, //
-                           "attempt_read_hidden", attempt_read_hidden, //
-                           "invalid_nullable_read", invalid_nullable_read, //
-                           "invalid_variant_object", invalid_variant_object, //
-                           "invalid_variant_array", invalid_variant_array, //
-                           "invalid_variant_string", invalid_variant_string, //
-                           "no_matching_variant_type", no_matching_variant_type, //
-                           "expected_true_or_false", expected_true_or_false, //
-                           "unknown_key", unknown_key, //
-                           "invalid_flag_input", invalid_flag_input, //
-                           "invalid_escape", invalid_escape, //
-                           "u_requires_hex_digits", u_requires_hex_digits, //
-                           "file_extension_not_supported", file_extension_not_supported, //
-                           "could_not_determine_extension", could_not_determine_extension, //
-                           "seek_failure", seek_failure, //
-                           "unicode_escape_conversion_failure", unicode_escape_conversion_failure, //
-                           "file_open_failure", file_open_failure, //
-                           "file_close_failure", file_close_failure, //
-                           "file_include_error", file_include_error, //
-                           "dump_int_error", dump_int_error, //
-                           "get_nonexistent_json_ptr", get_nonexistent_json_ptr, //
-                           "get_wrong_type", get_wrong_type, //
-                           "cannot_be_referenced", cannot_be_referenced, //
-                           "invalid_get", invalid_get, //
-                           "invalid_get_fn", invalid_get_fn, //
-                           "invalid_call", invalid_call, //
-                           "invalid_partial_key", invalid_partial_key, //
-                           "name_mismatch", name_mismatch, //
-                           "array_element_not_found", array_element_not_found, //
-                           "elements_not_convertible_to_design", elements_not_convertible_to_design, //
-                           "unknown_distribution", unknown_distribution, //
-                           "invalid_distribution_elements", invalid_distribution_elements, //
-                           "missing_key", missing_key, //
-                           "hostname_failure", hostname_failure, //
-                           "includer_error", includer_error //
-      );
-};
-
 namespace glz
 {
    // This wraps glz::expected error (unexpected) values in an object with an "error" key
    // This makes them discernable from the expected value
    template <class T>
-   struct unexpected_wrapper
+   struct unexpected_wrapper final
    {
       T* unexpected;
 
@@ -993,208 +564,19 @@ namespace glz
 
    template <class T>
    unexpected_wrapper(T*) -> unexpected_wrapper<T>;
-}
-
-namespace glz
-{
-   template <auto Enum>
-      requires(std::is_enum_v<decltype(Enum)>)
-   constexpr sv enum_name_v = []() -> std::string_view {
-      using T = std::decay_t<decltype(Enum)>;
-
-      if constexpr (detail::glaze_t<T>) {
-         using U = std::underlying_type_t<T>;
-         return detail::get_enum_key<T, static_cast<U>(Enum)>();
-      }
-      else {
-         static_assert(false_v<decltype(Enum)>, "Enum requires glaze metadata for name");
-      }
-   }();
-
-   [[nodiscard]] inline std::string format_error(const error_ctx& pe, const auto& buffer)
-   {
-      static constexpr auto arr = detail::make_enum_to_string_array<error_code>();
-      const auto error_type_str = arr[uint32_t(pe.ec)];
-
-      const auto info = detail::get_source_info(buffer, pe.location);
-      auto error_str = detail::generate_error_string(error_type_str, info);
-      if (pe.includer_error.size()) {
-         error_str.append(pe.includer_error);
-      }
-      return error_str;
-   }
-
-   template <class T>
-   [[nodiscard]] std::string format_error(const expected<T, error_ctx>& pe, const auto& buffer)
-   {
-      if (not pe) {
-         return format_error(pe.error(), buffer);
-      }
-      else {
-         return "";
-      }
-   }
 
-   [[nodiscard]] inline std::string format_error(const error_ctx& pe)
+   template <auto Opts, class Value>
+   [[nodiscard]] GLZ_ALWAYS_INLINE constexpr bool skip_member(const Value& value) noexcept
    {
-      static constexpr auto arr = detail::make_enum_to_string_array<error_code>();
-      return std::string{std::string_view{arr[uint32_t(pe.ec)]}};
-   }
-
-   template <class T>
-   [[nodiscard]] std::string format_error(const expected<T, error_ctx>& pe)
-   {
-      if (not pe) {
-         return format_error(pe.error());
-      }
-      else {
-         return "";
-      }
-   }
-}
-
-namespace glz::detail
-{
-   // This useless code and the inclusion of N is required for MSVC to build, but not Clang or GCC
-   template <size_t I, size_t N, class T>
-   struct glaze_tuple_element
-   {
-      using V = std::decay_t<T>;
-      using Item = tuplet::tuple<>;
-      using T0 = T;
-      static constexpr bool use_reflection = false; // for member object reflection
-      static constexpr size_t member_index = 0;
-      using mptr_t = T;
-      using type = T;
-   };
-
-   // This shouldn't need the requires or the N template paramter, except for the current MSVC
-   template <size_t I, size_t N, class T>
-      requires(N > 0 && !reflectable<T>)
-   struct glaze_tuple_element<I, N, T>
-   {
-      using V = std::decay_t<T>;
-      using Item = std::decay_t<decltype(glz::get<I>(meta_v<V>))>;
-      using T0 = std::decay_t<glz::tuple_element_t<0, Item>>;
-      static constexpr bool use_reflection = std::is_member_pointer_v<T0>; // for member object reflection
-      static constexpr size_t member_index = use_reflection ? 0 : 1;
-      using mptr_t = std::decay_t<glz::tuple_element_t<member_index, Item>>;
-      using type = member_t<V, mptr_t>;
-   };
-
-   template <size_t I, size_t N, reflectable T>
-      requires(N > 0)
-   struct glaze_tuple_element<I, N, T>
-   {
-      using V = std::decay_t<T>;
-      static constexpr bool use_reflection = false; // for member object reflection
-      static constexpr size_t member_index = 0;
-      using Item = decltype(to_tuple(std::declval<T>()));
-      using mptr_t = glz::tuple_element_t<I, Item>;
-      using type = member_t<V, mptr_t>;
-      using T0 = mptr_t;
-   };
-
-   template <size_t I, size_t N, class T>
-   using glaze_tuple_element_t = typename glaze_tuple_element<I, N, T>::type;
-
-   template <auto Opts, class T>
-   struct object_type_info
-   {
-      static constexpr auto N = reflection_count<T>;
-
-      // Allows us to remove a branch if the first item will always be written
-      static constexpr bool first_will_be_written = [] {
-         if constexpr (N > 0) {
-            using Element = glaze_tuple_element<0, N, T>;
-            using V = std::remove_cvref_t<typename Element::type>;
-
-            if constexpr (null_t<V> && Opts.skip_null_members) {
-               return false;
-            }
-
-            if constexpr (is_includer<V> || std::same_as<V, hidden> || std::same_as<V, skip>) {
-               return false;
-            }
-            else {
-               return true;
-            }
-         }
-         else {
-            return false;
-         }
-      }();
-
-      static constexpr bool maybe_skipped = [] {
-         if constexpr (N > 0) {
-            bool found_maybe_skipped{};
-            for_each_short_circuit<N>([&](auto I) {
-               using Element = glaze_tuple_element<I, N, T>;
-               using V = std::remove_cvref_t<typename Element::type>;
-
-               if constexpr (Opts.skip_null_members && null_t<V>) {
-                  found_maybe_skipped = true;
-                  return true; // early exit
-               }
-
-               if constexpr (is_includer<V> || std::same_as<V, hidden> || std::same_as<V, skip>) {
-                  found_maybe_skipped = true;
-                  return true; // early exit
-               }
-               return false; // continue
-            });
-            return found_maybe_skipped;
-         }
-         else {
-            return false;
-         }
-      }();
-   };
-
-   template <size_t I, class T, bool use_reflection>
-   constexpr auto key_name = [] {
-      if constexpr (reflectable<T>) {
-         return get<I>(member_names<T>);
-      }
-      else {
-         using V = std::decay_t<T>;
-         if constexpr (use_reflection) {
-            return get_name<get<0>(get<I>(meta_v<V>))>();
-         }
+      if constexpr (null_t<Value> && Opts.skip_null_members) {
+         if constexpr (always_null_t<Value>)
+            return true;
          else {
-            return get<0>(get<I>(meta_v<V>));
+            return !bool(value);
          }
       }
-   }();
-
-   template <size_t I, class T>
-   constexpr auto key_name_v = [] {
-      if constexpr (reflectable<T>) {
-         return get<I>(member_names<T>);
-      }
       else {
-         using V = std::decay_t<T>;
-         if constexpr (glaze_tuple_element<I, reflection_count<T>, T>::use_reflection) {
-            return get_name<get<0>(get<I>(meta_v<V>))>();
-         }
-         else {
-            return get<0>(get<I>(meta_v<V>));
-         }
-      }
-   }();
-
-   template <class T, auto Opts>
-   constexpr auto required_fields()
-   {
-      constexpr auto N = reflection_count<T>;
-
-      bit_array<N> fields{};
-      if constexpr (Opts.error_on_missing_keys) {
-         for_each<N>([&](auto I) constexpr {
-            using Element = glaze_tuple_element<I, N, T>;
-            fields[I] = !bool(Opts.skip_null_members) || !null_t<std::decay_t<typename Element::type>>;
-         });
+         return false;
       }
-      return fields;
    }
 }
diff --git a/deps/saucer/include/glaze/core/constraint.hpp b/deps/saucer/include/glaze/core/constraint.hpp
new file mode 100644
index 0000000..7817adb
--- /dev/null
+++ b/deps/saucer/include/glaze/core/constraint.hpp
@@ -0,0 +1,205 @@
+// Glaze Library
+// For the license information refer to glaze.hpp
+
+#pragma once
+
+#include "glaze/core/context.hpp"
+#include "glaze/core/opts.hpp"
+#include "glaze/tuplet/tuple.hpp"
+#include "glaze/util/string_literal.hpp"
+
+namespace glz
+{
+   // read_constraint allows a user to register a contraint lambda or member function
+   // that returns a boolean, which indicates true for success and false for failure
+   // this allows arguments to be validated
+   template <class T, auto Target, auto Constraint, string_literal Message>
+   struct read_constraint_t
+   {
+      static constexpr auto glaze_reflect = false;
+      static constexpr std::string_view message = Message;
+      using target_t = decltype(Target);
+      using constraint_t = decltype(Constraint);
+      T& val;
+      static constexpr auto target = Target;
+      static constexpr auto constraint = Constraint;
+   };
+
+   template <class T>
+   concept is_read_constraint = requires {
+      requires !T::glaze_reflect;
+      typename T::target_t;
+      typename T::constraint_t;
+   };
+
+   template <uint32_t Format, is_read_constraint T>
+   struct from<Format, T>
+   {
+      template <auto Opts>
+      static void op(auto&& value, is_context auto&& ctx, auto&& it, auto&& end)
+      {
+         using V = std::decay_t<decltype(value)>;
+         using Constraint = typename V::constraint_t;
+
+         auto assign_to_target = [&]<class Input>(Input&& input) {
+            using Target = typename V::target_t;
+            if constexpr (std::is_member_object_pointer_v<Target>) {
+               (value.val).*(value.target) = std::forward<Input>(input);
+            }
+            else if constexpr (std::invocable<Target, decltype(value.val)>) {
+               std::invoke(value.target, value.val) = std::forward<Input>(input);
+            }
+            else {
+               static_assert(false_v<Target>,
+                             "expected invocable function or member object pointer, perhaps you need const qualified "
+                             "input on your lambda");
+            }
+         };
+
+         if constexpr (std::is_member_pointer_v<Constraint>) {
+            if constexpr (std::is_member_function_pointer_v<Constraint>) {
+               using Ret = typename return_type<Constraint>::type;
+               if constexpr (std::same_as<Ret, bool>) {
+                  using Tuple = typename inputs_as_tuple<Constraint>::type;
+                  if constexpr (glz::tuple_size_v<Tuple> == 1) {
+                     std::decay_t<glz::tuple_element_t<0, Tuple>> input{};
+                     parse<Format>::template op<Opts>(input, ctx, it, end);
+                     if (bool(ctx.error)) [[unlikely]]
+                        return;
+                     auto success = (value.val.*(value.constraint))(input);
+                     if (not success) {
+                        ctx.error = error_code::constraint_violated;
+                        ctx.custom_error_message = V::message;
+                        return;
+                     }
+                     assign_to_target(std::move(input));
+                  }
+                  else {
+                     static_assert(false_v<T>, "function must have a single input");
+                  }
+               }
+               else {
+                  static_assert(false_v<T>, "function must return a boolean (true for success)");
+               }
+            }
+            else if constexpr (std::is_member_object_pointer_v<Constraint>) {
+               auto& constraint = value.val.*(value.constraint);
+               using Func = std::decay_t<decltype(constraint)>;
+               if constexpr (is_specialization_v<Func, std::function>) {
+                  using Ret = typename function_traits<Func>::result_type;
+
+                  if constexpr (std::same_as<Ret, bool>) {
+                     using Tuple = typename function_traits<Func>::arguments;
+                     if constexpr (glz::tuple_size_v<Tuple> == 1) {
+                        std::decay_t<glz::tuple_element_t<0, Tuple>> input{};
+                        parse<Format>::template op<Opts>(input, ctx, it, end);
+                        if (bool(ctx.error)) [[unlikely]]
+                           return;
+                        auto success = constraint(input);
+                        if (not success) {
+                           ctx.error = error_code::constraint_violated;
+                           ctx.custom_error_message = V::message;
+                           return;
+                        }
+                        assign_to_target(std::move(input));
+                     }
+                     else {
+                        static_assert(false_v<T>, "function must have a single input");
+                     }
+                  }
+                  else {
+                     static_assert(false_v<T>, "std::function must return a boolean (true for success)");
+                  }
+               }
+               else {
+                  static_assert(false_v<T>, "invalid type for read_constraint_t");
+               }
+            }
+            else {
+               static_assert(false_v<T>, "invalid type for read_constraint_t");
+            }
+         }
+         else {
+            if constexpr (is_invocable_concrete<Constraint>) {
+               using Ret = invocable_result_t<Constraint>;
+               if constexpr (std::same_as<Ret, bool>) {
+                  using Tuple = invocable_args_t<Constraint>;
+                  constexpr auto N = glz::tuple_size_v<Tuple>;
+                  if constexpr (N == 0) {
+                     static_assert(false_v<T>,
+                                   "lambda must take in the class as the first argument and the type to deserialize as "
+                                   "the second");
+                  }
+                  else if constexpr (N == 2) {
+                     std::decay_t<glz::tuple_element_t<1, Tuple>> input{};
+                     parse<Format>::template op<Opts>(input, ctx, it, end);
+                     if (bool(ctx.error)) [[unlikely]]
+                        return;
+                     auto success = value.constraint(value.val, input);
+                     if (not success) {
+                        ctx.error = error_code::constraint_violated;
+                        ctx.custom_error_message = V::message;
+                        return;
+                     }
+                     assign_to_target(std::move(input));
+                  }
+                  else {
+                     static_assert(false_v<T>, "lambda must have two inputs, the class and the type to deserialize");
+                  }
+               }
+               else {
+                  static_assert(false_v<T>, "lambda must return a boolean (true for success)");
+               }
+            }
+            else {
+               static_assert(
+                  false_v<T>,
+                  "IMPORTANT: Two arguments are required in your lambda (e.g. [](my_struct&, const std::string& "
+                  "input)) you must make all the arguments concrete types. None of the inputs can be `auto`. Also, "
+                  "you probably cannot define these lambdas within a local `struct glaze`, but instead need to use "
+                  "`glz::meta` outside your class so that your lambda can operate on a defined class.");
+            }
+         }
+      }
+   };
+
+   template <uint32_t Format, is_read_constraint T>
+   struct to<Format, T>
+   {
+      template <auto Opts>
+      static void op(auto&& value, is_context auto&& ctx, auto&&... args)
+      {
+         using V = std::decay_t<decltype(value)>;
+         using Target = typename V::target_t;
+
+         if constexpr (std::is_member_pointer_v<Target>) {
+            if constexpr (std::is_member_object_pointer_v<Target>) {
+               auto& target = value.val.*(value.target);
+               serialize<Format>::template op<Opts>(target, ctx, args...);
+            }
+            else {
+               static_assert(false_v<T>, "invalid type for read_constraint_t");
+            }
+         }
+         else {
+            if constexpr (std::invocable<Target, decltype(value.val)>) {
+               serialize<Format>::template op<Opts>(std::invoke(value.target, value.val), ctx, args...);
+            }
+            else {
+               static_assert(false_v<Target>,
+                             "expected invocable function, perhaps you need const qualified input on your lambda");
+            }
+         }
+      }
+   };
+
+   template <auto Target, auto Constraint, string_literal Message>
+   constexpr auto read_constraint_impl() noexcept
+   {
+      return
+         [](auto&& v) { return read_constraint_t<std::remove_cvref_t<decltype(v)>, Target, Constraint, Message>{v}; };
+   }
+
+   template <auto Target, auto Constraint, string_literal Message>
+   constexpr auto read_constraint = read_constraint_impl<Target, Constraint, Message>();
+}
diff --git a/deps/saucer/include/glaze/core/context.hpp b/deps/saucer/include/glaze/core/context.hpp
index 24b4c30..18ca34d 100644
--- a/deps/saucer/include/glaze/core/context.hpp
+++ b/deps/saucer/include/glaze/core/context.hpp
@@ -10,63 +10,92 @@
 
 namespace glz
 {
-   enum class error_code : uint32_t {
-      none,
-      no_read_input,
-      data_must_be_null_terminated,
-      parse_number_failure,
-      expected_brace,
-      expected_bracket,
-      expected_quote,
-      expected_comma,
-      expected_colon,
-      exceeded_static_array_size,
-      unexpected_end,
-      expected_end_comment,
-      syntax_error,
-      key_not_found,
-      unexpected_enum,
-      attempt_const_read,
-      attempt_member_func_read,
-      attempt_read_hidden,
-      invalid_nullable_read,
-      invalid_variant_object,
-      invalid_variant_array,
-      invalid_variant_string,
-      no_matching_variant_type,
-      expected_true_or_false,
-      unknown_key,
-      invalid_flag_input,
-      invalid_escape,
-      u_requires_hex_digits,
-      file_extension_not_supported,
-      could_not_determine_extension,
-      seek_failure,
-      unicode_escape_conversion_failure,
-      file_open_failure,
-      file_close_failure,
-      file_include_error,
-      dump_int_error,
-      get_nonexistent_json_ptr,
-      get_wrong_type,
-      cannot_be_referenced,
-      invalid_get,
-      invalid_get_fn,
-      invalid_call,
-      invalid_partial_key,
-      name_mismatch,
-      array_element_not_found,
-      elements_not_convertible_to_design,
-      unknown_distribution,
-      invalid_distribution_elements,
-      missing_key,
-      hostname_failure,
-      includer_error
+   inline constexpr size_t max_recursive_depth_limit = 256;
+
+   enum struct error_code : uint32_t {
+      // REPE compliant error codes
+      none, //
+      version_mismatch,
+      invalid_header,
+      invalid_query,
+      invalid_body,
+      parse_error,
+      method_not_found,
+      timeout,
+      send_error,
+      connection_failure,
+      // Other errors
+      end_reached, // A non-error code for non-null terminated input buffers
+      partial_read_complete, // A non-error code for short circuiting partial reads
+      no_read_input, //
+      data_must_be_null_terminated, //
+      parse_number_failure, //
+      expected_brace, //
+      expected_bracket, //
+      expected_quote, //
+      expected_comma, //
+      expected_colon, //
+      exceeded_static_array_size, //
+      exceeded_max_recursive_depth, //
+      unexpected_end, //
+      expected_end_comment, //
+      syntax_error, //
+      unexpected_enum, //
+      attempt_const_read, //
+      attempt_member_func_read, //
+      attempt_read_hidden, //
+      invalid_nullable_read, //
+      invalid_variant_object, //
+      invalid_variant_array, //
+      invalid_variant_string, //
+      no_matching_variant_type, //
+      expected_true_or_false, //
+      constraint_violated, //
+      // Key errors
+      key_not_found, //
+      unknown_key, //
+      missing_key, //
+      // Other errors
+      invalid_flag_input, //
+      invalid_escape, //
+      u_requires_hex_digits, //
+      unicode_escape_conversion_failure, //
+      dump_int_error, //
+      // File errors
+      file_open_failure, //
+      file_close_failure, //
+      file_include_error, //
+      file_extension_not_supported, //
+      could_not_determine_extension, //
+      // JSON pointer access errors
+      get_nonexistent_json_ptr, //
+      get_wrong_type, //
+      seek_failure, //
+      // Other errors
+      cannot_be_referenced, //
+      invalid_get, //
+      invalid_get_fn, //
+      invalid_call, //
+      invalid_partial_key, //
+      name_mismatch, //
+      array_element_not_found, //
+      elements_not_convertible_to_design, //
+      unknown_distribution, //
+      invalid_distribution_elements, //
+      hostname_failure, //
+      includer_error, //
+      // Feature support
+      feature_not_supported //
    };
 
    struct error_ctx final
    {
       error_code ec{};
+      // Glaze uses the custom_error_message for some error reporting
+      // But, since the first error always short-circuits parsing, developers are free to inject
+      // their own errors in the custom_error_message.
+      std::string_view custom_error_message{};
+      // INTERNAL USE:
       size_t location{};
       std::string_view includer_error{}; // error from a nested file includer
 
@@ -79,11 +108,16 @@ namespace glz
    // We do not template the context on iterators so that it can be easily shared across buffer implementations
    struct context final
    {
-      // INTERNAL USE
-      uint32_t indentation_level{};
-      std::string current_file; // top level file path
-      std::string_view includer_error{}; // error from a nested file includer
       error_code error{};
+      std::string_view custom_error_message;
+      // INTERNAL USE:
+      uint32_t indentation_level{}; // When writing this is the number of indent character to serialize
+      // When reading indentation_level is used to track the depth of structures to prevent stack overflows
+      // From massive depths due to untrusted inputs or attacks
+      std::string current_file; // top level file path
+      std::string_view includer_error; // error from a nested file includer
+      // NOTE: The default constructor is valid for std::string_view, so we use this rather than {}
+      // because debuggers like jumping to std::string_view initialization calls
    };
 
    template <class T>
diff --git a/deps/saucer/include/glaze/core/convert_struct.hpp b/deps/saucer/include/glaze/core/convert_struct.hpp
new file mode 100644
index 0000000..988ba50
--- /dev/null
+++ b/deps/saucer/include/glaze/core/convert_struct.hpp
@@ -0,0 +1,49 @@
+// Glaze Library
+// For the license information refer to glaze.hpp
+
+#pragma once
+
+#include "glaze/core/common.hpp"
+#include "glaze/core/reflect.hpp"
+
+namespace glz
+{
+   /**
+    * @brief Provides generic struct to struct conversion based on reflected fields.
+    *
+    * Uses reflected fields to perform a generic conversion from `In` to `Out`.
+    * Additional conversion rules can be added in the future, but optional like types are supported.
+    *
+    * @tparam In  Type of the input struct with optional fields.
+    * @tparam Out Type of the output struct with non-optional fields.
+    * @param[in] in   The input struct instance.
+    * @param[out] out The output struct instance to be populated.
+    */
+   template <class In, class Out>
+   void convert_struct(In&& in, Out&& out)
+   {
+      auto in_tuple = to_tie(std::forward<In>(in));
+      auto out_tuple = to_tie(std::forward<Out>(out));
+
+      constexpr auto N = tuple_size_v<std::decay_t<decltype(in_tuple)>>;
+      static_assert(N == tuple_size_v<std::decay_t<decltype(out_tuple)>>);
+
+      constexpr auto in_keys = reflect<In>::keys;
+      constexpr auto out_keys = reflect<Out>::keys;
+
+      for_each<N>([&]<auto I>() {
+         static_assert(in_keys[I] == out_keys[I]);
+         decltype(auto) l = get<I>(out_tuple);
+         decltype(auto) r = get<I>(in_tuple);
+         if constexpr (requires { l = r; }) {
+            l = r;
+         }
+         else if constexpr (requires { l = r.value(); }) {
+            l = r.value();
+         }
+         else {
+            static_assert(false_v<pair<In, Out>>, "Types are not convertible");
+         }
+      });
+   }
+}
diff --git a/deps/saucer/include/glaze/json/custom.hpp b/deps/saucer/include/glaze/core/custom.hpp
similarity index 76%
rename from deps/saucer/include/glaze/json/custom.hpp
rename to deps/saucer/include/glaze/core/custom.hpp
index 0c553ca..f2a1064 100644
--- a/deps/saucer/include/glaze/json/custom.hpp
+++ b/deps/saucer/include/glaze/core/custom.hpp
@@ -3,25 +3,24 @@
 
 #pragma once
 
+#include "glaze/core/read.hpp"
 #include "glaze/core/wrappers.hpp"
-#include "glaze/json/json_ptr.hpp"
-#include "glaze/json/read.hpp"
-#include "glaze/json/write.hpp"
+#include "glaze/core/write.hpp"
 
-namespace glz::detail
+namespace glz
 {
-   template <class T>
+   template <uint32_t Format, class T>
       requires(is_specialization_v<T, custom_t>)
-   struct from_json<T>
+   struct from<Format, T>
    {
       template <auto Opts>
-      GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, auto&& it, auto&& end) noexcept
+      static void op(auto&& value, is_context auto&& ctx, auto&& it, auto&& end)
       {
          using V = std::decay_t<decltype(value)>;
          using From = typename V::from_t;
 
          if constexpr (std::same_as<From, skip>) {
-            skip_value<Opts>(ctx, it, end);
+            skip_value<Format>::template op<Opts>(ctx, it, end);
          }
          else if constexpr (std::is_member_pointer_v<From>) {
             if constexpr (std::is_member_function_pointer_v<From>) {
@@ -36,10 +35,10 @@ namespace glz::detail
                   }
                   else if constexpr (glz::tuple_size_v<Tuple> == 1) {
                      std::decay_t<glz::tuple_element_t<0, Tuple>> input{};
-                     read<json>::op<Opts>(input, ctx, it, end);
+                     parse<Format>::template op<Opts>(input, ctx, it, end);
                      if (bool(ctx.error)) [[unlikely]]
                         return;
-                     (value.val.*(value.from))(input);
+                     (value.val.*(value.from))(std::move(input));
                   }
                   else {
                      static_assert(false_v<T>, "function cannot have more than one input");
@@ -65,10 +64,10 @@ namespace glz::detail
                      }
                      else if constexpr (glz::tuple_size_v<Tuple> == 1) {
                         std::decay_t<glz::tuple_element_t<0, Tuple>> input{};
-                        read<json>::op<Opts>(input, ctx, it, end);
+                        parse<Format>::template op<Opts>(input, ctx, it, end);
                         if (bool(ctx.error)) [[unlikely]]
                            return;
-                        from(input);
+                        from(std::move(input));
                      }
                      else {
                         static_assert(false_v<T>, "function cannot have more than one input");
@@ -79,7 +78,7 @@ namespace glz::detail
                   }
                }
                else {
-                  read<json>::op<Opts>(from, ctx, it, end);
+                  parse<Format>::template op<Opts>(from, ctx, it, end);
                }
             }
             else {
@@ -101,15 +100,18 @@ namespace glz::detail
                         return;
                      value.from(value.val);
                   }
-                  else if constexpr (N == 2) {
+                  else if constexpr (N > 1) {
                      std::decay_t<glz::tuple_element_t<1, Tuple>> input{};
-                     read<json>::op<Opts>(input, ctx, it, end);
+                     parse<Format>::template op<Opts>(input, ctx, it, end);
                      if (bool(ctx.error)) [[unlikely]]
                         return;
-                     value.from(value.val, input);
-                  }
-                  else {
-                     static_assert(false_v<T>, "lambda cannot have more than two inputs");
+                     if constexpr (N == 2) {
+                        value.from(value.val, std::move(input));
+                     }
+                     else {
+                        // Version that passes the glz::context for custom error handling
+                        value.from(value.val, std::move(input), ctx);
+                     }
                   }
                }
                else {
@@ -117,7 +119,10 @@ namespace glz::detail
                }
             }
             else if constexpr (std::invocable<From, decltype(value.val)>) {
-               read<json>::op<Opts>(value.from(value.val), ctx, it, end);
+               parse<Format>::template op<Opts>(value.from(value.val), ctx, it, end);
+            }
+            else if constexpr (std::invocable<From, decltype(value.val), context&>) {
+               parse<Format>::template op<Opts>(value.from(value.val, ctx), ctx, it, end);
             }
             else {
                static_assert(
@@ -131,12 +136,12 @@ namespace glz::detail
       }
    };
 
-   template <class T>
+   template <uint32_t Format, class T>
       requires(is_specialization_v<T, custom_t>)
-   struct to_json<T>
+   struct to<Format, T>
    {
       template <auto Opts>
-      GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, auto&&... args) noexcept
+      static void op(auto&& value, is_context auto&& ctx, auto&&... args)
       {
          using V = std::decay_t<decltype(value)>;
          using To = typename V::to_t;
@@ -145,7 +150,7 @@ namespace glz::detail
             if constexpr (std::is_member_function_pointer_v<To>) {
                using Tuple = typename inputs_as_tuple<To>::type;
                if constexpr (glz::tuple_size_v<Tuple> == 0) {
-                  write<json>::op<Opts>((value.val.*(value.to))(), ctx, args...);
+                  serialize<Format>::template op<Opts>((value.val.*(value.to))(), ctx, args...);
                }
                else {
                   static_assert(false_v<T>, "function cannot have inputs");
@@ -163,7 +168,7 @@ namespace glz::detail
                   else {
                      using Tuple = typename function_traits<Func>::arguments;
                      if constexpr (glz::tuple_size_v<Tuple> == 0) {
-                        write<json>::op<Opts>(to(), ctx, args...);
+                        serialize<Format>::template op<Opts>(to(), ctx, args...);
                      }
                      else {
                         static_assert(false_v<T>, "std::function cannot have inputs");
@@ -171,7 +176,7 @@ namespace glz::detail
                   }
                }
                else {
-                  write<json>::op<Opts>(to, ctx, args...);
+                  serialize<Format>::template op<Opts>(to, ctx, args...);
                }
             }
             else {
@@ -180,7 +185,10 @@ namespace glz::detail
          }
          else {
             if constexpr (std::invocable<To, decltype(value.val)>) {
-               write<json>::op<Opts>(std::invoke(value.to, value.val), ctx, args...);
+               serialize<Format>::template op<Opts>(std::invoke(value.to, value.val), ctx, args...);
+            }
+            else if constexpr (std::invocable<To, decltype(value.val), context&>) {
+               serialize<Format>::template op<Opts>(std::invoke(value.to, value.val, ctx), ctx, args...);
             }
             else {
                static_assert(false_v<To>,
diff --git a/deps/saucer/include/glaze/core/error_category.hpp b/deps/saucer/include/glaze/core/error_category.hpp
new file mode 100644
index 0000000..6b4262d
--- /dev/null
+++ b/deps/saucer/include/glaze/core/error_category.hpp
@@ -0,0 +1,173 @@
+// Glaze Library
+// For the license information refer to glaze.hpp
+
+#pragma once
+
+#include "glaze/core/context.hpp"
+#include "glaze/core/meta.hpp"
+
+template <>
+struct glz::meta<glz::error_code>
+{
+   static constexpr sv name = "glz::error_code";
+   using enum glz::error_code;
+   static constexpr std::array keys{"none",
+                                    "version_mismatch",
+                                    "invalid_header",
+                                    "invalid_query",
+                                    "invalid_body",
+                                    "parse_error",
+                                    "method_not_found",
+                                    "timeout",
+                                    "send_error",
+                                    "connection_failure",
+                                    "end_reached",
+                                    "partial_read_complete",
+                                    "no_read_input",
+                                    "data_must_be_null_terminated",
+                                    "parse_number_failure",
+                                    "expected_brace",
+                                    "expected_bracket",
+                                    "expected_quote",
+                                    "expected_comma",
+                                    "expected_colon",
+                                    "exceeded_static_array_size",
+                                    "exceeded_max_recursive_depth",
+                                    "unexpected_end",
+                                    "expected_end_comment",
+                                    "syntax_error",
+                                    "unexpected_enum",
+                                    "attempt_const_read",
+                                    "attempt_member_func_read",
+                                    "attempt_read_hidden",
+                                    "invalid_nullable_read",
+                                    "invalid_variant_object",
+                                    "invalid_variant_array",
+                                    "invalid_variant_string",
+                                    "no_matching_variant_type",
+                                    "expected_true_or_false",
+                                    "constraint_violated",
+                                    "key_not_found",
+                                    "unknown_key",
+                                    "missing_key",
+                                    "invalid_flag_input",
+                                    "invalid_escape",
+                                    "u_requires_hex_digits",
+                                    "unicode_escape_conversion_failure",
+                                    "dump_int_error",
+                                    "file_open_failure",
+                                    "file_close_failure",
+                                    "file_include_error",
+                                    "file_extension_not_supported",
+                                    "could_not_determine_extension",
+                                    "get_nonexistent_json_ptr",
+                                    "get_wrong_type",
+                                    "seek_failure",
+                                    "cannot_be_referenced",
+                                    "invalid_get",
+                                    "invalid_get_fn",
+                                    "invalid_call",
+                                    "invalid_partial_key",
+                                    "name_mismatch",
+                                    "array_element_not_found",
+                                    "elements_not_convertible_to_design",
+                                    "unknown_distribution",
+                                    "invalid_distribution_elements",
+                                    "hostname_failure",
+                                    "includer_error",
+                                    "feature_not_supported"};
+   static constexpr std::array value{none, //
+                                     version_mismatch, //
+                                     invalid_header, //
+                                     invalid_query, //
+                                     invalid_body, //
+                                     parse_error, //
+                                     method_not_found, //
+                                     timeout, //
+                                     send_error, //
+                                     connection_failure, //
+                                     end_reached, // A non-error code for non-null terminated input buffers
+                                     partial_read_complete,
+                                     no_read_input, //
+                                     data_must_be_null_terminated, //
+                                     parse_number_failure, //
+                                     expected_brace, //
+                                     expected_bracket, //
+                                     expected_quote, //
+                                     expected_comma, //
+                                     expected_colon, //
+                                     exceeded_static_array_size, //
+                                     exceeded_max_recursive_depth, //
+                                     unexpected_end, //
+                                     expected_end_comment, //
+                                     syntax_error, //
+                                     unexpected_enum, //
+                                     attempt_const_read, //
+                                     attempt_member_func_read, //
+                                     attempt_read_hidden, //
+                                     invalid_nullable_read, //
+                                     invalid_variant_object, //
+                                     invalid_variant_array, //
+                                     invalid_variant_string, //
+                                     no_matching_variant_type, //
+                                     expected_true_or_false, //
+                                     constraint_violated, //
+                                     // Key errors
+                                     key_not_found, //
+                                     unknown_key, //
+                                     missing_key, //
+                                     // Other errors
+                                     invalid_flag_input, //
+                                     invalid_escape, //
+                                     u_requires_hex_digits, //
+                                     unicode_escape_conversion_failure, //
+                                     dump_int_error, //
+                                     // File errors
+                                     file_open_failure, //
+                                     file_close_failure, //
+                                     file_include_error, //
+                                     file_extension_not_supported, //
+                                     could_not_determine_extension, //
+                                     // JSON pointer access errors
+                                     get_nonexistent_json_ptr, //
+                                     get_wrong_type, //
+                                     seek_failure, //
+                                     // Other errors
+                                     cannot_be_referenced, //
+                                     invalid_get, //
+                                     invalid_get_fn, //
+                                     invalid_call, //
+                                     invalid_partial_key, //
+                                     name_mismatch, //
+                                     array_element_not_found, //
+                                     elements_not_convertible_to_design, //
+                                     unknown_distribution, //
+                                     invalid_distribution_elements, //
+                                     hostname_failure, //
+                                     includer_error, //
+                                     feature_not_supported};
+};
+
+#include <system_error>
+
+namespace glz
+{
+   struct glaze_error_category : public std::error_category
+   {
+      const char* name() const noexcept override { return "glaze"; }
+
+      std::string message(int ev) const override { return {meta<error_code>::keys[uint32_t(ev)]}; }
+   };
+
+   inline glaze_error_category error_category{};
+
+   inline std::error_code make_error_code(error_code e) { return {static_cast<int>(e), error_category}; }
+}
+
+// Make Glaze error_code compatible with std::error_code
+namespace std
+{
+   template <>
+   struct is_error_code_enum<glz::error_code> : true_type
+   {};
+}
diff --git a/deps/saucer/include/glaze/core/feature_test.hpp b/deps/saucer/include/glaze/core/feature_test.hpp
new file mode 100644
index 0000000..3b4f3d7
--- /dev/null
+++ b/deps/saucer/include/glaze/core/feature_test.hpp
@@ -0,0 +1,35 @@
+// Glaze Library
+// For the license information refer to glaze.hpp
+
+#pragma once
+
+// Glaze Feature Test Macros for breaking changes
+
+// v5.2.0 Moves `layout` CSV option into glz::opts_csv
+#define glaze_v5_2_0_opts_csv
+
+// v5.1.0 swaps the template parameters of read_supported/write_supported to enable cleaner concepts and usage
+#define glaze_v5_1_0_supported_swap
+
+// v5.0.0 removes many internal functions and concepts out of the detail namespace to enable cleaner customization
+#define glaze_v5_0_0
+// v5.0.0 moves to more generic read_supported and write_supported concepts
+// removes concepts like `read_json_supported` and uses `read_supported<JSON, T>`
+#define glaze_v5_0_0_generic_supported
+// v5.0.0 makes glz::opts the default options and moves some of the compile time options out of the struct
+#define glaze_v5_0_0_customized_opts
+
+// v4.3.0 removed global glz::trace
+#define glaze_v4_3_0_trace
+
+// v4.2.3 renamed glz::tuplet::tuple to glz::tuple
+#define glaze_v4_2_3_tuple
+
+// v3.6.0 renames glz::refl to glz::reflect and does not instantiate the struct as an
+// inline constexpr variable
+#define glaze_v3_6_0_reflect
+
+// v3.5.0 change glz::detail::to_json and glz::detail::from_json specializations
+// to glz::to<JSON and glz::from<JSON
+// The template specialization takes a uint32_t Format as the first template parameter
+#define glaze_v3_5_0_to_from
diff --git a/deps/saucer/include/glaze/core/manage.hpp b/deps/saucer/include/glaze/core/manage.hpp
new file mode 100644
index 0000000..9659fa1
--- /dev/null
+++ b/deps/saucer/include/glaze/core/manage.hpp
@@ -0,0 +1,129 @@
+// Glaze Library
+// For the license information refer to glaze.hpp
+
+#pragma once
+
+#include "glaze/core/common.hpp"
+
+// Calls a read function after reading and calls a write function before writing.
+// glz::manage is useful for transforming state from a user facing format
+// into a more complex or esoteric internal format.
+
+namespace glz
+{
+   // manage_t invokes a function call before reading and after writing from a value
+   template <class T, class Member, class From, class To>
+   struct manage_t
+   {
+      static constexpr auto glaze_reflect = false;
+      using from_t = From;
+      using to_t = To;
+      T& val;
+      Member member;
+      From from;
+      To to;
+   };
+
+   template <class T, class Member, class From, class To>
+   manage_t(T&, Member, From, To) -> manage_t<T, Member, From, To>;
+
+   template <uint32_t Format, class T>
+      requires(is_specialization_v<T, manage_t>)
+   struct from<Format, T>
+   {
+      template <auto Opts>
+      static void op(auto&& value, is_context auto&& ctx, auto&& it, auto&& end)
+      {
+         using V = std::decay_t<decltype(value)>;
+         using From = typename V::from_t;
+
+         parse<Format>::template op<Opts>(get_member(value.val, value.member), ctx, it, end);
+
+         if constexpr (std::is_member_pointer_v<From>) {
+            if constexpr (std::is_member_function_pointer_v<From>) {
+               if (!(value.val.*(value.from))()) {
+                  ctx.error = error_code::syntax_error;
+                  return;
+               }
+            }
+            else if constexpr (std::is_member_object_pointer_v<From>) {
+               auto& from = value.val.*(value.from);
+               using Func = std::decay_t<decltype(from)>;
+               if constexpr (std::is_invocable_r_v<bool, Func>) {
+                  if (!value.from()) {
+                     ctx.error = error_code::syntax_error;
+                     return;
+                  }
+               }
+               else {
+                  static_assert(false_v<T>, "function must have no arguments with a bool return");
+               }
+            }
+            else {
+               static_assert(false_v<T>, "invalid type");
+            }
+         }
+         else {
+            if (!value.from(value.val)) {
+               ctx.error = error_code::syntax_error;
+               return;
+            }
+         }
+      }
+   };
+
+   template <uint32_t Format, class T>
+      requires(is_specialization_v<T, manage_t>)
+   struct to<Format, T>
+   {
+      template <auto Opts>
+      static void op(auto&& value, is_context auto&& ctx, auto&&... args)
+      {
+         using V = std::decay_t<decltype(value)>;
+         using To = typename V::to_t;
+
+         if constexpr (std::is_member_pointer_v<To>) {
+            if constexpr (std::is_member_function_pointer_v<To>) {
+               if (!(value.val.*(value.to))()) {
+                  ctx.error = error_code::syntax_error;
+                  return;
+               }
+            }
+            else if constexpr (std::is_member_object_pointer_v<To>) {
+               auto& to = value.val.*(value.to);
+               using Func = std::decay_t<decltype(to)>;
+               if constexpr (std::is_invocable_r_v<bool, Func>) {
+                  if (!value.to()) {
+                     ctx.error = error_code::syntax_error;
+                     return;
+                  }
+               }
+               else {
+                  static_assert(false_v<T>, "function must have no arguments with a bool return");
+               }
+            }
+            else {
+               static_assert(false_v<T>, "invalid type");
+            }
+         }
+         else {
+            if (!value.to(value.val)) {
+               ctx.error = error_code::syntax_error;
+               return;
+            }
+         }
+
+         using Value = core_t<decltype(get_member(value.val, value.member))>;
+         to<Format, Value>::template op<Opts>(get_member(value.val, value.member), ctx, args...);
+      }
+   };
+
+   template <auto Member, auto From, auto To>
+   inline constexpr decltype(auto) manage_impl()
+   {
+      return [](auto&& v) { return manage_t{v, Member, From, To}; };
+   }
+
+   template <auto Member, auto From, auto To>
+   constexpr auto manage = manage_impl<Member, From, To>();
+}
diff --git a/deps/saucer/include/glaze/core/meta.hpp b/deps/saucer/include/glaze/core/meta.hpp
index 49faf55..0325042 100644
--- a/deps/saucer/include/glaze/core/meta.hpp
+++ b/deps/saucer/include/glaze/core/meta.hpp
@@ -11,12 +11,21 @@
 #include "glaze/util/string_literal.hpp"
 #include "glaze/util/type_traits.hpp"
 #include "glaze/util/variant.hpp"
+#include "glaze/version.hpp"
 
 namespace glz
 {
+   enum struct operation { serialize, parse };
+
+   // The meta_context provides compile time data about the serialization context.
+   // This include whether we are serializing or parsing.
+   struct meta_context
+   {
+      operation op = operation::serialize;
+   };
+
    template <class T>
-   struct meta
-   {};
+   struct meta;
 
    template <>
    struct meta<std::string_view>
@@ -24,6 +33,12 @@ namespace glz
       static constexpr std::string_view name = "std::string_view";
    };
 
+   template <>
+   struct meta<const std::string_view>
+   {
+      static constexpr std::string_view name = "const std::string_view";
+   };
+
    template <class T>
    struct json_schema
    {};
@@ -65,49 +80,55 @@ namespace glz
 
       template <class T>
       Flags(T) -> Flags<T>;
+   }
 
-      template <class T>
-      concept local_construct_t = requires { T::glaze::construct; };
+   template <class T>
+   concept local_construct_t = requires { T::glaze::construct; };
 
-      template <class T>
-      concept global_construct_t = requires { meta<T>::construct; };
+   template <class T>
+   concept global_construct_t = requires { meta<T>::construct; };
 
-      template <class T>
-      concept local_meta_t = requires { T::glaze::value; };
+   template <class T>
+   concept local_meta_t = requires { T::glaze::value; };
 
-      template <class T>
-      concept global_meta_t = requires { meta<T>::value; };
+   template <class T>
+   concept local_keys_t = requires { T::glaze::keys; };
 
-      template <class T>
-      concept glaze_t = requires { meta<std::decay_t<T>>::value; } || local_meta_t<std::decay_t<T>>;
+   template <class T>
+   concept global_meta_t = requires { meta<T>::value; };
 
-      template <class T>
-      concept has_unknown_writer = requires { meta<T>::unknown_write; } || requires { T::glaze::unknown_write; };
+   template <class T>
+   concept glaze_t = requires { meta<std::decay_t<T>>::value; } || local_meta_t<std::decay_t<T>>;
 
-      template <class T>
-      concept has_unknown_reader = requires { meta<T>::unknown_read; } || requires { T::glaze::unknown_read; };
+   template <class T>
+   concept meta_keys = requires { meta<std::decay_t<T>>::keys; } || local_keys_t<std::decay_t<T>>;
 
-      template <class T>
-      concept local_json_schema_t = requires { typename std::decay_t<T>::glaze_json_schema; };
+   template <class T>
+   concept has_unknown_writer = requires { meta<T>::unknown_write; } || requires { T::glaze::unknown_write; };
 
-      template <class T>
-      concept global_json_schema_t = requires { is_specialization_v<std::decay_t<T>, json_schema>; };
+   template <class T>
+   concept has_unknown_reader = requires { meta<T>::unknown_read; } || requires { T::glaze::unknown_read; };
 
-      template <class T>
-      concept json_schema_t = local_json_schema_t<T> || global_json_schema_t<T>;
-   }
+   template <class T>
+   concept local_json_schema_t = requires { typename std::decay_t<T>::glaze_json_schema; };
+
+   template <class T>
+   concept global_json_schema_t = requires { typename json_schema<T>; };
+
+   template <class T>
+   concept json_schema_t = local_json_schema_t<T> || global_json_schema_t<T>;
 
    struct empty
    {
-      static constexpr glz::tuplet::tuple<> value{};
+      static constexpr glz::tuple<> value{};
    };
 
    template <class T>
    inline constexpr decltype(auto) meta_wrapper_v = [] {
-      if constexpr (detail::local_meta_t<T>) {
+      if constexpr (local_meta_t<T>) {
          return T::glaze::value;
       }
-      else if constexpr (detail::global_meta_t<T>) {
+      else if constexpr (global_meta_t<T>) {
          return meta<T>::value;
       }
       else {
@@ -117,10 +138,10 @@ namespace glz
 
    template <class T>
    inline constexpr auto meta_construct_v = [] {
-      if constexpr (detail::local_construct_t<T>) {
+      if constexpr (local_construct_t<T>) {
          return T::glaze::construct;
       }
-      else if constexpr (detail::global_construct_t<T>) {
+      else if constexpr (global_construct_t<T>) {
          return meta<T>::construct;
       }
       else {
@@ -129,7 +150,14 @@ namespace glz
    }();
 
    template <class T>
-   inline constexpr auto meta_v = meta_wrapper_v<decay_keep_volatile_t<T>>.value;
+   inline constexpr auto meta_v = []() -> decltype(auto) {
+      if constexpr (meta_keys<T>) {
+         return meta_wrapper_v<decay_keep_volatile_t<T>>;
+      }
+      else {
+         return meta_wrapper_v<decay_keep_volatile_t<T>>.value;
+      }
+   }();
 
    template <class T>
    using meta_t = decay_keep_volatile_t<decltype(meta_v<T>)>;
@@ -137,12 +165,28 @@ namespace glz
    template <class T>
    using meta_wrapper_t = decay_keep_volatile_t<decltype(meta_wrapper_v<std::decay_t<T>>)>;
 
+   template <class T>
+   inline constexpr auto meta_keys_v = [] {
+      if constexpr (local_meta_t<T>) {
+         return T::glaze::keys;
+      }
+      else if constexpr (global_meta_t<T>) {
+         return meta<T>::keys;
+      }
+      else {
+         static_assert(false_v<T>, "no keys or values provided");
+      }
+   }();
+
+   template <class T>
+   using meta_keys_t = decay_keep_volatile_t<decltype(meta_keys_v<T>)>;
+
    template <class T>
    struct remove_meta_wrapper
    {
       using type = T;
    };
-   template <detail::glaze_t T>
+   template <glaze_t T>
    struct remove_meta_wrapper<T>
    {
       using type = std::remove_pointer_t<std::remove_const_t<meta_wrapper_t<T>>>;
@@ -152,10 +196,10 @@ namespace glz
 
    template <class T>
    inline constexpr auto meta_unknown_write_v = [] {
-      if constexpr (detail::local_meta_t<T>) {
+      if constexpr (local_meta_t<T>) {
          return T::glaze::unknown_write;
       }
-      else if constexpr (detail::global_meta_t<T>) {
+      else if constexpr (global_meta_t<T>) {
          return meta<T>::unknown_write;
       }
       else {
@@ -168,10 +212,10 @@ namespace glz
 
    template <class T>
    inline constexpr auto meta_unknown_read_v = [] {
-      if constexpr (detail::local_meta_t<T>) {
+      if constexpr (local_meta_t<T>) {
          return T::glaze::unknown_read;
       }
-      else if constexpr (detail::global_meta_t<T>) {
+      else if constexpr (global_meta_t<T>) {
          return meta<T>::unknown_read;
       }
       else {
@@ -209,10 +253,16 @@ namespace glz
    template <class T>
    concept ided = requires { meta<std::decay_t<T>>::ids; } || requires { std::decay_t<T>::glaze::ids; };
 
+   // Concept when skip is specified for the type
+   template <class T>
+   concept meta_has_skip = requires(T t, const std::string_view s, const meta_context& mctx) {
+      { glz::meta<std::remove_cvref_t<T>>::skip(s, mctx) } -> std::same_as<bool>;
+   };
+
    template <class T>
    inline constexpr std::string_view tag_v = [] {
       if constexpr (tagged<T>) {
-         if constexpr (detail::local_meta_t<T>) {
+         if constexpr (local_meta_t<T>) {
             return std::decay_t<T>::glaze::tag;
          }
          else {
@@ -227,7 +277,8 @@ namespace glz
    namespace detail
    {
       template <class T, size_t N>
-      inline constexpr std::array<std::string_view, N> convert_ids_to_array_of_sv(const std::array<T, N>& arr)
+         requires(not std::integral<T>)
+      inline constexpr auto convert_ids_to_array(const std::array<T, N>& arr)
       {
          std::array<std::string_view, N> result;
          for (size_t i = 0; i < N; ++i) {
@@ -235,33 +286,42 @@ namespace glz
          }
          return result;
       }
+
+      template <class T, size_t N>
+         requires(std::integral<T>)
+      inline constexpr auto convert_ids_to_array(const std::array<T, N>& arr)
+      {
+         std::array<T, N> result;
+         for (size_t i = 0; i < N; ++i) {
+            result[i] = arr[i];
+         }
+         return result;
+      }
    }
 
    template <is_variant T>
    inline constexpr auto ids_v = [] {
       if constexpr (ided<T>) {
-         if constexpr (detail::local_meta_t<T>) {
-            return detail::convert_ids_to_array_of_sv(std::decay_t<T>::glaze::ids);
+         if constexpr (local_meta_t<T>) {
+            return detail::convert_ids_to_array(std::decay_t<T>::glaze::ids);
          }
          else {
-            return detail::convert_ids_to_array_of_sv(meta<std::decay_t<T>>::ids);
+            return detail::convert_ids_to_array(meta<std::decay_t<T>>::ids);
          }
       }
       else {
          constexpr auto N = std::variant_size_v<T>;
          std::array<std::string_view, N> ids{};
-         for_each<N>([&](auto I) { ids[I] = glz::name_v<std::decay_t<std::variant_alternative_t<I, T>>>; });
+         for_each<N>([&]<auto I>() { ids[I] = glz::name_v<std::decay_t<std::variant_alternative_t<I, T>>>; });
          return ids;
       }
    }();
 
-   using version_t = std::array<uint32_t, 3>;
-
    template <class T>
    concept versioned = requires { meta<std::decay_t<T>>::version; };
 
    template <class T>
-   inline constexpr version_t version = []() -> version_t {
+   inline constexpr version_t version_v = []() -> version_t {
       if constexpr (versioned<T>) {
          return meta<std::decay_t<T>>::version;
       }
@@ -270,12 +330,15 @@ namespace glz
       }
    }();
 
-   template <class T>
-   inline constexpr auto json_schema_v = [] {
-      if constexpr (detail::local_json_schema_t<T>) {
+   // We don't make this constexpr so that we can have heap allocated values like std::string
+   // IMPORTANT: GCC has a bug that doesn't default instantiate this object when it isn't constexpr
+   // The solution is to use the json_schema_type defined below to instantiate where used.
+   template <json_schema_t T>
+   inline const auto json_schema_v = [] {
+      if constexpr (local_json_schema_t<T>) {
          return typename std::decay_t<T>::glaze_json_schema{};
       }
-      else if constexpr (detail::global_json_schema_t<T>) {
+      else if constexpr (global_json_schema_t<T>) {
          return json_schema<std::decay_t<T>>{};
       }
    }();
@@ -290,7 +353,4 @@ namespace glz
 
    template <class T>
    concept custom_write = requires { requires meta<T>::custom_write == true; };
-
-   template <class T>
-   concept is_partial_read = requires { requires meta<T>::partial_read == true; };
 }
diff --git a/deps/saucer/include/glaze/core/opts.hpp b/deps/saucer/include/glaze/core/opts.hpp
index 2f6a21b..5b403e6 100644
--- a/deps/saucer/include/glaze/core/opts.hpp
+++ b/deps/saucer/include/glaze/core/opts.hpp
@@ -9,295 +9,531 @@
 
 namespace glz
 {
-   // format
-   constexpr uint32_t binary = 0;
-   constexpr uint32_t json = 10;
-   constexpr uint32_t ndjson = 100; // new line delimited JSON
-   constexpr uint32_t csv = 10000;
+   // Formats
+   // Built in formats must be less than 65536
+   // User defined formats can be 65536 to 4294967296
+   inline constexpr uint32_t INVALID = 0;
+   inline constexpr uint32_t BEVE = 1;
+   inline constexpr uint32_t JSON = 10;
+   inline constexpr uint32_t JSON_PTR = 20;
+   inline constexpr uint32_t NDJSON = 100; // new line delimited JSON
+   inline constexpr uint32_t TOML = 400;
+   inline constexpr uint32_t STENCIL = 500;
+   inline constexpr uint32_t MUSTACHE = 501;
+   inline constexpr uint32_t CSV = 10000;
+   inline constexpr uint32_t EETF = 20000;
+
+   // Protocol formats
+   inline constexpr uint32_t REPE = 30000;
+   inline constexpr uint32_t REST = 30100;
 
    // layout
-   constexpr uint32_t rowwise = 0;
-   constexpr uint32_t colwise = 1;
-
-   enum struct float_precision : uint8_t { full, float32 = 4, float64 = 8, float128 = 16 };
+   inline constexpr uint8_t rowwise = 0;
+   inline constexpr uint8_t colwise = 1;
+
+   enum struct float_precision : uint8_t { //
+      full, //
+      float32 = 4, //
+      float64 = 8, //
+      float128 = 16 //
+   };
 
    // We use 16 padding bytes because surrogate unicode pairs require 12 bytes
    // and we want a power of 2 buffer
-   constexpr uint32_t padding_bytes = 16;
+   inline constexpr uint32_t padding_bytes = 16;
 
    // Write padding bytes simplifies our dump calculations by making sure we have significant excess
-   constexpr uint32_t write_padding_bytes = 256;
+   inline constexpr size_t write_padding_bytes = 256;
+
+   // This macro exists so that Glaze tests can change the default behavior
+   // to easily run tests as if strings were not null terminated
+#ifndef GLZ_NULL_TERMINATED
+#define GLZ_NULL_TERMINATED true
+#endif
+
+   enum struct opts_internal : uint32_t {
+      none = 0,
+      opening_handled = 1 << 0, // the opening character has been handled
+      closing_handled = 1 << 1, // the closing character has been handled
+      ws_handled = 1 << 2, // whitespace has already been parsed
+      no_header = 1 << 3, // whether or not a binary header is needed
+      disable_write_unknown =
+         1 << 4, // whether to turn off writing unknown fields for a glz::meta specialized for unknown writing
+      is_padded = 1 << 5, // whether or not the read buffer is padded
+      disable_padding = 1 << 6, // to explicitly disable padding for contexts like includers
+      write_unchecked = 1 << 7 // the write buffer has sufficient space and does not need to be checked
+   };
+
+   // NOTE TO USER:
+   // glz::opts are the default options for using Glaze
+   // You can create your own options struct with more or less fields as long as your struct has:
+   // - opts_internal internal{};
+   // - uint32_t format
+   // The recommended approach is to inherit:
+   // struct custom_opts : glz::opts {
+   //   bool validate_trailing_whitespace = true;
+   // };
 
    struct opts
    {
       // USER CONFIGURABLE
-      uint32_t format = json;
-      bool comments = false; // Write out or support reading in JSONC style comments
+      uint32_t format = JSON;
+      bool null_terminated = GLZ_NULL_TERMINATED; // Whether the input buffer is null terminated
+      bool comments = false; // Support reading in JSONC style comments
       bool error_on_unknown_keys = true; // Error when an unknown key is encountered
       bool skip_null_members = true; // Skip writing out params in an object if the value is null
-      bool use_hash_comparison = true; // Will replace some string equality checks with hash checks
       bool prettify = false; // Write out prettified JSON
       bool minified = false; // Require minified input for JSON, which results in faster read performance
       char indentation_char = ' '; // Prettified JSON indentation char
       uint8_t indentation_width = 3; // Prettified JSON indentation size
       bool new_lines_in_arrays = true; // Whether prettified arrays should have new lines for each element
-      bool shrink_to_fit = false; // Shrinks dynamic containers to new size to save memory
-      bool write_type_info = true; // Write type info for meta objects in variants
-      bool force_conformance = false; // Do not allow invalid json normally accepted such as nan, inf.
+      bool append_arrays = false; // When reading into an array the data will be appended if the type supports it
       bool error_on_missing_keys = false; // Require all non nullable keys to be present in the object. Use
                                           // skip_null_members = false to require nullable members
-
       bool error_on_const_read =
          false; // Error if attempt is made to read into a const value, by default the value is skipped without error
 
-      uint32_t layout = rowwise; // CSV row wise output/input
-
-      // The maximum precision type used for writing floats, higher precision floats will be cast down to this precision
-      float_precision float_max_write_precision{};
-
       bool bools_as_numbers = false; // Read and write booleans with 1's and 0's
 
       bool quoted_num = false; // treat numbers as quoted or array-like types as having quoted numbers
-      bool number = false; // read numbers as strings and write these string as numbers
+      bool number = false; // treats all types like std::string as numbers: read/write these quoted numbers
       bool raw = false; // write out string like values without quotes
       bool raw_string = false; // do not decode/encode escaped characters for strings (improves read/write performance)
       bool structs_as_arrays = false; // Handle structs (reading/writing) without keys, which applies
-      bool allow_conversions = true; // Whether conversions between convertible types are
-      // allowed in binary, e.g. double -> float
 
       bool partial_read =
-         false; // Reads into only existing fields and elements and then exits without parsing the rest of the input
-
-      // glaze_object_t concepts
-      bool partial_read_nested = false; // Advance the partially read struct to the end of the struct
-      bool concatenate = true; // Concatenates ranges of std::pair into single objects when writing
-
-      bool hide_non_invocable =
-         true; // Hides non-invocable members from the cli_menu (may be applied elsewhere in the future)
-
-      // INTERNAL USE
-      bool opening_handled = false; // the opening character has been handled
-      bool closing_handled = false; // the closing character has been handled
-      bool ws_handled = false; // whitespace has already been parsed
-      bool no_header = false; // whether or not a binary header is needed
-      bool write_unknown = true; // whether to write unkwown fields
-      bool is_padded = false; // whether or not the read buffer is padded
-      bool disable_padding = false; // to explicitly disable padding for contexts like includers
-      bool write_unchecked = false; // the write buffer has sufficient space and does not need to be checked
-      // sufficient space is only applicable to writing certain types and based on the write_padding_bytes
+         false; // Reads into the deepest structural object and then exits without parsing the rest of the input
+
+      // INTERNAL OPTIONS
+      uint32_t internal{}; // default should be 0
 
       [[nodiscard]] constexpr bool operator==(const opts&) const noexcept = default;
    };
 
-   template <opts Opts>
+   // CSV Format Options
+   // Note: You can always create your own options struct if you want to share it between formats
+   struct opts_csv
+   {
+      uint32_t format = CSV;
+      static constexpr bool null_terminated = true; // Whether the input buffer is null terminated
+      uint8_t layout = rowwise; // CSV row wise output/input
+      bool use_headers = true; // Whether to write column/row headers in CSV format
+      bool append_arrays = false; // When reading into an array the data will be appended if the type supports it
+      bool raw_string = false; // do not decode/encode escaped characters for strings (improves read/write performance)
+
+      // INTERNAL OPTIONS
+      uint32_t internal{}; // default should be 0
+
+      [[nodiscard]] constexpr bool operator==(const opts_csv&) const noexcept = default;
+   };
+
+   // Add these fields to a custom options struct if you want to use them
+   // OTHER AVAILABLE OPTIONS (and default values):
+
+   // ---
+   // bool validate_skipped = false;
+   // If full validation should be performed on skipped values
+
+   // ---
+   // bool validate_trailing_whitespace = false;
+   // If, after parsing a value, we want to validate the trailing whitespace
+
+   // ---
+   // bool concatenate = true;
+   // Concatenates ranges of std::pair into single objects when writing
+
+   // ---
+   // bool allow_conversions = true;
+   // Whether conversions between convertible types are allowed in BEVE, e.g. double -> float
+
+   // ---
+   // bool write_type_info = true;
+   // Write type info for meta objects in variants
+
+   // ---
+   // bool shrink_to_fit = false;
+   // Shrinks dynamic containers to new size to save memory
+
+   // ---
+   // bool hide_non_invocable = true;
+   // Hides non-invocable members from the cli_menu (may be applied elsewhere in the future)
+
+   // ---
+   // bool escape_control_characters = false;
+   // Escapes control characters like 0x01 or null characters with proper unicode escape sequences.
+   // The default behavior does not escape these characters for performance and safety
+   // (embedding nulls can cause issues, especially with C APIs)
+   // Glaze will error when parsing non-escaped control character (per the JSON spec)
+   // This option allows escaping control characters to avoid such errors.
+
+   // ---
+   // float_precision float_max_write_precision{};
+   // The maximum precision type used for writing floats, higher precision floats will be cast down to this precision
+
+   consteval bool check_validate_skipped(auto&& Opts)
+   {
+      if constexpr (requires { Opts.validate_skipped; }) {
+         return Opts.validate_skipped;
+      }
+      else {
+         return false;
+      }
+   }
+
+   consteval bool check_validate_trailing_whitespace(auto&& Opts)
+   {
+      if constexpr (requires { Opts.validate_trailing_whitespace; }) {
+         return Opts.validate_trailing_whitespace;
+      }
+      else {
+         return false;
+      }
+   }
+
+   consteval bool check_partial_read(auto&& Opts)
+   {
+      if constexpr (requires { Opts.partial_read; }) {
+         return Opts.partial_read;
+      }
+      else {
+         return false;
+      }
+   }
+
+   consteval bool check_concatenate(auto&& Opts)
+   {
+      if constexpr (requires { Opts.concatenate; }) {
+         return Opts.concatenate;
+      }
+      else {
+         return true;
+      }
+   }
+
+   consteval bool check_allow_conversions(auto&& Opts)
+   {
+      if constexpr (requires { Opts.allow_conversions; }) {
+         return Opts.allow_conversions;
+      }
+      else {
+         return true;
+      }
+   }
+
+   consteval bool check_write_type_info(auto&& Opts)
+   {
+      if constexpr (requires { Opts.write_type_info; }) {
+         return Opts.write_type_info;
+      }
+      else {
+         return true;
+      }
+   }
+
+   consteval bool check_shrink_to_fit(auto&& Opts)
+   {
+      if constexpr (requires { Opts.shrink_to_fit; }) {
+         return Opts.shrink_to_fit;
+      }
+      else {
+         return false;
+      }
+   }
+
+   consteval bool check_hide_non_invocable(auto&& Opts)
+   {
+      if constexpr (requires { Opts.hide_non_invocable; }) {
+         return Opts.hide_non_invocable;
+      }
+      else {
+         return true;
+      }
+   }
+
+   consteval bool check_escape_control_characters(auto&& Opts)
+   {
+      if constexpr (requires { Opts.escape_control_characters; }) {
+         return Opts.escape_control_characters;
+      }
+      else {
+         return false;
+      }
+   }
+
+   consteval bool check_use_headers(auto&& Opts)
+   {
+      if constexpr (requires { Opts.use_headers; }) {
+         return Opts.use_headers;
+      }
+      else {
+         return true;
+      }
+   }
+
+   consteval bool check_raw_string(auto&& Opts)
+   {
+      if constexpr (requires { Opts.raw_string; }) {
+         return Opts.raw_string;
+      }
+      else {
+         return false;
+      }
+   }
+
+   consteval uint8_t check_layout(auto&& Opts)
+   {
+      if constexpr (requires { Opts.layout; }) {
+         return Opts.layout;
+      }
+      else {
+         return rowwise;
+      }
+   }
+
+   consteval float_precision check_float_max_write_precision(auto&& Opts)
+   {
+      if constexpr (requires { Opts.float_max_write_precision; }) {
+         return Opts.float_max_write_precision;
+      }
+      else {
+         return {};
+      }
+   }
+
+   consteval bool check_opening_handled(auto&& o) { return o.internal & uint32_t(opts_internal::opening_handled); }
+
+   consteval bool check_closing_handled(auto&& o) { return o.internal & uint32_t(opts_internal::closing_handled); }
+
+   consteval bool check_ws_handled(auto&& o) { return o.internal & uint32_t(opts_internal::ws_handled); }
+
+   consteval bool check_no_header(auto&& o) { return o.internal & uint32_t(opts_internal::no_header); }
+
+   consteval bool check_disable_write_unknown(auto&& o)
+   {
+      return o.internal & uint32_t(opts_internal::disable_write_unknown);
+   }
+
+   consteval bool check_is_padded(auto&& o) { return o.internal & uint32_t(opts_internal::is_padded); }
+
+   consteval bool check_disable_padding(auto&& o) { return o.internal & uint32_t(opts_internal::disable_padding); }
+
+   consteval bool check_write_unchecked(auto&& o) { return o.internal & uint32_t(opts_internal::write_unchecked); }
+
+   template <auto Opts>
    constexpr auto opening_handled()
    {
-      opts ret = Opts;
-      ret.opening_handled = true;
+      auto ret = Opts;
+      ret.internal |= uint32_t(opts_internal::opening_handled);
       return ret;
    }
 
-   template <opts Opts>
+   template <auto Opts>
    constexpr auto opening_and_closing_handled()
    {
-      opts ret = Opts;
-      ret.opening_handled = true;
-      ret.closing_handled = true;
+      auto ret = Opts;
+      ret.internal |= (uint32_t(opts_internal::opening_handled) | uint32_t(opts_internal::closing_handled));
       return ret;
    }
 
-   template <opts Opts>
+   template <auto Opts>
    constexpr auto opening_handled_off()
    {
-      opts ret = Opts;
-      ret.opening_handled = false;
+      auto ret = Opts;
+      ret.internal &= ~uint32_t(opts_internal::opening_handled);
       return ret;
    }
 
-   template <opts Opts>
+   template <auto Opts>
    constexpr auto opening_and_closing_handled_off()
    {
-      opts ret = Opts;
-      ret.opening_handled = false;
-      ret.closing_handled = false;
+      auto ret = Opts;
+      ret.internal &= ~(uint32_t(opts_internal::opening_handled) | uint32_t(opts_internal::closing_handled));
       return ret;
    }
 
-   template <opts Opts>
+   template <auto Opts>
    constexpr auto ws_handled()
    {
-      opts ret = Opts;
-      ret.ws_handled = true;
+      auto ret = Opts;
+      ret.internal |= uint32_t(opts_internal::ws_handled);
       return ret;
    }
 
-   template <opts Opts>
+   template <auto Opts>
    constexpr auto ws_handled_off()
    {
-      opts ret = Opts;
-      ret.ws_handled = false;
+      auto ret = Opts;
+      ret.internal &= ~uint32_t(opts_internal::ws_handled);
+      return ret;
+   }
+
+   template <auto Opts>
+   constexpr auto no_header_on()
+   {
+      auto ret = Opts;
+      ret.internal |= uint32_t(opts_internal::no_header);
+      return ret;
+   }
+
+   template <auto Opts>
+   constexpr auto no_header_off()
+   {
+      auto ret = Opts;
+      ret.internal &= ~uint32_t(opts_internal::no_header);
+      return ret;
+   }
+
+   template <auto Opts>
+   constexpr auto is_padded_on()
+   {
+      auto ret = Opts;
+      ret.internal |= uint32_t(opts_internal::is_padded);
+      return ret;
+   }
+
+   template <auto Opts>
+   constexpr auto is_padded_off()
+   {
+      auto ret = Opts;
+      ret.internal &= ~uint32_t(opts_internal::is_padded);
+      return ret;
+   }
+
+   template <auto Opts>
+   constexpr auto disable_padding_on()
+   {
+      auto ret = Opts;
+      ret.internal |= uint32_t(opts_internal::disable_padding);
       return ret;
    }
 
-   template <opts Opts, auto member_ptr>
+   template <auto Opts>
+   constexpr auto disable_padding_off()
+   {
+      auto ret = Opts;
+      ret.internal &= ~uint32_t(opts_internal::disable_padding);
+      return ret;
+   }
+
+   template <auto Opts>
+   constexpr auto write_unchecked_on()
+   {
+      auto ret = Opts;
+      ret.internal |= uint32_t(opts_internal::write_unchecked);
+      return ret;
+   }
+
+   template <auto Opts>
+   constexpr auto write_unchecked_off()
+   {
+      auto ret = Opts;
+      ret.internal &= ~uint32_t(opts_internal::write_unchecked);
+      return ret;
+   }
+
+   template <auto Opts, auto member_ptr>
    constexpr auto set_opt(auto&& value)
    {
-      opts ret = Opts;
+      auto ret = Opts;
       ret.*member_ptr = value;
       return ret;
    }
 
-   template <opts Opts, auto member_ptr>
+   template <auto Opts, auto member_ptr>
    constexpr auto opt_on()
    {
-      opts ret = Opts;
+      auto ret = Opts;
       ret.*member_ptr = true;
       return ret;
    }
 
-   template <opts Opts, auto member_ptr>
+   template <auto Opts, auto member_ptr>
    inline constexpr auto opt_true = opt_on<Opts, member_ptr>();
 
-   template <opts Opts, auto member_ptr>
+   template <auto Opts, auto member_ptr>
    constexpr auto opt_off()
    {
-      opts ret = Opts;
+      auto ret = Opts;
       ret.*member_ptr = false;
       return ret;
    }
 
-   template <opts Opts, auto member_ptr>
+   template <auto Opts, auto member_ptr>
    inline constexpr auto opt_false = opt_off<Opts, member_ptr>();
 
-   template <opts Opts>
-   constexpr auto write_unknown_off()
+   template <auto Opts>
+   constexpr auto disable_write_unknown_off()
    {
-      opts ret = Opts;
-      ret.write_unknown = false;
+      auto ret = Opts;
+      ret.internal &= ~uint32_t(opts_internal::disable_write_unknown);
       return ret;
    }
 
-   template <opts Opts>
-   constexpr auto write_unknown_on()
+   template <auto Opts>
+   constexpr auto disable_write_unknown_on()
    {
-      opts ret = Opts;
-      ret.write_unknown = true;
+      auto ret = Opts;
+      ret.internal |= uint32_t(opts_internal::disable_write_unknown);
       return ret;
    }
 
-   template <opts Opts>
-   constexpr auto set_binary()
+   template <auto Opts>
+   constexpr auto set_beve()
    {
-      opts ret = Opts;
-      ret.format = binary;
+      auto ret = Opts;
+      ret.format = BEVE;
       return ret;
    }
 
-   template <opts Opts>
+   template <auto Opts>
    constexpr auto set_json()
    {
-      opts ret = Opts;
-      ret.format = json;
+      auto ret = Opts;
+      ret.format = JSON;
       return ret;
    }
-}
 
-namespace glz
-{
-   namespace detail
+   template <auto Opts>
+   constexpr auto set_toml()
    {
-      template <class T = void>
-      struct to_binary;
-
-      template <class T = void>
-      struct from_binary;
-
-      template <class T = void>
-      struct to_json;
-
-      template <class T = void>
-      struct from_json;
-
-      template <class T = void>
-      struct to_ndjson;
-
-      template <class T = void>
-      struct from_ndjson;
-
-      template <class T = void>
-      struct to_csv;
-
-      template <class T = void>
-      struct from_csv;
+      auto ret = Opts;
+      ret.format = TOML;
+      return ret;
    }
+}
 
-   template <class T>
-   concept write_binary_supported = requires { detail::to_binary<std::remove_cvref_t<T>>{}; };
-
-   template <class T>
-   concept read_binary_supported = requires { detail::from_binary<std::remove_cvref_t<T>>{}; };
-
-   template <class T>
-   concept write_json_supported = requires { detail::to_json<std::remove_cvref_t<T>>{}; };
+namespace glz
+{
+   template <uint32_t Format = INVALID, class T = void>
+   struct to;
 
-   template <class T>
-   concept read_json_supported = requires { detail::from_json<std::remove_cvref_t<T>>{}; };
+   template <uint32_t Format = INVALID, class T = void>
+   struct from;
 
-   template <class T>
-   concept write_ndjson_supported = requires { detail::to_ndjson<std::remove_cvref_t<T>>{}; };
+   template <uint32_t Format = INVALID, class T = void>
+   struct to_partial;
 
-   template <class T>
-   concept read_ndjson_supported = requires { detail::from_ndjson<std::remove_cvref_t<T>>{}; };
+   template <uint32_t Format = INVALID>
+   struct skip_value;
 
-   template <class T>
-   concept write_csv_supported = requires { detail::to_csv<std::remove_cvref_t<T>>{}; };
+   template <class T, uint32_t Format>
+   concept write_supported = requires { to<Format, std::remove_cvref_t<T>>{}; };
 
-   template <class T>
-   concept read_csv_supported = requires { detail::from_csv<std::remove_cvref_t<T>>{}; };
+   template <class T, uint32_t Format>
+   concept read_supported = requires { from<Format, std::remove_cvref_t<T>>{}; };
 
-   template <uint32_t Format, class T>
-   consteval bool write_format_supported()
-   {
-      if constexpr (Format == binary) {
-         return write_binary_supported<T>;
-      }
-      else if constexpr (Format == json) {
-         return write_json_supported<T>;
-      }
-      else if constexpr (Format == ndjson) {
-         return write_ndjson_supported<T>;
-      }
-      else if constexpr (Format == csv) {
-         return write_csv_supported<T>;
-      }
-      else {
-         static_assert(false_v<T>, "Glaze metadata is probably needed for your type");
-      }
-   }
+   // These templates save typing by determining the core type used to select the proper to/from specialization
+   // Long term I would like to remove these detail indirections.
 
-   template <uint32_t Format, class T>
-   consteval bool read_format_supported()
-   {
-      if constexpr (Format == binary) {
-         return read_binary_supported<T>;
-      }
-      else if constexpr (Format == json) {
-         return read_json_supported<T>;
-      }
-      else if constexpr (Format == ndjson) {
-         return read_ndjson_supported<T>;
-      }
-      else if constexpr (Format == csv) {
-         return read_csv_supported<T>;
-      }
-      else {
-         static_assert(false_v<T>, "Glaze metadata is probably needed for your type");
-      }
-   }
+   template <uint32_t Format>
+   struct parse
+   {};
 
-   template <uint32_t Format, class T>
-   concept write_supported = write_format_supported<Format, T>();
+   template <uint32_t Format>
+   struct serialize
+   {};
 
-   template <uint32_t Format, class T>
-   concept read_supported = read_format_supported<Format, T>();
+   template <uint32_t Format>
+   struct serialize_partial
+   {};
 }
diff --git a/deps/saucer/include/glaze/core/ptr.hpp b/deps/saucer/include/glaze/core/ptr.hpp
index ce71fb7..56fc59f 100644
--- a/deps/saucer/include/glaze/core/ptr.hpp
+++ b/deps/saucer/include/glaze/core/ptr.hpp
@@ -12,12 +12,11 @@
 namespace glz
 {
    // Given a JSON pointer path, reads from the buffer into the object
-   template <opts Opts, class T, class B>
+   template <auto Opts, class T, class B>
    [[nodiscard]] error_ctx read_as(T&& root_value, const sv json_ptr, B&& buffer)
    {
       error_ctx pe{};
-      bool b =
-         detail::seek_impl([&](auto&& val) { pe = read<Opts>(val, buffer); }, std::forward<T>(root_value), json_ptr);
+      bool b = seek([&](auto&& val) { pe = read<Opts>(val, buffer); }, std::forward<T>(root_value), json_ptr);
       if (b) {
          return pe;
       }
@@ -26,10 +25,10 @@ namespace glz
    }
 
    // Given a JSON pointer path, writes into a buffer the specified value
-   template <opts Opts, class T, class B>
+   template <auto Opts, class T, class B>
    [[nodiscard]] bool write_as(T&& root_value, const sv json_ptr, B&& buffer)
    {
-      return detail::seek_impl(
+      return seek(
          [&](auto&& val) {
             if constexpr (raw_buffer<B>) {
                std::ignore = write<Opts>(
diff --git a/deps/saucer/include/glaze/core/read.hpp b/deps/saucer/include/glaze/core/read.hpp
index 4c25494..27fcbcb 100644
--- a/deps/saucer/include/glaze/core/read.hpp
+++ b/deps/saucer/include/glaze/core/read.hpp
@@ -11,83 +11,68 @@
 
 namespace glz
 {
-   template <opts Opts, bool Padded = false>
-   auto read_iterators(is_context auto&& ctx, contiguous auto&& buffer) noexcept
+   template <auto Opts, bool Padded = false>
+   auto read_iterators(contiguous auto&& buffer) noexcept
    {
       static_assert(sizeof(decltype(*buffer.data())) == 1);
 
       auto it = reinterpret_cast<const char*>(buffer.data());
       auto end = reinterpret_cast<const char*>(buffer.data()); // to be incremented
 
-      if (buffer.empty()) [[unlikely]] {
-         ctx.error = error_code::no_read_input;
-         return std::pair{it, end};
-      }
-
-      using Buffer = std::remove_cvref_t<decltype(buffer)>;
-      if constexpr (is_specialization_v<Buffer, std::basic_string> ||
-                    is_specialization_v<Buffer, std::basic_string_view> || span<Buffer>) {
-         if constexpr (Padded) {
-            end += buffer.size() - padding_bytes;
-         }
-         else {
-            end += buffer.size();
-         }
+      if constexpr (Padded) {
+         end += buffer.size() - padding_bytes;
       }
       else {
-         // if not a std::string, std::string_view, or span, check that the last character is a null character
-         end += buffer.size() - 1;
-         if constexpr (Padded) {
-            end -= padding_bytes;
-         }
-         if (*end != '\0') {
-            ctx.error = error_code::data_must_be_null_terminated;
-         }
+         end += buffer.size();
       }
 
       return std::pair{it, end};
    }
 
-   template <opts Opts, class T>
-      requires read_supported<Opts.format, T>
-   [[nodiscard]] error_ctx read(T& value, contiguous auto&& buffer, is_context auto&& ctx) noexcept
+   template <auto Opts, class T>
+      requires read_supported<T, Opts.format>
+   [[nodiscard]] error_ctx read(T& value, contiguous auto&& buffer, is_context auto&& ctx)
    {
       static_assert(sizeof(decltype(*buffer.data())) == 1);
       using Buffer = std::remove_reference_t<decltype(buffer)>;
 
-      if (buffer.empty()) [[unlikely]] {
-         ctx.error = error_code::no_read_input;
-         return {ctx.error, 0, ctx.includer_error};
+      if constexpr (Opts.format != NDJSON) {
+         if (buffer.empty()) [[unlikely]] {
+            ctx.error = error_code::no_read_input;
+            return {ctx.error, ctx.custom_error_message, 0, ctx.includer_error};
+         }
       }
 
-      constexpr bool use_padded = resizable<Buffer> && non_const_buffer<Buffer> && !Opts.disable_padding;
+      constexpr bool use_padded = resizable<Buffer> && non_const_buffer<Buffer> && !check_disable_padding(Opts);
 
       if constexpr (use_padded) {
          // Pad the buffer for SWAR
          buffer.resize(buffer.size() + padding_bytes);
       }
 
-      auto [it, end] = read_iterators<Opts, use_padded>(ctx, buffer);
+      auto [it, end] = read_iterators<Opts, use_padded>(buffer);
       auto start = it;
       if (bool(ctx.error)) [[unlikely]] {
          goto finish;
       }
 
       if constexpr (use_padded) {
-         detail::read<Opts.format>::template op<opt_true<Opts, &opts::is_padded>>(value, ctx, it, end);
+         parse<Opts.format>::template op<is_padded_on<Opts>()>(value, ctx, it, end);
       }
       else {
-         detail::read<Opts.format>::template op<opt_false<Opts, &opts::is_padded>>(value, ctx, it, end);
+         parse<Opts.format>::template op<is_padded_off<Opts>()>(value, ctx, it, end);
       }
 
       if (bool(ctx.error)) [[unlikely]] {
          goto finish;
       }
 
-      if constexpr (Opts.force_conformance) {
-         // Trailing whitespace is not allowed
+      // The JSON RFC 8259 defines: JSON-text = ws value ws
+      // So, trailing whitespace is permitted and sometimes we want to
+      // validate this, even though this memory will not affect Glaze.
+      if constexpr (check_validate_trailing_whitespace(Opts)) {
          if (it < end) {
-            detail::skip_ws<Opts>(ctx, it, end);
+            skip_ws<Opts>(ctx, it, end);
             if (bool(ctx.error)) [[unlikely]] {
                goto finish;
             }
@@ -98,17 +83,32 @@ namespace glz
       }
 
    finish:
+      // We don't do depth validation for partial reading
+      if constexpr (check_partial_read(Opts)) {
+         if (ctx.error == error_code::partial_read_complete) [[likely]] {
+            ctx.error = error_code::none;
+         }
+         else if (ctx.error == error_code::end_reached && ctx.indentation_level == 0) {
+            ctx.error = error_code::none;
+         }
+      }
+      else {
+         if (ctx.error == error_code::end_reached && ctx.indentation_level == 0) {
+            ctx.error = error_code::none;
+         }
+      }
+
       if constexpr (use_padded) {
          // Restore the original buffer state
          buffer.resize(buffer.size() - padding_bytes);
       }
 
-      return {ctx.error, size_t(it - start), ctx.includer_error};
+      return {ctx.error, ctx.custom_error_message, size_t(it - start), ctx.includer_error};
    }
 
-   template <opts Opts, class T>
-      requires read_supported<Opts.format, T>
-   [[nodiscard]] error_ctx read(T& value, contiguous auto&& buffer) noexcept
+   template <auto Opts, class T>
+      requires read_supported<T, Opts.format>
+   [[nodiscard]] error_ctx read(T& value, contiguous auto&& buffer)
    {
       context ctx{};
       return read<Opts>(value, buffer, ctx);
@@ -117,21 +117,24 @@ namespace glz
    template <class T>
    concept c_style_char_buffer = std::convertible_to<std::remove_cvref_t<T>, std::string_view> && !has_data<T>;
 
+   template <class T>
+   concept is_buffer = c_style_char_buffer<T> || contiguous<T>;
+
    // for char array input
-   template <opts Opts, class T, c_style_char_buffer Buffer>
-      requires read_supported<Opts.format, T>
-   [[nodiscard]] error_ctx read(T& value, Buffer&& buffer, auto&& ctx) noexcept
+   template <auto Opts, class T, c_style_char_buffer Buffer>
+      requires read_supported<T, Opts.format>
+   [[nodiscard]] error_ctx read(T& value, Buffer&& buffer, auto&& ctx)
    {
       const auto str = std::string_view{std::forward<Buffer>(buffer)};
       if (str.empty()) {
-         return {error_code::no_read_input, 0};
+         return {error_code::no_read_input};
       }
       return read<Opts>(value, str, ctx);
    }
 
-   template <opts Opts, class T, c_style_char_buffer Buffer>
-      requires read_supported<Opts.format, T>
-   [[nodiscard]] error_ctx read(T& value, Buffer&& buffer) noexcept
+   template <auto Opts, class T, c_style_char_buffer Buffer>
+      requires read_supported<T, Opts.format>
+   [[nodiscard]] error_ctx read(T& value, Buffer&& buffer)
    {
       context ctx{};
       return read<Opts>(value, std::forward<Buffer>(buffer), ctx);
diff --git a/deps/saucer/include/glaze/core/reflect.hpp b/deps/saucer/include/glaze/core/reflect.hpp
new file mode 100644
index 0000000..e6c2524
--- /dev/null
+++ b/deps/saucer/include/glaze/core/reflect.hpp
@@ -0,0 +1,2074 @@
+// Glaze Library
+// For the license information refer to glaze.hpp
+
+#pragma once
+
+#include "glaze/beve/header.hpp"
+#include "glaze/core/common.hpp"
+#include "glaze/core/wrappers.hpp"
+#include "glaze/util/primes_64.hpp"
+
+#ifdef _MSC_VER
+// Turn off MSVC warning for unreferenced formal parameter, which is referenced in a constexpr branch
+#pragma warning(push)
+#pragma warning(disable : 4100 4189)
+#endif
+
+namespace glz
+{
+   // Get indices of elements satisfying a predicate
+   template <class Tuple, template <class> class Predicate>
+   consteval auto filter_indices()
+   {
+      constexpr auto N = tuple_size_v<Tuple>;
+      if constexpr (N == 0) {
+         return std::array<size_t, 0>{};
+      }
+      else {
+         return []<size_t... Is>(std::index_sequence<Is...>) constexpr {
+            constexpr bool matches[] = {Predicate<glz::tuple_element_t<Is, Tuple>>::value...};
+            constexpr size_t count = (matches[Is] + ...);
+
+            std::array<size_t, count> indices{};
+            size_t index = 0;
+            ((void)((matches[Is] ? (indices[index++] = Is, true) : false)), ...);
+            return indices;
+         }(std::make_index_sequence<N>{});
+      }
+   }
+
+   template <class T>
+   concept is_object_key_type = std::convertible_to<T, std::string_view>;
+
+   template <class T>
+   using object_key_type = std::bool_constant<is_object_key_type<T>>;
+
+   template <class T>
+   using not_object_key_type = std::bool_constant<not is_object_key_type<T>>;
+
+   namespace detail
+   {
+      // The purpose of this is to allocate a new string_view to only the portion of memory
+      // that we are concerned with. This lets the compiler reduce the binary on
+      // reflected names;
+      template <size_t I, class V>
+      struct get_name_alloc
+      {
+         static constexpr auto alias = get_name<get<I>(meta_v<V>)>();
+         static constexpr auto value = join_v<alias>;
+      };
+   }
+
+   template <class T, size_t I>
+   consteval sv get_key_element()
+   {
+      using V = std::decay_t<T>;
+      if constexpr (I == 0) {
+         if constexpr (is_object_key_type<decltype(get<0>(meta_v<V>))>) {
+            return get<0>(meta_v<V>);
+         }
+         else {
+            return detail::get_name_alloc<0, V>::value;
+            // return get_name<get<0>(meta_v<V>)>();
+         }
+      }
+      else if constexpr (is_object_key_type<decltype(get<I - 1>(meta_v<V>))>) {
+         return get<I - 1>(meta_v<V>);
+      }
+      else {
+         return detail::get_name_alloc<I, V>::value;
+         // return get_name<get<I>(meta_v<V>)>();
+      }
+   };
+
+   template <class T>
+   struct reflect;
+
+   // MSVC requires this template specialization for when the tuple size if zero,
+   // otherwise MSVC tries to instantiate calls of get<0> in invalid branches
+   template <class T>
+      requires((glaze_object_t<T> || glaze_flags_t<T> || glaze_enum_t<T>) && (tuple_size_v<meta_t<T>> == 0))
+   struct reflect<T>
+   {
+      static constexpr auto size = 0;
+      static constexpr auto values = tuple{};
+      static constexpr std::array<sv, 0> keys{};
+
+      template <size_t I>
+      using type = std::nullptr_t;
+   };
+
+   template <class T>
+      requires(!meta_keys<T> && (glaze_object_t<T> || glaze_flags_t<T> || glaze_enum_t<T>) &&
+               (tuple_size_v<meta_t<T>> != 0))
+   struct reflect<T>
+   {
+      using V = std::remove_cvref_t<T>;
+      static constexpr auto value_indices = filter_indices<meta_t<V>, not_object_key_type>();
+
+      static constexpr auto values = [] {
+         return [&]<size_t... I>(std::index_sequence<I...>) { //
+            return tuple{get<value_indices[I]>(meta_v<T>)...}; //
+         }(std::make_index_sequence<value_indices.size()>{}); //
+      }();
+
+      static constexpr auto size = tuple_size_v<decltype(values)>;
+
+      static constexpr auto keys = [] {
+         std::array<sv, size> res{};
+         [&]<size_t... I>(std::index_sequence<I...>) { //
+            ((res[I] = get_key_element<T, value_indices[I]>()), ...);
+         }(std::make_index_sequence<value_indices.size()>{});
+         return res;
+      }();
+
+      template <size_t I>
+      using elem = decltype(get<I>(values));
+
+      template <size_t I>
+      using type = member_t<V, decltype(get<I>(values))>;
+   };
+
+   template <class T, size_t N>
+   inline constexpr auto c_style_to_sv(const std::array<T, N>& arr)
+   {
+      std::array<sv, N> ret{};
+      for (size_t i = 0; i < N; ++i) {
+         ret[i] = arr[i];
+      }
+      return ret;
+   }
+
+   template <class T>
+      requires(meta_keys<T> && glaze_t<T>)
+   struct reflect<T>
+   {
+      using V = std::remove_cvref_t<T>;
+      static constexpr auto size = tuple_size_v<meta_keys_t<T>>;
+
+      static constexpr auto values = meta_wrapper_v<T>;
+
+      static constexpr auto keys = c_style_to_sv(meta_keys_v<T>);
+
+      template <size_t I>
+      using elem = decltype(get<I>(values));
+
+      template <size_t I>
+      using type = member_t<V, decltype(get<I>(values))>;
+   };
+
+   template <class T>
+      requires(is_memory_object<T>)
+   struct reflect<T> : reflect<memory_type<T>>
+   {};
+
+   template <class T>
+      requires(glaze_array_t<T>)
+   struct reflect<T>
+   {
+      using V = std::remove_cvref_t<T>;
+
+      static constexpr auto values = meta_v<V>;
+
+      static constexpr auto size = tuple_size_v<decltype(values)>;
+
+      template <size_t I>
+      using elem = decltype(get<I>(values));
+
+      template <size_t I>
+      using type = member_t<V, decltype(get<I>(values))>;
+   };
+
+   template <class T>
+      requires reflectable<T>
+   struct reflect<T>
+   {
+      using V = std::remove_cvref_t<T>;
+      using tie_type = decltype(to_tie(std::declval<T&>()));
+
+      static constexpr auto keys = member_names<V>;
+      static constexpr auto size = keys.size();
+
+      template <size_t I>
+      using elem = decltype(get<I>(std::declval<tie_type>()));
+
+      template <size_t I>
+      using type = member_t<V, decltype(get<I>(std::declval<tie_type>()))>;
+   };
+
+   template <class T>
+      requires readable_map_t<T>
+   struct reflect<T>
+   {
+      static constexpr auto size = 0;
+   };
+
+   // The type of the field before get_member is applied
+   template <class T, size_t I>
+   using elem_t = reflect<T>::template elem<I>;
+
+   // The type of the field after get_member is applied
+   template <class T, size_t I>
+   using refl_t = reflect<T>::template type<I>;
+
+   // The decayed type after get_member is called
+   template <class T, size_t I>
+   using field_t = std::remove_cvref_t<refl_t<T, I>>;
+
+   template <auto Opts, class T>
+   inline constexpr bool maybe_skipped = [] {
+      if constexpr (reflect<T>::size > 0) {
+         constexpr auto N = reflect<T>::size;
+         if constexpr (meta_has_skip<T>) {
+            // If the glz::meta provides a skip method, we assume the user wants to skip fields
+            return true;
+         }
+         else if constexpr (Opts.skip_null_members) {
+            // if any type could be null then we might skip
+            return []<size_t... I>(std::index_sequence<I...>) {
+               return ((always_skipped<field_t<T, I>> || null_t<field_t<T, I>>) || ...);
+            }(std::make_index_sequence<N>{});
+         }
+         else {
+            // if we have an always_skipped type then we return true
+            return []<size_t... I>(std::index_sequence<I...>) {
+               return ((always_skipped<field_t<T, I>>) || ...);
+            }(std::make_index_sequence<N>{});
+         }
+      }
+      else {
+         return false;
+      }
+   }();
+}
+
+namespace glz
+{
+   template <size_t I, class T>
+   constexpr auto key_name_v = [] {
+      if constexpr (reflectable<T>) {
+         return get<I>(member_names<T>);
+      }
+      else {
+         return reflect<T>::keys[I];
+      }
+   }();
+
+   template <class V, class From>
+   consteval bool custom_type_is_nullable()
+   {
+      if constexpr (std::is_member_pointer_v<From>) {
+         if constexpr (std::is_member_function_pointer_v<From>) {
+            using Ret = typename return_type<From>::type;
+            if constexpr (std::is_void_v<Ret>) {
+               using Tuple = typename inputs_as_tuple<From>::type;
+               if constexpr (glz::tuple_size_v<Tuple> == 1) {
+                  using Input = std::decay_t<glz::tuple_element_t<0, Tuple>>;
+                  return bool(null_t<Input>);
+               }
+            }
+         }
+         else if constexpr (std::is_member_object_pointer_v<From>) {
+            using Value = std::decay_t<decltype(std::declval<V>().val.*(std::declval<V>().from))>;
+            if constexpr (is_specialization_v<Value, std::function>) {
+               using Ret = typename function_traits<Value>::result_type;
+
+               if constexpr (std::is_void_v<Ret>) {
+                  using Tuple = typename function_traits<Value>::arguments;
+                  if constexpr (glz::tuple_size_v<Tuple> == 1) {
+                     using Input = std::decay_t<glz::tuple_element_t<0, Tuple>>;
+                     return bool(null_t<Input>);
+                  }
+               }
+            }
+            else {
+               return bool(null_t<Value>);
+            }
+         }
+      }
+      else {
+         if constexpr (is_invocable_concrete<From>) {
+            using Ret = invocable_result_t<From>;
+            if constexpr (std::is_void_v<Ret>) {
+               using Tuple = invocable_args_t<From>;
+               constexpr auto N = glz::tuple_size_v<Tuple>;
+               if constexpr (N == 2) {
+                  using Input = std::decay_t<glz::tuple_element_t<1, Tuple>>;
+                  return bool(null_t<Input>);
+               }
+            }
+         }
+      }
+
+      return false;
+   }
+
+   template <class T, auto Opts>
+   constexpr auto required_fields()
+   {
+      constexpr auto N = reflect<T>::size;
+
+      bit_array<N> fields{};
+      if constexpr (Opts.error_on_missing_keys) {
+         for_each<N>([&]<auto I>() constexpr {
+            using V = std::decay_t<refl_t<T, I>>;
+            if constexpr (is_specialization_v<V, custom_t>) {
+               using From = typename V::from_t;
+
+               // If we are reading a glz::custom_t, we must deduce the input argument and not require the key if it is
+               // optional This allows error_on_missing_keys to work properly with glz::custom_t wrapping optional types
+               constexpr bool nullable_in_custom = custom_type_is_nullable<V, From>();
+
+               fields[I] = !Opts.skip_null_members || !(std::same_as<From, skip> || nullable_in_custom);
+            }
+            else {
+               fields[I] = !Opts.skip_null_members || !null_t<V>;
+            }
+         });
+      }
+      return fields;
+   }
+}
+
+namespace glz::detail
+{
+   // from
+   // https://stackoverflow.com/questions/55941964/how-to-filter-duplicate-types-from-tuple-c
+   template <class T, class... Ts>
+   struct unique
+   {
+      using type = T;
+   };
+
+   template <template <class...> class T, class... Ts, class U, class... Us>
+   struct unique<T<Ts...>, U, Us...>
+      : std::conditional_t<(std::is_same_v<U, Ts> || ...), unique<T<Ts...>, Us...>, unique<T<Ts..., U>, Us...>>
+   {};
+
+   template <class... Ts>
+   struct unique_variant : unique<std::variant<>, Ts...>
+   {};
+
+   template <class T>
+   struct tuple_ptr_variant;
+
+   template <class... Ts>
+   struct tuple_ptr_variant<glz::tuple<Ts...>> : unique<std::variant<>, std::add_pointer_t<Ts>...>
+   {};
+
+   template <class... Ts>
+   struct tuple_ptr_variant<std::tuple<Ts...>> : unique<std::variant<>, std::add_pointer_t<Ts>...>
+   {};
+
+   template <class... Ts>
+   struct tuple_ptr_variant<std::pair<Ts...>> : unique<std::variant<>, std::add_pointer_t<Ts>...>
+   {};
+
+   template <class T, class = std::make_index_sequence<reflect<T>::size>>
+   struct member_tuple_type;
+
+   template <class T, size_t... I>
+   struct member_tuple_type<T, std::index_sequence<I...>>
+   {
+      using type =
+         std::conditional_t<sizeof...(I) == 0, tuple<>, tuple<std::remove_cvref_t<member_t<T, refl_t<T, I>>>...>>;
+   };
+
+   template <class T>
+   using member_tuple_t = typename member_tuple_type<T>::type;
+
+   template <class T, class = std::make_index_sequence<reflect<T>::size>>
+   struct value_variant;
+
+   template <class T, size_t... I>
+   struct value_variant<T, std::index_sequence<I...>>
+   {
+      using type = typename unique_variant<std::remove_cvref_t<elem_t<T, I>>...>::type;
+   };
+
+   template <class T>
+   using value_variant_t = typename value_variant<T>::type;
+
+   template <class T>
+   inline constexpr auto make_array()
+   {
+      return []<size_t... I>(std::index_sequence<I...>) {
+         using value_t = value_variant_t<T>;
+         return std::array<value_t, reflect<T>::size>{get<I>(reflect<T>::values)...};
+      }(std::make_index_sequence<reflect<T>::size>{});
+   }
+
+   template <class Tuple, std::size_t... Is>
+   inline constexpr auto tuple_runtime_getter(std::index_sequence<Is...>)
+   {
+      using value_t = typename tuple_ptr_variant<Tuple>::type;
+      using tuple_ref = std::add_lvalue_reference_t<Tuple>;
+      using getter_t = value_t (*)(tuple_ref);
+      return std::array<getter_t, glz::tuple_size_v<Tuple>>{+[](tuple_ref t) -> value_t {
+         if constexpr (is_std_tuple<Tuple>) {
+            return &std::get<Is>(t);
+         }
+         else {
+            return &glz::get<Is>(t);
+         }
+      }...};
+   }
+
+   template <class Tuple>
+   inline auto get_runtime(Tuple&& t, const size_t index)
+   {
+      using T = std::decay_t<Tuple>;
+      static constexpr auto indices = std::make_index_sequence<glz::tuple_size_v<T>>{};
+      static constexpr auto runtime_getter = tuple_runtime_getter<T>(indices);
+      return runtime_getter[index](t);
+   }
+}
+
+namespace glz
+{
+   template <auto Enum>
+      requires(std::is_enum_v<decltype(Enum)>)
+   constexpr sv enum_name_v = []() -> std::string_view {
+      using T = std::decay_t<decltype(Enum)>;
+
+      if constexpr (glaze_t<T>) {
+         using U = std::underlying_type_t<T>;
+         return reflect<T>::keys[static_cast<U>(Enum)];
+      }
+      else {
+         static_assert(false_v<decltype(Enum)>, "Enum requires glaze metadata for name");
+      }
+   }();
+}
+
+namespace glz
+{
+   template <class T>
+   constexpr auto make_enum_to_string_map()
+   {
+      constexpr auto N = reflect<T>::size;
+      return [&]<size_t... I>(std::index_sequence<I...>) {
+         using key_t = std::underlying_type_t<T>;
+         return normal_map<key_t, sv, N>(std::array<pair<key_t, sv>, N>{
+            pair<key_t, sv>{static_cast<key_t>(glz::get<I>(reflect<T>::values)), reflect<T>::keys[I]}...});
+      }(std::make_index_sequence<N>{});
+   }
+
+   // TODO: This faster approach can be used if the enum has an integer type base and sequential numbering
+   template <class T>
+   constexpr auto make_enum_to_string_array() noexcept
+   {
+      return []<size_t... I>(std::index_sequence<I...>) {
+         return std::array<sv, sizeof...(I)>{reflect<T>::keys[I]...};
+      }(std::make_index_sequence<reflect<T>::size>{});
+   }
+
+   // get a std::string_view from an enum value
+   template <class T>
+      requires(glaze_t<T> && std::is_enum_v<std::decay_t<T>>)
+   constexpr auto get_enum_name(T&& enum_value)
+   {
+      using V = std::decay_t<T>;
+      using U = std::underlying_type_t<V>;
+      constexpr auto arr = make_enum_to_string_array<V>();
+      return arr[static_cast<U>(enum_value)];
+   }
+
+   template <glaze_flags_t T>
+   consteval auto byte_length() noexcept
+   {
+      constexpr auto N = reflect<T>::size;
+
+      if constexpr (N % 8 == 0) {
+         return N / 8;
+      }
+      else {
+         return (N / 8) + 1;
+      }
+   }
+}
+
+#include <initializer_list>
+
+#include "glaze/core/common.hpp"
+#include "glaze/reflection/get_name.hpp"
+#include "glaze/reflection/to_tuple.hpp"
+
+namespace glz
+{
+   // Use a dummy struct for make_reflectable so that we don't conflict with any user defined constructors
+   struct dummy final
+   {};
+
+   // If you want to make an empty struct or a struct with constructors visible in reflected structs,
+   // add the folllwing constructor to your type:
+   // my_struct(glz::make_reflectable) {}
+   using make_reflectable = std::initializer_list<dummy>;
+}
+
+namespace glz
+{
+   // TODO: This is returning the total keys and not the max keys for a particular variant object
+   template <class T, size_t N>
+   constexpr size_t get_max_keys = [] {
+      size_t res{};
+      for_each<N>([&]<auto I>() {
+         using V = std::decay_t<std::variant_alternative_t<I, T>>;
+         if constexpr (glaze_object_t<V> || reflectable<V>) {
+            res += reflect<V>::size;
+         }
+         else if constexpr (is_memory_object<V>) {
+            res += reflect<memory_type<V>>::size;
+         }
+      });
+      return res;
+   }();
+
+   template <class T>
+   constexpr auto get_combined_keys_from_variant()
+   {
+      constexpr auto N = std::variant_size_v<T>;
+
+      std::array<sv, get_max_keys<T, N>> keys{};
+      // This intermediate pointer is necessary for GCC 13 (otherwise segfaults with reflection logic)
+      auto* data_ptr = &keys;
+      size_t index = 0;
+      for_each<N>([&]<auto I>() {
+         using V = std::decay_t<std::variant_alternative_t<I, T>>;
+         if constexpr (glaze_object_t<V> || reflectable<V> || is_memory_object<V>) {
+            using X = std::conditional_t<is_memory_object<V>, memory_type<V>, V>;
+            for (size_t i = 0; i < reflect<X>::size; ++i) {
+               (*data_ptr)[index++] = reflect<X>::keys[i];
+            }
+         }
+      });
+
+      std::sort(keys.begin(), keys.end());
+      const auto end = std::unique(keys.begin(), keys.end());
+      const auto size = std::distance(keys.begin(), end);
+
+      return pair{keys, size};
+   }
+
+   template <class T, size_t... I>
+   consteval auto make_variant_deduction_base_map(std::index_sequence<I...>, auto&& keys)
+   {
+      using V = bit_array<std::variant_size_v<T>>;
+      return normal_map<sv, V, sizeof...(I)>(
+         std::array<pair<sv, V>, sizeof...(I)>{pair<sv, V>{sv(std::get<I>(keys)), V{}}...});
+   }
+
+   template <class T>
+   constexpr auto make_variant_deduction_map()
+   {
+      constexpr auto key_size_pair = get_combined_keys_from_variant<T>();
+
+      auto deduction_map =
+         make_variant_deduction_base_map<T>(std::make_index_sequence<key_size_pair.second>{}, key_size_pair.first);
+
+      constexpr auto N = std::variant_size_v<T>;
+      for_each<N>([&]<auto I>() {
+         using V = decay_keep_volatile_t<std::variant_alternative_t<I, T>>;
+         if constexpr (glaze_object_t<V> || reflectable<V> || is_memory_object<V>) {
+            using X = std::conditional_t<is_memory_object<V>, memory_type<V>, V>;
+            constexpr auto Size = reflect<X>::size;
+            if constexpr (Size > 0) {
+               for (size_t J = 0; J < Size; ++J) {
+                  deduction_map.find(reflect<X>::keys[J])->second[I] = true;
+               }
+            }
+         }
+      });
+
+      return deduction_map;
+   }
+}
+
+namespace glz
+{
+   template <class T>
+   consteval size_t key_index(const std::string_view key)
+   {
+      const auto n = reflect<T>::keys.size();
+      for (size_t i = 0; i < n; ++i) {
+         if (key == reflect<T>::keys[i]) {
+            return i;
+         }
+      }
+      return n;
+   }
+}
+
+namespace glz
+{
+   GLZ_ALWAYS_INLINE constexpr uint64_t bitmix(uint64_t h, const uint64_t seed) noexcept
+   {
+      h *= seed;
+      return h ^ std::rotr(h, 49);
+   };
+
+   // Use when hashing large chunks of characters that are likely very similar
+   GLZ_ALWAYS_INLINE constexpr uint64_t rich_bitmix(uint64_t h, const uint64_t seed) noexcept
+   {
+      h ^= h >> 23;
+      h *= 0x2127599bf4325c37ULL;
+      h ^= seed;
+      h *= 0x880355f21e6d1965ULL;
+      h ^= h >> 47;
+      return h;
+   }
+
+   template <size_t N>
+   using bucket_value_t = std::conditional_t < N<256, uint8_t, uint16_t>;
+
+   // The larger the underlying bucket the more we avoid collisions with invalid keys.
+   // This improves performance of rejecting invalid keys because we don't have to do
+   // string comparisons in these cases.
+   // However, there are obvious memory costs with increasing the bucket size.
+
+   enum struct hash_type { //
+      invalid, // hashing failed
+      unique_index, // A unique character index is used
+      front_hash, // Hash on the front bytes of the key
+      single_element, // Map is a single element
+      mod4, // c % 4
+      xor_mod4, // (c ^ c0) % 4
+      minus_mod4, // (c - c0) % 4
+      three_element_unique_index,
+      unique_per_length, // Hash on a unique character index and the length of the key
+      full_flat // Full key hash with a single table
+   };
+
+   // For N == 3 and N == 4 it is cheap to check mod4, xor_mod4, and minus_mod4 hashes.
+   // Consecuative values like "x", "y", "z" for keys work with minus_mod4
+
+   struct unique_per_length_t
+   {
+      bool valid{};
+      std::array<uint8_t, 256> unique_index{};
+   };
+
+   inline constexpr unique_per_length_t unique_per_length_info(const auto& input_strings)
+   {
+      // TODO: MSVC fixed the related compiler bug, but GitHub Actions has not caught up yet
+#if !defined(_MSC_VER)
+      const auto N = input_strings.size();
+      if (N == 0) {
+         return {};
+      }
+
+      // This could be a std::array, but each length N for std::array causes unique template instaniations
+      // This propagates to std::ranges::sort, so using std::vector means less template instaniations
+      std::vector<std::string_view> strings{};
+      strings.reserve(N);
+      for (size_t i = 0; i < N; ++i) {
+         strings.emplace_back(input_strings[i]);
+      }
+
+      std::ranges::sort(strings, [](const auto& a, const auto& b) { return a.size() < b.size(); });
+
+      if (strings.front().empty() || strings.back().size() >= 255) {
+         return {};
+      }
+
+      unique_per_length_t info{.valid = true};
+      info.unique_index.fill(255);
+
+      // Process each unique length
+      for (size_t len = strings.front().size(); len <= strings.back().size(); ++len) {
+         auto range_begin = std::lower_bound(strings.begin(), strings.end(), len,
+                                             [](const auto& s, size_t l) { return s.length() < l; });
+
+         auto range_end =
+            std::upper_bound(range_begin, strings.end(), len, [](size_t l, const auto& s) { return l < s.length(); });
+
+         auto range = std::ranges::subrange(range_begin, range_end);
+
+         if (range.begin() == range.end()) continue;
+
+         // Find the first unique character for this length
+         bool found = false;
+         for (size_t pos = 0; pos < len; ++pos) {
+            std::array<int, 256> char_count = {};
+
+            // Count occurrences of each character at this position
+            for (auto it = range.begin(); it != range.end(); ++it) {
+               ++char_count[uint8_t((*it)[pos])];
+            }
+
+            bool collision = false;
+            for (const auto count : char_count) {
+               if (count > 1) {
+                  collision = true;
+                  break;
+               }
+            }
+            if (not collision) {
+               info.unique_index[len] = uint8_t(pos);
+               found = true;
+               break;
+            }
+         }
+         if (not found) {
+            info.valid = false;
+            return info;
+         }
+      }
+
+      return info;
+#else
+      return {};
+#endif
+   }
+
+   template <class T>
+   inline constexpr auto per_length_info = unique_per_length_info(reflect<T>::keys);
+
+   consteval size_t bucket_size(hash_type type, size_t N)
+   {
+      using enum hash_type;
+      switch (type) {
+      case invalid: {
+         return 0;
+      }
+      case unique_index: {
+         return 256;
+      }
+      case front_hash: {
+         return (N == 1) ? 1 : std::bit_ceil(N * N) / 2;
+      }
+      case single_element: {
+         return 0;
+      }
+      case mod4: {
+         return 0;
+      }
+      case xor_mod4: {
+         return 0;
+      }
+      case minus_mod4: {
+         return 0;
+      }
+      case three_element_unique_index: {
+         return 0;
+      }
+      case unique_per_length: {
+         return (N == 1) ? 1 : std::bit_ceil(N * N) / 2;
+      }
+      case full_flat: {
+         return (N == 1) ? 1 : std::bit_ceil(N * N) / 2;
+      }
+      default: {
+         return 0;
+      }
+      }
+   }
+
+   struct keys_info_t
+   {
+      size_t N{};
+      hash_type type{};
+      size_t min_length = (std::numeric_limits<size_t>::max)();
+      size_t max_length{};
+      // uint8_t min_diff = (std::numeric_limits<uint8_t>::max)();
+      uint64_t seed{};
+      size_t unique_index = (std::numeric_limits<size_t>::max)();
+      bool sized_hash = false;
+      size_t front_hash_bytes{};
+   };
+
+   // For hash algorithm a value of the seed indicates an invalid hash
+
+   // A value of N in the bucket indicates an invalid hash
+   template <class T, size_t Slots>
+   struct hash_info_t
+   {
+      hash_type type{};
+
+      static constexpr auto N = reflect<T>::size;
+      using V = bucket_value_t<N>;
+      static constexpr auto invalid = static_cast<V>(N);
+
+      std::array<V, Slots> table{}; // hashes to switch-case indices
+      size_t min_length = (std::numeric_limits<size_t>::max)();
+      size_t max_length{};
+      uint64_t seed{};
+      size_t unique_index = (std::numeric_limits<size_t>::max)();
+      bool sized_hash = false;
+      size_t front_hash_bytes{};
+   };
+
+   constexpr std::optional<size_t> find_unique_index(const auto& strings)
+   {
+      namespace ranges = std::ranges;
+
+      const auto N = strings.size();
+
+      if (N == 0) {
+         return {};
+      }
+
+      size_t min_length = (std::numeric_limits<size_t>::max)();
+      for (auto& s : strings) {
+         const auto n = s.size();
+         if (n < min_length) {
+            min_length = n;
+         }
+      }
+
+      if (min_length == 0) {
+         return {};
+      }
+
+      std::vector<std::vector<uint8_t>> cols(min_length);
+
+      for (const auto& s : strings) {
+         // for each character in the string
+         for (size_t c = 0; c < min_length; ++c) {
+            cols[c].emplace_back(s[c]);
+         }
+      }
+
+      // sort colums so that we can determine
+      // if the column is unique
+      size_t best_index{};
+      size_t best_count{};
+      for (size_t i = 0; i < min_length; ++i) {
+         auto& col = cols[i];
+         ranges::sort(col);
+         if (auto it = ranges::adjacent_find(col); it == col.end()) {
+            // no duplicates found
+            best_count = col.size();
+            best_index = i;
+            break;
+         }
+      }
+
+      if (best_count == 0) {
+         return {};
+      }
+
+      return best_index;
+   }
+
+   constexpr std::optional<size_t> find_unique_sized_index(const auto& strings)
+   {
+      namespace ranges = std::ranges;
+
+      const auto N = strings.size();
+
+      if (N == 0) {
+         return {};
+      }
+
+      size_t min_length = (std::numeric_limits<size_t>::max)();
+      for (auto& s : strings) {
+         if (s.contains('"')) {
+            return {}; // Sized hashing requires looking for terminating quote
+         }
+
+         const auto n = s.size();
+         if (n < min_length) {
+            min_length = n;
+         }
+      }
+
+      if (min_length == 0) {
+         return {};
+      }
+
+      std::vector<std::vector<uint16_t>> cols(min_length);
+
+      for (size_t i = 0; i < N; ++i) {
+         const auto& s = strings[i];
+         // for each character in the string
+         for (size_t c = 0; c < min_length; ++c) {
+            const auto k = uint16_t(uint16_t(s[c]) | (uint16_t(s.size()) << 8));
+            cols[c].emplace_back(k);
+         }
+      }
+
+      // sort colums so that we can determine
+      // if the column is unique
+      size_t best_index{};
+      size_t best_count{};
+      for (size_t i = 0; i < min_length; ++i) {
+         auto& col = cols[i];
+         ranges::sort(col);
+         if (auto it = ranges::adjacent_find(col); it == col.end()) {
+            // no duplicates found
+            best_count = col.size();
+            best_index = i;
+            break;
+         }
+      }
+
+      if (best_count == 0) {
+         return {};
+      }
+
+      return best_index;
+   }
+
+   // For full hashing we perform a rich_bitmix on the tail end
+   // This is because most cases that require full hashes are because
+   // the tail end is the only unique part
+
+   // Do not call this at runtime, it is assumes the key lies within min_length and max_length
+   inline constexpr uint64_t full_hash_impl(const sv key, const uint64_t seed, const auto min_length,
+                                            const auto max_length) noexcept
+   {
+      if (max_length < 8) {
+         return bitmix(to_uint64_n_below_8(key.data(), key.size()), seed);
+      }
+      else if (min_length > 7) {
+         const auto n = key.size();
+         uint64_t h = seed;
+         const auto* data = key.data();
+         const auto* end7 = data + n - 7;
+         for (auto d0 = data; d0 < end7; d0 += 8) {
+            h = bitmix(to_uint64(d0), h);
+         }
+         // Handle potential tail. We know we have at least 8
+         return rich_bitmix(to_uint64(data + n - 8), h);
+      }
+      else {
+         const auto n = key.size();
+         const auto* data = key.data();
+
+         if (n < 8) {
+            return bitmix(to_uint64_n_below_8(data, n), seed);
+         }
+
+         uint64_t h = seed;
+         const auto* end7 = data + n - 7;
+         for (auto d0 = data; d0 < end7; d0 += 8) {
+            h = bitmix(to_uint64(d0), h);
+         }
+         // Handle potential tail. We know we have at least 8
+         return rich_bitmix(to_uint64(data + n - 8), h);
+      }
+   }
+
+   // runtime full hash algorithm
+   template <uint64_t min_length, uint64_t max_length, uint64_t seed>
+   inline constexpr uint64_t full_hash(const auto* it, const size_t n) noexcept
+   {
+      if constexpr (max_length < 8) {
+         if (n > 7) {
+            return seed;
+         }
+         return bitmix(to_uint64_n_below_8(it, n), seed);
+      }
+      else if constexpr (min_length > 7) {
+         if (n < 8) {
+            return seed;
+         }
+         uint64_t h = seed;
+         const auto* end7 = it + n - 7;
+         for (auto d0 = it; d0 < end7; d0 += 8) {
+            h = bitmix(to_uint64(d0), h);
+         }
+         // Handle potential tail. We know we have at least 8
+         return rich_bitmix(to_uint64(it + n - 8), h);
+      }
+      else {
+         if (n < 8) {
+            return bitmix(to_uint64_n_below_8(it, n), seed);
+         }
+
+         uint64_t h = seed;
+         const auto* end7 = it + n - 7;
+         for (auto d0 = it; d0 < end7; d0 += 8) {
+            h = bitmix(to_uint64(d0), h);
+         }
+         // Handle potential tail. We know we have at least 8
+         return rich_bitmix(to_uint64(it + n - 8), h);
+      }
+   }
+
+   template <std::integral ChunkType, size_t N>
+   constexpr bool front_bytes_hash_info(const std::array<sv, N>& keys, keys_info_t& info) noexcept
+   {
+      if (info.min_length < sizeof(ChunkType)) {
+         return false;
+      }
+
+      // check for uniqueness
+      std::array<ChunkType, N> k;
+      for (size_t i = 0; i < N; ++i) {
+         if constexpr (std::same_as<ChunkType, uint16_t>) {
+            k[i] = uint16_t(keys[i][0]) | (uint16_t(keys[i][1]) << 8);
+         }
+         else if constexpr (std::same_as<ChunkType, uint32_t>) {
+            k[i] = uint32_t(keys[i][0]) //
+                   | (uint32_t(keys[i][1]) << 8) //
+                   | (uint32_t(keys[i][2]) << 16) //
+                   | (uint32_t(keys[i][3]) << 24);
+         }
+         else if constexpr (std::same_as<ChunkType, uint64_t>) {
+            k[i] = uint64_t(keys[i][0]) //
+                   | (uint64_t(keys[i][1]) << 8) //
+                   | (uint64_t(keys[i][2]) << 16) //
+                   | (uint64_t(keys[i][3]) << 24) //
+                   | (uint64_t(keys[i][4]) << 32) //
+                   | (uint64_t(keys[i][5]) << 40) //
+                   | (uint64_t(keys[i][6]) << 48) //
+                   | (uint64_t(keys[i][7]) << 56);
+         }
+         else {
+            static_assert(false_v<ChunkType>);
+         }
+      }
+
+      std::ranges::sort(k);
+
+      for (size_t i = 0; i < N - 1; ++i) {
+         const auto diff = k[i + 1] - k[i];
+         if (diff == 0) {
+            return false;
+         }
+      }
+
+      using enum hash_type;
+      constexpr uint64_t invalid_seed = 0;
+      auto& seed = info.seed;
+      auto hash_alg = [&] {
+         std::array<size_t, N> bucket_index{};
+         constexpr auto bsize = bucket_size(front_hash, N);
+
+         for (size_t i = 0; i < primes_64.size(); ++i) {
+            seed = primes_64[i];
+            size_t index = 0;
+            for (const auto& key : keys) {
+               const auto hash = [&]() -> size_t {
+                  if constexpr (std::same_as<ChunkType, uint16_t>) {
+                     return bitmix(uint16_t(key[0]) | (uint16_t(key[1]) << 8), seed);
+                  }
+                  else if constexpr (std::same_as<ChunkType, uint32_t>) {
+                     return bitmix(uint32_t(key[0]) //
+                                      | (uint32_t(key[1]) << 8) //
+                                      | (uint32_t(key[2]) << 16) //
+                                      | (uint32_t(key[3]) << 24),
+                                   seed);
+                  }
+                  else if constexpr (std::same_as<ChunkType, uint64_t>) {
+                     return rich_bitmix(uint64_t(key[0]) //
+                                           | (uint64_t(key[1]) << 8) //
+                                           | (uint64_t(key[2]) << 16) //
+                                           | (uint64_t(key[3]) << 24) //
+                                           | (uint64_t(key[4]) << 32) //
+                                           | (uint64_t(key[5]) << 40) //
+                                           | (uint64_t(key[6]) << 48) //
+                                           | (uint64_t(key[7]) << 56),
+                                        seed);
+                  }
+                  else {
+                     static_assert(false_v<ChunkType>);
+                  }
+               }();
+               if (hash == seed) {
+                  break;
+               }
+               const auto bucket = hash % bsize;
+               if (contains(bucket_index.data(), index, bucket)) {
+                  break;
+               }
+               bucket_index[index] = bucket;
+               ++index;
+            }
+
+            if (index == N) {
+               // make sure the seed does not collide with any hashes
+               const auto bucket = seed % bsize;
+               if (not contains(bucket_index.data(), N, bucket)) {
+                  return; // found working seed
+               }
+            }
+         }
+
+         seed = invalid_seed;
+      };
+
+      hash_alg();
+      if (seed != invalid_seed) {
+         info.type = front_hash;
+         info.front_hash_bytes = sizeof(ChunkType);
+         return true;
+      }
+
+      return false;
+   }
+
+   // The sequence of hashing algorithms written here determines the selection preference
+   template <size_t N>
+   constexpr auto make_keys_info(const std::array<sv, N>& keys)
+   {
+      namespace ranges = std::ranges;
+
+      keys_info_t info{N};
+
+      if constexpr (N == 0) {
+         return info;
+      }
+
+      for (size_t i = 0; i < N; ++i) {
+         const auto n = keys[i].size();
+         if (n < info.min_length) {
+            info.min_length = n;
+         }
+         if (n > info.max_length) {
+            info.max_length = n;
+         }
+      }
+
+      using enum hash_type;
+
+      if constexpr (N == 1) {
+         info.type = single_element;
+         return info;
+      }
+
+      // N == 2 is optimized within other hashing methods
+
+      if constexpr (N == 3 || N == 4) {
+         if (info.min_length > 0) {
+            bool valid = true;
+            for (size_t i = 0; i < N; ++i) {
+               if (keys[i][0] % 4 != uint8_t(i)) {
+                  valid = false;
+               }
+            }
+            if (valid) {
+               info.type = mod4;
+               return info;
+            }
+
+            const auto c0 = keys[0][0];
+
+            valid = true;
+            for (size_t i = 0; i < N; ++i) {
+               if ((keys[i][0] ^ c0) % 4 != uint8_t(i)) {
+                  valid = false;
+               }
+            }
+            if (valid) {
+               info.type = xor_mod4;
+               return info;
+            }
+
+            valid = true;
+            for (size_t i = 0; i < N; ++i) {
+               if ((keys[i][0] - c0) % 4 != uint8_t(i)) {
+                  valid = false;
+               }
+            }
+            if (valid) {
+               info.type = minus_mod4;
+               return info;
+            }
+         }
+      }
+
+      auto& seed = info.seed;
+      constexpr uint64_t invalid_seed = 0;
+
+      if (const auto uindex = find_unique_index(keys)) {
+         info.unique_index = uindex.value();
+
+         if constexpr (N == 3) {
+            // An xor of the first unique character with itself will result in 0 (our desired index)
+            // We use a hash algorithm that will produce zero if zero is given, so we can avoid a branch
+            // We need a seed produces hashes of [1, 2] for the 2nd and 3rd keys
+
+            const auto u = info.unique_index;
+            const auto first = uint8_t(keys[0][u]);
+            const auto mix1 = uint8_t(keys[1][u]) ^ first;
+            const auto mix2 = uint8_t(keys[2][u]) ^ first;
+
+            for (size_t i = 0; i < primes_64.size(); ++i) {
+               seed = primes_64[i];
+               uint8_t h1 = (mix1 * seed) % 4;
+               uint8_t h2 = (mix2 * seed) % 4;
+
+               if (h1 == 1 && h2 == 2) {
+                  info.type = three_element_unique_index;
+                  return info;
+               }
+            }
+            // Otherwise we failed to find a seed and we'll use a normal unique_index hash
+         }
+
+         info.type = unique_index;
+         return info;
+      }
+
+      if (front_bytes_hash_info<uint16_t>(keys, info)) {
+         return info;
+      }
+      else if (front_bytes_hash_info<uint32_t>(keys, info)) {
+         return info;
+      }
+      else if (front_bytes_hash_info<uint64_t>(keys, info)) {
+         return info;
+      }
+
+      if (const auto uindex = find_unique_sized_index(keys)) {
+         info.unique_index = uindex.value();
+         info.sized_hash = true;
+
+         auto sized_unique_hash = [&] {
+            std::array<size_t, N> bucket_index{};
+            constexpr auto bsize = bucket_size(unique_index, N);
+
+            for (size_t i = 0; i < primes_64.size(); ++i) {
+               seed = primes_64[i];
+               size_t index = 0;
+               for (const auto& key : keys) {
+                  const auto hash = bitmix(uint16_t(key[info.unique_index]) | (uint16_t(key.size()) << 8), seed);
+                  if (hash == seed) {
+                     break;
+                  }
+                  const auto bucket = hash % bsize;
+                  if (contains(bucket_index.data(), index, bucket)) {
+                     break;
+                  }
+                  bucket_index[index] = bucket;
+                  ++index;
+               }
+
+               if (index == N) {
+                  // make sure the seed does not collide with any hashes
+                  const auto bucket = seed % bsize;
+                  if (not contains(bucket_index.data(), N, bucket)) {
+                     return; // found working seed
+                  }
+               }
+            }
+
+            seed = invalid_seed;
+         };
+
+         sized_unique_hash();
+         if (seed != invalid_seed) {
+            info.type = unique_index;
+            return info;
+         }
+      }
+
+      // TODO: MSVC fixed the related compiler bug, but GitHub Actions has not caught up yet
+#if !defined(_MSC_VER)
+      // TODO: Use meta-programming to cache this value
+      const auto per_length_data = unique_per_length_info(keys);
+      if (per_length_data.valid) {
+         auto sized_unique_hash = [&] {
+            std::array<size_t, N> bucket_index{};
+            constexpr auto bsize = bucket_size(unique_per_length, N);
+
+            for (size_t i = 0; i < primes_64.size(); ++i) {
+               seed = primes_64[i];
+               size_t index = 0;
+               for (const auto& key : keys) {
+                  const auto n = uint8_t(key.size());
+                  const auto hash = bitmix(uint16_t(key[per_length_data.unique_index[n]]) | (uint16_t(n) << 8), seed);
+                  if (hash == seed) {
+                     break;
+                  }
+                  const auto bucket = hash % bsize;
+                  if (contains(bucket_index.data(), index, bucket)) {
+                     break;
+                  }
+                  bucket_index[index] = bucket;
+                  ++index;
+               }
+
+               if (index == N) {
+                  // make sure the seed does not collide with any hashes
+                  const auto bucket = seed % bsize;
+                  if (not contains(bucket_index.data(), N, bucket)) {
+                     return; // found working seed
+                  }
+               }
+            }
+
+            seed = invalid_seed;
+         };
+
+         sized_unique_hash();
+         if (seed != invalid_seed) {
+            info.type = unique_per_length;
+            return info;
+         }
+      }
+#endif
+
+      // full_flat
+      {
+         auto full_flat_hash = [&] {
+            std::array<size_t, N> bucket_index{};
+            constexpr auto bsize = bucket_size(full_flat, N);
+
+            for (size_t i = 0; i < primes_64.size(); ++i) {
+               seed = primes_64[i];
+               size_t index = 0;
+               for (const auto& key : keys) {
+                  const auto hash = full_hash_impl(key, seed, info.min_length, info.max_length);
+                  if (hash == seed) {
+                     break;
+                  }
+                  const auto bucket = hash % bsize;
+                  if (contains(bucket_index.data(), index, bucket)) {
+                     break;
+                  }
+                  bucket_index[index] = bucket;
+                  ++index;
+               }
+
+               if (index == N) {
+                  // make sure the seed does not collide with any hashes
+                  const auto bucket = seed % bsize;
+                  if (not contains(bucket_index.data(), N, bucket)) {
+                     return; // found working seed
+                  }
+               }
+            }
+
+            seed = invalid_seed;
+         };
+
+         full_flat_hash();
+         if (seed != invalid_seed) {
+            info.type = full_flat;
+            return info;
+         }
+      }
+
+      return info;
+   }
+
+   template <class T>
+   constexpr auto keys_info = make_keys_info(reflect<T>::keys);
+
+   template <class T>
+   constexpr auto hash_info = [] {
+      if constexpr ((glaze_object_t<T> || reflectable<T> || glaze_flags_t<T> ||
+                     ((std::is_enum_v<std::remove_cvref_t<T>> && meta_keys<T>) || glaze_enum_t<T>)) &&
+                    (reflect<T>::size > 0)) {
+         constexpr auto& k_info = keys_info<T>;
+         constexpr auto& type = k_info.type;
+         constexpr auto& N = reflect<T>::size;
+         constexpr auto& keys = reflect<T>::keys;
+
+         using enum hash_type;
+         if constexpr (type == single_element) {
+            hash_info_t<T, bucket_size(single_element, N)> info{.type = single_element};
+            info.min_length = k_info.min_length;
+            info.max_length = k_info.max_length;
+            return info;
+         }
+         else if constexpr (type == mod4) {
+            hash_info_t<T, bucket_size(mod4, N)> info{.type = mod4};
+            info.min_length = k_info.min_length;
+            info.max_length = k_info.max_length;
+            return info;
+         }
+         else if constexpr (type == xor_mod4) {
+            hash_info_t<T, bucket_size(xor_mod4, N)> info{.type = xor_mod4};
+            info.min_length = k_info.min_length;
+            info.max_length = k_info.max_length;
+            return info;
+         }
+         else if constexpr (type == minus_mod4) {
+            hash_info_t<T, bucket_size(minus_mod4, N)> info{.type = minus_mod4};
+            info.min_length = k_info.min_length;
+            info.max_length = k_info.max_length;
+            return info;
+         }
+         else if constexpr (type == three_element_unique_index) {
+            hash_info_t<T, bucket_size(three_element_unique_index, N)> info{.type = three_element_unique_index};
+            info.min_length = k_info.min_length;
+            info.max_length = k_info.max_length;
+            info.seed = k_info.seed;
+            info.unique_index = k_info.unique_index;
+            return info;
+         }
+         else if constexpr (type == front_hash) {
+            constexpr auto bsize = bucket_size(front_hash, N);
+            hash_info_t<T, bsize> info{.type = front_hash, .seed = k_info.seed};
+            info.min_length = k_info.min_length;
+            info.max_length = k_info.max_length;
+            info.front_hash_bytes = k_info.front_hash_bytes;
+            info.table.fill(uint8_t(N));
+
+            for (uint8_t i = 0; i < N; ++i) {
+               auto& key = keys[i];
+               const auto h = [&]() -> size_t {
+                  if (info.front_hash_bytes == sizeof(uint16_t)) {
+                     return bitmix(uint16_t(key[0]) | (uint16_t(key[1]) << 8), info.seed) % bsize;
+                  }
+                  else if (info.front_hash_bytes == sizeof(uint32_t)) {
+                     return bitmix(uint32_t(key[0]) //
+                                      | (uint32_t(key[1]) << 8) //
+                                      | (uint32_t(key[2]) << 16) //
+                                      | (uint32_t(key[3]) << 24),
+                                   info.seed) %
+                            bsize;
+                  }
+                  else if (info.front_hash_bytes == sizeof(uint64_t)) {
+                     return rich_bitmix(uint64_t(key[0]) //
+                                           | (uint64_t(key[1]) << 8) //
+                                           | (uint64_t(key[2]) << 16) //
+                                           | (uint64_t(key[3]) << 24) //
+                                           | (uint64_t(key[4]) << 32) //
+                                           | (uint64_t(key[5]) << 40) //
+                                           | (uint64_t(key[6]) << 48) //
+                                           | (uint64_t(key[7]) << 56),
+                                        info.seed) %
+                            bsize;
+                  }
+                  else {
+                     return 0; // MSVC has a compiler bug that prevents us from returning N, but this is unreachable
+                  }
+               }();
+               info.table[h] = i;
+            }
+
+            return info;
+         }
+         else if constexpr (type == unique_index && N < 256) {
+            hash_info_t<T, bucket_size(unique_index, N)> info{.type = unique_index, .seed = k_info.seed};
+            info.min_length = k_info.min_length;
+            info.max_length = k_info.max_length;
+            info.table.fill(bucket_value_t<N>(N));
+            info.unique_index = k_info.unique_index;
+
+            if constexpr (k_info.sized_hash) {
+               info.sized_hash = true;
+               constexpr auto bsize = bucket_size(unique_index, N);
+               for (uint8_t i = 0; i < N; ++i) {
+                  const auto x = uint16_t(keys[i][k_info.unique_index]) | (uint16_t(keys[i].size()) << 8);
+                  const auto h = bitmix(x, info.seed) % bsize;
+                  info.table[h] = i;
+               }
+            }
+            else {
+               for (uint8_t i = 0; i < N; ++i) {
+                  const auto h = uint8_t(keys[i][k_info.unique_index]);
+                  info.table[h] = i;
+               }
+            }
+            return info;
+         }
+         // TODO: MSVC fixed the related compiler bug, but GitHub Actions has not caught up yet
+#if !defined(_MSC_VER)
+         else if constexpr (type == unique_per_length) {
+            hash_info_t<T, bucket_size(unique_per_length, N)> info{.type = unique_per_length, .seed = k_info.seed};
+            info.min_length = k_info.min_length;
+            info.max_length = k_info.max_length;
+            info.table.fill(uint8_t(N));
+            info.sized_hash = true;
+            constexpr auto bsize = bucket_size(unique_per_length, N);
+            constexpr auto& data = per_length_info<T>;
+            for (uint8_t i = 0; i < N; ++i) {
+               const auto n = keys[i].size();
+               const auto x = uint16_t(keys[i][data.unique_index[n]]) | (uint16_t(n) << 8);
+               const auto h = bitmix(x, info.seed) % bsize;
+               info.table[h] = i;
+            }
+            return info;
+         }
+#endif
+         else if constexpr (type == full_flat) {
+            hash_info_t<T, bucket_size(full_flat, N)> info{.type = full_flat, .seed = k_info.seed};
+            info.min_length = k_info.min_length;
+            info.max_length = k_info.max_length;
+            info.table.fill(uint8_t(N));
+            constexpr auto bsize = bucket_size(full_flat, N);
+            for (uint8_t i = 0; i < N; ++i) {
+               const auto h = full_hash_impl(keys[i], info.seed, info.min_length, info.max_length) % bsize;
+               info.table[h] = i;
+            }
+            return info;
+         }
+         else {
+            // invalid
+            return hash_info_t<T, 0>{};
+         }
+      }
+      else {
+         return hash_info_t<T, 0>{};
+      }
+   }();
+
+   template <size_t min_length>
+   GLZ_ALWAYS_INLINE constexpr const void* quote_memchr(auto&& it, auto&& end) noexcept
+   {
+      if (std::is_constant_evaluated()) {
+         const auto count = size_t(end - it);
+         for (std::size_t i = 0; i < count; ++i) {
+            if (it[i] == '"') {
+               return it + i;
+            }
+         }
+         return nullptr;
+      }
+      else {
+         if constexpr (min_length >= 4) {
+            // Skipping makes the bifurcation worth it
+            const auto* start = it + min_length;
+            if (start >= end) [[unlikely]] {
+               return nullptr;
+            }
+            else [[likely]] {
+               return std::memchr(start, '"', size_t(end - start));
+            }
+         }
+         else {
+            return std::memchr(it, '"', size_t(end - it));
+         }
+      }
+   }
+
+   template <uint32_t Format, class T, auto HashInfo, hash_type Type>
+   struct decode_hash;
+
+   template <class T, auto HashInfo>
+   struct decode_hash<JSON, T, HashInfo, hash_type::single_element>
+   {
+      GLZ_ALWAYS_INLINE static constexpr size_t op(auto&& /*it*/, auto&& /*end*/) noexcept { return 0; }
+   };
+
+   template <class T, auto HashInfo>
+   struct decode_hash<JSON, T, HashInfo, hash_type::mod4>
+   {
+      GLZ_ALWAYS_INLINE static constexpr size_t op(auto&& it, auto&& /*end*/) noexcept { return uint8_t(*it) % 4; }
+   };
+
+   template <class T, auto HashInfo>
+   struct decode_hash<JSON, T, HashInfo, hash_type::xor_mod4>
+   {
+      static constexpr auto first_key_char = reflect<T>::keys[0][0];
+
+      GLZ_ALWAYS_INLINE static constexpr size_t op(auto&& it, auto&& /*end*/) noexcept
+      {
+         return (uint8_t(*it) ^ first_key_char) % 4;
+      }
+   };
+
+   template <class T, auto HashInfo>
+   struct decode_hash<JSON, T, HashInfo, hash_type::minus_mod4>
+   {
+      static constexpr auto first_key_char = reflect<T>::keys[0][0];
+
+      GLZ_ALWAYS_INLINE static constexpr size_t op(auto&& it, auto&& /*end*/) noexcept
+      {
+         return (uint8_t(*it) - first_key_char) % 4;
+      }
+   };
+
+   template <class T, auto HashInfo>
+   struct decode_hash<JSON, T, HashInfo, hash_type::unique_index>
+   {
+      static constexpr auto N = reflect<T>::size;
+      static constexpr auto bsize = bucket_size(hash_type::unique_index, N);
+      static constexpr auto uindex = HashInfo.unique_index;
+
+      GLZ_ALWAYS_INLINE static constexpr size_t op(auto&& it, auto&& end) noexcept
+      {
+         if constexpr (HashInfo.sized_hash) {
+            const auto* c = quote_memchr<HashInfo.min_length>(it, end);
+            if (c) [[likely]] {
+               const auto n = size_t(static_cast<std::decay_t<decltype(it)>>(c) - it);
+               if (n == 0 || n > HashInfo.max_length) [[unlikely]] {
+                  return N; // error
+               }
+
+               const auto h = bitmix(uint16_t(it[HashInfo.unique_index]) | (uint16_t(n) << 8), HashInfo.seed);
+               return HashInfo.table[h % bsize];
+            }
+            else [[unlikely]] {
+               return N;
+            }
+         }
+         else {
+            if constexpr (N == 2) {
+               if constexpr (uindex > 0) {
+                  if ((it + uindex) >= end) [[unlikely]] {
+                     return N; // error
+                  }
+               }
+               // Avoids using a hash table
+               if (std::is_constant_evaluated()) {
+                  constexpr auto first_key_char = reflect<T>::keys[0][uindex];
+                  return size_t(bool(it[uindex] ^ first_key_char));
+               }
+               else {
+                  static constexpr auto first_key_char = reflect<T>::keys[0][uindex];
+                  return size_t(bool(it[uindex] ^ first_key_char));
+               }
+            }
+            else {
+               if constexpr (uindex > 0) {
+                  if ((it + uindex) >= end) [[unlikely]] {
+                     return N; // error
+                  }
+               }
+               return HashInfo.table[uint8_t(it[uindex])];
+            }
+         }
+      }
+   };
+
+   template <class T, auto HashInfo>
+   struct decode_hash<JSON, T, HashInfo, hash_type::three_element_unique_index>
+   {
+      static constexpr auto N = reflect<T>::size;
+      static constexpr auto uindex = HashInfo.unique_index;
+
+      GLZ_ALWAYS_INLINE static constexpr size_t op(auto&& it, auto&& end) noexcept
+      {
+         if constexpr (uindex > 0) {
+            if ((it + uindex) >= end) [[unlikely]] {
+               return N; // error
+            }
+         }
+         // Avoids using a hash table
+         if (std::is_constant_evaluated()) {
+            constexpr auto first_key_char = reflect<T>::keys[0][uindex];
+            return (uint8_t(it[uindex] ^ first_key_char) * HashInfo.seed) % 4;
+         }
+         else {
+            static constexpr auto first_key_char = reflect<T>::keys[0][uindex];
+            return (uint8_t(it[uindex] ^ first_key_char) * HashInfo.seed) % 4;
+         }
+      }
+   };
+
+   template <class T, auto HashInfo>
+   struct decode_hash<JSON, T, HashInfo, hash_type::front_hash>
+   {
+      static constexpr auto N = reflect<T>::size;
+      static constexpr auto bsize = bucket_size(hash_type::front_hash, N);
+
+      GLZ_ALWAYS_INLINE static constexpr size_t op(auto&& it, auto&& end) noexcept
+      {
+         if constexpr (HashInfo.front_hash_bytes == 2) {
+            if ((it + 2) >= end) [[unlikely]] {
+               return N; // error
+            }
+            uint16_t h;
+            if (std::is_constant_evaluated()) {
+               h = 0;
+               for (size_t i = 0; i < 2; ++i) {
+                  h |= static_cast<uint16_t>(it[i]) << (8 * i);
+               }
+            }
+            else {
+               std::memcpy(&h, it, 2);
+            }
+            return HashInfo.table[bitmix(h, HashInfo.seed) % bsize];
+         }
+         else if constexpr (HashInfo.front_hash_bytes == 4) {
+            if ((it + 4) >= end) [[unlikely]] {
+               return N;
+            }
+            uint32_t h;
+            if (std::is_constant_evaluated()) {
+               h = 0;
+               for (size_t i = 0; i < 4; ++i) {
+                  h |= static_cast<uint32_t>(it[i]) << (8 * i);
+               }
+            }
+            else {
+               std::memcpy(&h, it, 4);
+            }
+            return HashInfo.table[bitmix(h, HashInfo.seed) % bsize];
+         }
+         else if constexpr (HashInfo.front_hash_bytes == 8) {
+            if ((it + 8) >= end) [[unlikely]] {
+               return N;
+            }
+            uint64_t h;
+            if (std::is_constant_evaluated()) {
+               h = 0;
+               for (size_t i = 0; i < 8; ++i) {
+                  h |= static_cast<uint64_t>(it[i]) << (8 * i);
+               }
+            }
+            else {
+               std::memcpy(&h, it, 8);
+            }
+            return HashInfo.table[rich_bitmix(h, HashInfo.seed) % bsize];
+         }
+         else {
+            static_assert(false_v<T>, "invalid hash algorithm");
+         }
+      }
+   };
+
+   template <class T, auto HashInfo>
+   struct decode_hash<JSON, T, HashInfo, hash_type::unique_per_length>
+   {
+      static constexpr auto N = reflect<T>::size;
+      static constexpr auto bsize = bucket_size(hash_type::unique_per_length, N);
+
+      GLZ_ALWAYS_INLINE static constexpr size_t op(auto&& it, auto&& end) noexcept
+      {
+         const auto* c = quote_memchr<HashInfo.min_length>(it, end);
+         if (c) [[likely]] {
+            const auto n = uint8_t(static_cast<std::decay_t<decltype(it)>>(c) - it);
+            const auto pos = per_length_info<T>.unique_index[n];
+            if ((it + pos) >= end) [[unlikely]] {
+               return N; // error
+            }
+            const auto h = bitmix(uint16_t(it[pos]) | (uint16_t(n) << 8), HashInfo.seed);
+            return HashInfo.table[h % bsize];
+         }
+         else [[unlikely]] {
+            return N;
+         }
+      }
+   };
+
+   template <class T, auto HashInfo>
+   struct decode_hash<JSON, T, HashInfo, hash_type::full_flat>
+   {
+      static constexpr auto N = reflect<T>::size;
+      static constexpr auto bsize = bucket_size(hash_type::full_flat, N);
+      static constexpr auto min_length = HashInfo.min_length;
+      static constexpr auto max_length = HashInfo.max_length;
+      static constexpr auto length_range = max_length - min_length;
+
+      GLZ_ALWAYS_INLINE static constexpr size_t op(auto&& it, auto&& end) noexcept
+      {
+         // For JSON we require at a minimum ":1} characters after a key (1 being a single char number)
+         // This means that we can require all these characters to exist for SWAR parsing
+
+         if constexpr (length_range == 0) {
+            if ((it + min_length) >= end) [[unlikely]] {
+               return N;
+            }
+            const auto h = full_hash<HashInfo.min_length, HashInfo.max_length, HashInfo.seed>(it, min_length);
+            return HashInfo.table[h % bsize];
+         }
+         else {
+            if constexpr (length_range == 1) {
+               auto quote = it + min_length;
+               if ((quote + 1) >= end) [[unlikely]] {
+                  return N;
+               }
+
+               const auto n = min_length + uint8_t(*quote != '"');
+               const auto h = full_hash<HashInfo.min_length, HashInfo.max_length, HashInfo.seed>(it, n);
+               return HashInfo.table[h % bsize];
+            }
+            else {
+               const auto* c = quote_memchr<HashInfo.min_length>(it, end);
+               if (c) [[likely]] {
+                  const auto n = uint8_t(static_cast<std::decay_t<decltype(it)>>(c) - it);
+                  const auto h = full_hash<HashInfo.min_length, HashInfo.max_length, HashInfo.seed>(it, n);
+                  return HashInfo.table[h % bsize];
+               }
+               else [[unlikely]] {
+                  return N;
+               }
+            }
+         }
+      }
+   };
+
+   template <uint32_t Format, class T, auto HashInfo, hash_type Type>
+   struct decode_hash_with_size;
+
+   template <uint32_t Format, class T, auto HashInfo>
+   struct decode_hash_with_size<Format, T, HashInfo, hash_type::single_element>
+   {
+      GLZ_ALWAYS_INLINE static constexpr size_t op(auto&&, auto&&, const size_t) noexcept { return 0; }
+   };
+
+   template <uint32_t Format, class T, auto HashInfo>
+   struct decode_hash_with_size<Format, T, HashInfo, hash_type::mod4>
+   {
+      GLZ_ALWAYS_INLINE static constexpr size_t op(auto&& it, auto&&, const size_t) noexcept
+      {
+         return uint8_t(*it) % 4;
+      }
+   };
+
+   template <uint32_t Format, class T, auto HashInfo>
+   struct decode_hash_with_size<Format, T, HashInfo, hash_type::xor_mod4>
+   {
+      static constexpr auto first_key_char = reflect<T>::keys[0][0];
+
+      GLZ_ALWAYS_INLINE static constexpr size_t op(auto&& it, auto&&, const size_t) noexcept
+      {
+         return (uint8_t(*it) ^ first_key_char) % 4;
+      }
+   };
+
+   template <uint32_t Format, class T, auto HashInfo>
+   struct decode_hash_with_size<Format, T, HashInfo, hash_type::minus_mod4>
+   {
+      static constexpr auto first_key_char = reflect<T>::keys[0][0];
+
+      GLZ_ALWAYS_INLINE static constexpr size_t op(auto&& it, auto&&, const size_t) noexcept
+      {
+         return (uint8_t(*it) - first_key_char) % 4;
+      }
+   };
+
+   template <uint32_t Format, class T, auto HashInfo>
+   struct decode_hash_with_size<Format, T, HashInfo, hash_type::unique_index>
+   {
+      static constexpr auto N = reflect<T>::size;
+      static constexpr auto bsize = bucket_size(hash_type::unique_index, N);
+      static constexpr auto uindex = HashInfo.unique_index;
+
+      GLZ_ALWAYS_INLINE static constexpr size_t op(auto&& it, auto&& end, const size_t n) noexcept
+      {
+         if constexpr (HashInfo.sized_hash) {
+            if (n == 0 || n > HashInfo.max_length) {
+               return N; // error
+            }
+
+            const auto h = bitmix(uint16_t(it[HashInfo.unique_index]) | (uint16_t(n) << 8), HashInfo.seed);
+            return HashInfo.table[h % bsize];
+         }
+         else {
+            if constexpr (N == 2) {
+               if ((it + uindex) >= end) [[unlikely]] {
+                  return N; // error
+               }
+               // Avoids using a hash table
+               if (std::is_constant_evaluated()) {
+                  constexpr auto first_key_char = reflect<T>::keys[0][uindex];
+                  return size_t(bool(it[uindex] ^ first_key_char));
+               }
+               else {
+                  static constexpr auto first_key_char = reflect<T>::keys[0][uindex];
+                  return size_t(bool(it[uindex] ^ first_key_char));
+               }
+            }
+            else {
+               if ((it + uindex) >= end) [[unlikely]] {
+                  return N; // error
+               }
+               return HashInfo.table[uint8_t(it[uindex])];
+            }
+         }
+      }
+   };
+
+   template <uint32_t Format, class T, auto HashInfo>
+   struct decode_hash_with_size<Format, T, HashInfo, hash_type::three_element_unique_index>
+   {
+      static constexpr auto N = reflect<T>::size;
+      static constexpr auto uindex = HashInfo.unique_index;
+
+      GLZ_ALWAYS_INLINE static constexpr size_t op(auto&& it, auto&& end, const size_t) noexcept
+      {
+         if constexpr (uindex > 0) {
+            if ((it + uindex) >= end) [[unlikely]] {
+               return N; // error
+            }
+         }
+         // Avoids using a hash table
+         if (std::is_constant_evaluated()) {
+            constexpr auto first_key_char = reflect<T>::keys[0][uindex];
+            return (uint8_t(it[uindex] ^ first_key_char) * HashInfo.seed) % 4;
+         }
+         else {
+            static constexpr auto first_key_char = reflect<T>::keys[0][uindex];
+            return (uint8_t(it[uindex] ^ first_key_char) * HashInfo.seed) % 4;
+         }
+      }
+   };
+
+   template <uint32_t Format, class T, auto HashInfo>
+   struct decode_hash_with_size<Format, T, HashInfo, hash_type::front_hash>
+   {
+      static constexpr auto N = reflect<T>::size;
+      static constexpr auto bsize = bucket_size(hash_type::front_hash, N);
+
+      GLZ_ALWAYS_INLINE static constexpr size_t op(auto&& it, auto&&, const size_t) noexcept
+      {
+         if constexpr (HashInfo.front_hash_bytes == 2) {
+            uint16_t h;
+            if (std::is_constant_evaluated()) {
+               h = 0;
+               for (size_t i = 0; i < 2; ++i) {
+                  h |= static_cast<uint16_t>(it[i]) << (8 * i);
+               }
+            }
+            else {
+               std::memcpy(&h, it, 2);
+            }
+            return HashInfo.table[bitmix(h, HashInfo.seed) % bsize];
+         }
+         else if constexpr (HashInfo.front_hash_bytes == 4) {
+            uint32_t h;
+            if (std::is_constant_evaluated()) {
+               h = 0;
+               for (size_t i = 0; i < 4; ++i) {
+                  h |= static_cast<uint32_t>(it[i]) << (8 * i);
+               }
+            }
+            else {
+               std::memcpy(&h, it, 4);
+            }
+            return HashInfo.table[bitmix(h, HashInfo.seed) % bsize];
+         }
+         else if constexpr (HashInfo.front_hash_bytes == 8) {
+            uint64_t h;
+            if (std::is_constant_evaluated()) {
+               h = 0;
+               for (size_t i = 0; i < 8; ++i) {
+                  h |= static_cast<uint64_t>(it[i]) << (8 * i);
+               }
+            }
+            else {
+               std::memcpy(&h, it, 8);
+            }
+            return HashInfo.table[rich_bitmix(h, HashInfo.seed) % bsize];
+         }
+         else {
+            static_assert(false_v<T>, "invalid hash algorithm");
+         }
+      }
+   };
+
+   template <uint32_t Format, class T, auto HashInfo>
+   struct decode_hash_with_size<Format, T, HashInfo, hash_type::unique_per_length>
+   {
+      static constexpr auto N = reflect<T>::size;
+      static constexpr auto bsize = bucket_size(hash_type::unique_per_length, N);
+
+      GLZ_ALWAYS_INLINE static constexpr size_t op(auto&& it, auto&& end, const size_t n) noexcept
+      {
+         const auto pos = per_length_info<T>.unique_index[uint8_t(n)];
+         if ((it + pos) >= end) [[unlikely]] {
+            return N; // error
+         }
+         const auto h = bitmix(uint16_t(it[pos]) | (uint16_t(n) << 8), HashInfo.seed);
+         return HashInfo.table[h % bsize];
+      }
+   };
+
+   template <uint32_t Format, class T, auto HashInfo>
+   struct decode_hash_with_size<Format, T, HashInfo, hash_type::full_flat>
+   {
+      static constexpr auto N = reflect<T>::size;
+      static constexpr auto bsize = bucket_size(hash_type::full_flat, N);
+
+      GLZ_ALWAYS_INLINE static constexpr size_t op(auto&& it, auto&&, const size_t n) noexcept
+      {
+         const auto h = full_hash<HashInfo.min_length, HashInfo.max_length, HashInfo.seed>(it, n);
+         return HashInfo.table[h % bsize];
+      }
+   };
+}
+
+namespace glz
+{
+   [[nodiscard]] inline std::string format_error(const error_code& ec)
+   {
+      return std::string{meta<error_code>::keys[uint32_t(ec)]};
+   }
+
+   [[nodiscard]] inline std::string format_error(const error_ctx& pe)
+   {
+      std::string error_str{meta<error_code>::keys[uint32_t(pe.ec)]};
+      if (pe.includer_error.size()) {
+         error_str.append(pe.includer_error);
+      }
+      if (pe.custom_error_message.size()) {
+         error_str.append(" ");
+         error_str.append(pe.custom_error_message.begin(), pe.custom_error_message.end());
+      }
+      return error_str;
+   }
+
+   [[nodiscard]] inline std::string format_error(const error_ctx& pe, const auto& buffer)
+   {
+      const auto error_type_str = meta<error_code>::keys[uint32_t(pe.ec)];
+
+      const auto info = detail::get_source_info(buffer, pe.location);
+      auto error_str = detail::generate_error_string(error_type_str, info);
+      if (pe.includer_error.size()) {
+         error_str.append(pe.includer_error);
+      }
+      if (pe.custom_error_message.size()) {
+         error_str.append(" ");
+         error_str.append(pe.custom_error_message.begin(), pe.custom_error_message.end());
+      }
+      return error_str;
+   }
+
+   template <class T>
+   [[nodiscard]] std::string format_error(const expected<T, error_ctx>& pe, const auto& buffer)
+   {
+      if (not pe) {
+         return format_error(pe.error(), buffer);
+      }
+      else {
+         return "";
+      }
+   }
+
+   template <class T>
+   [[nodiscard]] std::string format_error(const expected<T, error_ctx>& pe)
+   {
+      if (not pe) {
+         return format_error(pe.error());
+      }
+      else {
+         return "";
+      }
+   }
+
+   template <class T>
+   inline constexpr size_t maximum_key_size = [] {
+      constexpr auto N = reflect<T>::size;
+      size_t maximum{};
+      for (size_t i = 0; i < N; ++i) {
+         if (reflect<T>::keys[i].size() > maximum) {
+            maximum = reflect<T>::keys[i].size();
+         }
+      }
+      return maximum + 2; // add quotes for JSON
+   }();
+
+   inline constexpr uint64_t round_up_to_nearest_16(const uint64_t value) noexcept { return (value + 15) & ~15ull; }
+}
+
+namespace glz
+{
+   // The Callable comes second as ranges::for_each puts the callable at the end
+
+   template <class Callable, reflectable T>
+   void for_each_field(T&& value, Callable&& callable)
+   {
+      constexpr auto N = reflect<T>::size;
+      if constexpr (N > 0) {
+         [&]<size_t... I>(std::index_sequence<I...>) constexpr {
+            (callable(get_member(value, get<I>(to_tie(value)))), ...);
+         }(std::make_index_sequence<N>{});
+      }
+   }
+
+   template <class Callable, glaze_object_t T>
+   void for_each_field(T&& value, Callable&& callable)
+   {
+      constexpr auto N = reflect<T>::size;
+      if constexpr (N > 0) {
+         [&]<size_t... I>(std::index_sequence<I...>) constexpr {
+            (callable(get_member(value, get<I>(reflect<T>::values))), ...);
+         }(std::make_index_sequence<N>{});
+      }
+   }
+}
+
+#ifdef _MSC_VER
+// restore disabled warnings
+#pragma warning(pop)
+#endif
diff --git a/deps/saucer/include/glaze/core/reflection_tuple.hpp b/deps/saucer/include/glaze/core/reflection_tuple.hpp
deleted file mode 100644
index cb82dfb..0000000
--- a/deps/saucer/include/glaze/core/reflection_tuple.hpp
+++ /dev/null
@@ -1,39 +0,0 @@
-// Glaze Library
-// For the license information refer to glaze.hpp
-
-#pragma once
-
-#include "glaze/core/common.hpp"
-#include "glaze/reflection/reflect.hpp"
-
-namespace glz::detail
-{
-   template <class T>
-   decltype(auto) reflection_tuple(auto&& value, auto&&...) noexcept
-   {
-      if constexpr (reflectable<T>) {
-         using V = decay_keep_volatile_t<decltype(value)>;
-         if constexpr (std::is_const_v<std::remove_reference_t<decltype(value)>>) {
-#if ((defined _MSC_VER) && (!defined __clang__))
-            static thread_local auto tuple_of_ptrs = make_const_tuple_from_struct<V>();
-#else
-            static thread_local constinit auto tuple_of_ptrs = make_const_tuple_from_struct<V>();
-#endif
-            populate_tuple_ptr(value, tuple_of_ptrs);
-            return tuple_of_ptrs;
-         }
-         else {
-#if ((defined _MSC_VER) && (!defined __clang__))
-            static thread_local auto tuple_of_ptrs = make_tuple_from_struct<V>();
-#else
-            static thread_local constinit auto tuple_of_ptrs = make_tuple_from_struct<V>();
-#endif
-            populate_tuple_ptr(value, tuple_of_ptrs);
-            return tuple_of_ptrs;
-         }
-      }
-      else {
-         return nullptr;
-      }
-   }
-}
diff --git a/deps/saucer/include/glaze/core/seek.hpp b/deps/saucer/include/glaze/core/seek.hpp
index 0ce0729..b8f1360 100644
--- a/deps/saucer/include/glaze/core/seek.hpp
+++ b/deps/saucer/include/glaze/core/seek.hpp
@@ -3,207 +3,232 @@
 
 #pragma once
 
+#include "glaze/core/custom.hpp"
 #include "glaze/core/read.hpp"
+#include "glaze/core/reflect.hpp"
 #include "glaze/core/write.hpp"
-#include "glaze/reflection/reflect.hpp"
+#include "glaze/util/glaze_fast_float.hpp"
 
 // Use JSON Pointer syntax to seek to a specific element
 // https://github.com/stephenberry/JSON-Pointer
 
-namespace glz::detail
+namespace glz
 {
-   template <class F, class T>
-      requires glaze_value_t<T>
-   bool seek_impl(F&& func, T&& value, sv json_ptr) noexcept;
-
-   template <class F, class T>
-      requires glaze_array_t<T> || tuple_t<std::decay_t<T>> || array_t<std::decay_t<T>> || is_std_tuple<std::decay_t<T>>
-   bool seek_impl(F&& func, T&& value, sv json_ptr) noexcept;
-
-   template <class F, class T>
-      requires nullable_t<std::decay_t<T>>
-   bool seek_impl(F&& func, T&& value, sv json_ptr) noexcept;
+   template <class T>
+   struct seek_op;
 
+   // Call a function on an value at the location of a json_ptr
    template <class F, class T>
-      requires readable_map_t<std::decay_t<T>> || glaze_object_t<T> || reflectable<T>
-   bool seek_impl(F&& func, T&& value, sv json_ptr) noexcept;
+   bool seek(F&& func, T&& value, sv json_ptr)
+   {
+      return seek_op<std::remove_cvref_t<T>>::op(std::forward<F>(func), std::forward<T>(value), json_ptr);
+   }
 
-   template <class F, class T>
-   bool seek_impl(F&& func, T&& value, sv json_ptr) noexcept
+   // Default implementation for types that don't have specific specializations
+   template <class T>
+   struct seek_op
    {
-      if (json_ptr.empty()) {
-         func(value);
-         return true;
+      template <class F>
+      static bool op(F&& func, auto&& value, sv json_ptr)
+      {
+         if (json_ptr.empty()) {
+            func(value);
+            return true;
+         }
+         return false;
       }
-      return false;
-   }
+   };
 
-   // TODO: compile time search for `~` and optimize if escape does not exist
-   template <class F, class T>
-      requires readable_map_t<std::decay_t<T>> || glaze_object_t<T> || reflectable<T>
-   bool seek_impl(F&& func, T&& value, sv json_ptr) noexcept
+   // Specialization for glaze_value_t types
+   template <class T>
+      requires glaze_value_t<T>
+   struct seek_op<T>
    {
-      if (json_ptr.empty()) {
-         func(value);
-         return true;
+      template <class F>
+      static bool op(F&& func, auto&& value, sv json_ptr)
+      {
+         decltype(auto) member = get_member(value, meta_wrapper_v<T>);
+         if (json_ptr.empty()) {
+            func(member);
+            return true;
+         }
+         return seek(std::forward<F>(func), member, json_ptr);
       }
-      if (json_ptr[0] != '/' || json_ptr.size() < 2) return false;
+   };
 
-      static thread_local auto key = []() {
-         if constexpr (writable_map_t<std::decay_t<T>>) {
-            return typename std::decay_t<T>::key_type{};
+   // Specialization for array-like types
+   template <class T>
+      requires(glaze_array_t<T> || tuple_t<T> || array_t<T> || is_std_tuple<T>)
+   struct seek_op<T>
+   {
+      template <class F>
+      static bool op(F&& func, auto&& value, sv json_ptr)
+      {
+         if (json_ptr.empty()) {
+            func(value);
+            return true;
          }
-         else {
-            return std::string{};
+         if (json_ptr[0] != '/' || json_ptr.size() < 2) return false;
+
+         size_t index{};
+         auto [p, ec] = std::from_chars(&json_ptr[1], json_ptr.data() + json_ptr.size(), index);
+         if (ec != std::errc{}) return false;
+         json_ptr = json_ptr.substr(p - json_ptr.data());
+
+         if constexpr (glaze_array_t<T>) {
+            static constexpr auto member_array = glz::detail::make_array<T>();
+            if (index >= member_array.size()) return false;
+            return std::visit(
+               [&](auto&& element) { return seek(std::forward<F>(func), get_member(value, element), json_ptr); },
+               member_array[index]);
          }
-      }();
-      using Key = std::decay_t<decltype(key)>;
-      static_assert(std::is_same_v<Key, std::string> || num_t<Key>);
-
-      if constexpr (std::is_same_v<Key, std::string>) {
-         key.clear();
-         size_t i = 1;
-         for (; i < json_ptr.size(); ++i) {
-            auto c = json_ptr[i];
-            if (c == '/')
-               break;
-            else if (c == '~') {
-               if (++i == json_ptr.size()) return false;
-               c = json_ptr[i];
-               if (c == '0')
-                  c = '~';
-               else if (c == '1')
-                  c = '/';
-               else
-                  return false;
-            }
-            key.push_back(c);
+         else if constexpr (tuple_t<T> || is_std_tuple<T>) {
+            if (index >= glz::tuple_size_v<T>) return false;
+            auto tuple_element_ptr = detail::get_runtime(value, index);
+            return std::visit([&](auto&& element_ptr) { return seek(std::forward<F>(func), *element_ptr, json_ptr); },
+                              tuple_element_ptr);
+         }
+         else {
+            if (index >= value.size()) return false;
+            return seek(std::forward<F>(func), *std::next(value.begin(), index), json_ptr);
          }
-         json_ptr = json_ptr.substr(i);
-      }
-      else if constexpr (std::is_floating_point_v<Key>) {
-         auto it = json_ptr.data();
-         auto s = parse_float<Key>(key, it);
-         if (!s) return false;
-         json_ptr = json_ptr.substr(size_t(it - json_ptr.data()));
       }
-      else {
-         auto [p, ec] = std::from_chars(&json_ptr[1], json_ptr.data() + json_ptr.size(), key);
-         if (ec != std::errc{}) return false;
-         json_ptr = json_ptr.substr(p - json_ptr.data());
+   };
+
+   // Specialization for nullable types
+   template <class T>
+      requires nullable_t<T>
+   struct seek_op<T>
+   {
+      template <class F>
+      static bool op(F&& func, auto&& value, sv json_ptr)
+      {
+         if (json_ptr.empty()) {
+            func(value);
+            return true;
+         }
+         if (!value) return false;
+         return seek(std::forward<F>(func), *value, json_ptr);
       }
+   };
 
-      if constexpr (glaze_object_t<T> || reflectable<T>) {
-         decltype(auto) frozen_map = [&]() -> decltype(auto) {
-            if constexpr (reflectable<T>) {
-#if ((defined _MSC_VER) && (!defined __clang__))
-               static thread_local auto cmap = make_map<T>();
-#else
-               static thread_local constinit auto cmap = make_map<T>();
-#endif
-               populate_map(value, cmap); // Function required for MSVC to build
-               return cmap;
+   // Specialization for object/map types
+   template <class T>
+      requires(readable_map_t<T> || glaze_object_t<T> || reflectable<T>)
+   struct seek_op<T>
+   {
+      template <class F>
+      static bool op(F&& func, auto&& value, sv json_ptr)
+      {
+         if (json_ptr.empty()) {
+            func(value);
+            return true;
+         }
+         if (json_ptr[0] != '/' || json_ptr.size() < 2) return false;
+
+         static thread_local auto key = []() {
+            if constexpr (writable_map_t<T>) {
+               return typename T::key_type{};
             }
             else {
-               static constexpr auto cmap = make_map<T>();
-               return cmap;
+               return std::string{};
             }
          }();
-
-         const auto& member_it = frozen_map.find(key);
-         if (member_it != frozen_map.end()) [[likely]] {
-            return std::visit(
-               [&](auto&& member_ptr) {
-                  return seek_impl(std::forward<F>(func), get_member(value, member_ptr), json_ptr);
-               },
-               member_it->second);
+         using Key = std::decay_t<decltype(key)>;
+         static_assert(std::is_same_v<Key, std::string> || num_t<Key>);
+
+         if constexpr (std::is_same_v<Key, std::string>) {
+            key.clear();
+            size_t i = 1;
+            for (; i < json_ptr.size(); ++i) {
+               auto c = json_ptr[i];
+               if (c == '/')
+                  break;
+               else if (c == '~') {
+                  if (++i == json_ptr.size()) return false;
+                  c = json_ptr[i];
+                  if (c == '0')
+                     c = '~';
+                  else if (c == '1')
+                     c = '/';
+                  else
+                     return false;
+               }
+               key.push_back(c);
+            }
+            json_ptr = json_ptr.substr(i);
          }
-         else [[unlikely]] {
-            return false;
+         else if constexpr (std::floating_point<Key>) {
+            auto [ptr, ec] = glz::from_chars<false>(json_ptr.data(), json_ptr.data() + json_ptr.size(), key);
+            if (ec != std::errc()) [[unlikely]] {
+               return false;
+            }
+            json_ptr = json_ptr.substr(size_t(ptr - json_ptr.data()));
+         }
+         else {
+            auto [p, ec] = std::from_chars(&json_ptr[1], json_ptr.data() + json_ptr.size(), key);
+            if (ec != std::errc{}) return false;
+            json_ptr = json_ptr.substr(p - json_ptr.data());
          }
-      }
-      else {
-         return seek_impl(std::forward<F>(func), value[key], json_ptr);
-      }
-   }
 
-   template <class F, class T>
-      requires glaze_array_t<T> || tuple_t<std::decay_t<T>> || array_t<std::decay_t<T>> || is_std_tuple<std::decay_t<T>>
-   bool seek_impl(F&& func, T&& value, sv json_ptr) noexcept
-   {
-      if (json_ptr.empty()) {
-         func(value);
-         return true;
-      }
-      if (json_ptr[0] != '/' || json_ptr.size() < 2) return false;
-
-      size_t index{};
-      auto [p, ec] = std::from_chars(&json_ptr[1], json_ptr.data() + json_ptr.size(), index);
-      if (ec != std::errc{}) return false;
-      json_ptr = json_ptr.substr(p - json_ptr.data());
-
-      if constexpr (glaze_array_t<std::decay_t<T>>) {
-         static constexpr auto member_array = glz::detail::make_array<decay_keep_volatile_t<T>>();
-         if (index >= member_array.size()) return false;
-         return std::visit(
-            [&](auto&& member_ptr) {
-               return seek_impl(std::forward<F>(func), get_member(value, member_ptr), json_ptr);
-            },
-            member_array[index]);
-      }
-      else if constexpr (tuple_t<std::decay_t<T>> || is_std_tuple<std::decay_t<T>>) {
-         if (index >= glz::tuple_size_v<std::decay_t<T>>) return false;
-         auto tuple_element_ptr = get_runtime(value, index);
-         return std::visit([&](auto&& element_ptr) { return seek_impl(std::forward<F>(func), *element_ptr, json_ptr); },
-                           tuple_element_ptr);
-      }
-      else {
-         return seek_impl(std::forward<F>(func), *std::next(value.begin(), index), json_ptr);
+         if constexpr (glaze_object_t<T> || reflectable<T>) {
+            static constexpr auto N = reflect<T>::size;
+            static constexpr auto HashInfo = hash_info<T>;
+            static_assert(HashInfo.type != hash_type::invalid, "Hashing failed");
+
+            const auto index = decode_hash_with_size<JSON_PTR, T, HashInfo, HashInfo.type>::op(
+               key.data(), key.data() + key.size(), key.size());
+
+            if (index < N) [[likely]] {
+               bool ret{};
+               visit<N>(
+                  [&]<size_t I>() {
+                     static constexpr auto TargetKey = get<I>(reflect<T>::keys);
+                     if (key == TargetKey) {
+                        if constexpr (reflectable<T>) {
+                           ret = seek(std::forward<F>(func), get_member(value, get<I>(to_tie(value))), json_ptr);
+                        }
+                        else {
+                           ret = seek(std::forward<F>(func), get_member(value, get<I>(reflect<T>::values)), json_ptr);
+                        }
+                     }
+                  },
+                  index);
+               return ret;
+            }
+            else [[unlikely]] {
+               return false;
+            }
+         }
+         else {
+            return seek(std::forward<F>(func), value[key], json_ptr);
+         }
       }
-   }
+   };
 
-   template <class F, class T>
-      requires nullable_t<std::decay_t<T>>
-   bool seek_impl(F&& func, T&& value, sv json_ptr) noexcept
-   {
-      if (json_ptr.empty()) {
-         func(value);
-         return true;
-      }
-      if (!value) return false;
-      return seek_impl(std::forward<F>(func), *value, json_ptr);
-   }
+   // Helper to transfer cv-qualifiers from source type to target type
+   template <class Source, class Target>
+   using copy_cv_t = std::conditional_t<
+      std::is_const_v<Source>,
+      std::conditional_t<std::is_volatile_v<Source>, std::add_cv_t<Target>, std::add_const_t<Target>>,
+      std::conditional_t<std::is_volatile_v<Source>, std::add_volatile_t<Target>, Target>>;
 
-   template <class F, class T>
-      requires glaze_value_t<T>
-   bool seek_impl(F&& func, T&& value, sv json_ptr) noexcept
-   {
-      decltype(auto) member = get_member(value, meta_wrapper_v<std::remove_cvref_t<T>>);
-      if (json_ptr.empty()) {
-         func(member);
-         return true;
-      }
-      return seek_impl(std::forward<F>(func), member, json_ptr);
-   }
-}
+   // Helper to determine the correct pointer type based on value type
+   template <class V, class T>
+   using get_pointer_type = copy_cv_t<std::remove_reference_t<T>, V>*;
 
-namespace glz
-{
-   // Call a function on an value at the location of a json_ptr
-   template <class F, class T>
-   bool seek(F&& func, T&& value, sv json_ptr) noexcept
-   {
-      return detail::seek_impl(std::forward<F>(func), std::forward<T>(value), json_ptr);
-   }
+   // Helper to determine the correct reference wrapper type
+   template <class V, class T>
+   using get_reference_type = std::reference_wrapper<copy_cv_t<std::remove_reference_t<T>, V>>;
 
-   // Get a refrence to a value at the location of a json_ptr. Will error if
+   // Get a reference to a value at the location of a json_ptr. Will error if
    // value doesnt exist or is wrong type
    template <class V, class T>
-   expected<std::reference_wrapper<V>, error_ctx> get(T&& root_value, sv json_ptr) noexcept
+   expected<get_reference_type<V, T>, error_ctx> get(T&& root_value, sv json_ptr)
    {
-      V* result{};
+      get_pointer_type<V, T> result{};
       error_code ec{};
-      detail::seek_impl(
+      seek(
          [&](auto&& val) {
             if constexpr (not std::same_as<V, decay_keep_volatile_t<decltype(val)>>) {
                ec = error_code::get_wrong_type;
@@ -228,10 +253,10 @@ namespace glz
    // Get a pointer to a value at the location of a json_ptr. Will return
    // nullptr if value doesnt exist or is wrong type
    template <class V, class T>
-   V* get_if(T&& root_value, sv json_ptr) noexcept
+   get_pointer_type<V, T> get_if(T&& root_value, sv json_ptr) noexcept
    {
-      V* result{};
-      detail::seek_impl(
+      get_pointer_type<V, T> result{};
+      seek(
          [&](auto&& val) {
             if constexpr (std::same_as<V, std::decay_t<decltype(val)>>) {
                result = &val;
@@ -242,17 +267,17 @@ namespace glz
    }
 
    // Get a value at the location of a json_ptr. Will error if
-   // value doesnt exist or is not asignable or is a narrowing conversion.
+   // value doesnt exist or is not assignable or is a narrowing conversion.
    template <class V, class T>
    expected<V, error_code> get_value(T&& root_value, sv json_ptr) noexcept
    {
       V result{};
       bool found{};
       error_code ec{};
-      detail::seek_impl(
+      seek(
          [&](auto&& val) {
-            if constexpr (std::is_assignable_v<V, decltype(val)> &&
-                          detail::non_narrowing_convertable<std::decay_t<decltype(val)>, V>) {
+            if constexpr (std::is_assignable_v<V&, decltype(val)> &&
+                          non_narrowing_convertable<std::decay_t<decltype(val)>, V>) {
                found = true;
                result = val;
             }
@@ -277,11 +302,10 @@ namespace glz
    bool set(T&& root_value, const sv json_ptr, V&& value) noexcept
    {
       bool result{};
-      detail::seek_impl(
+      seek(
          [&](auto&& val) {
             if constexpr (std::is_assignable_v<decltype(val), decltype(value)> &&
-                          detail::non_narrowing_convertable<std::decay_t<decltype(value)>,
-                                                            std::decay_t<decltype(val)>>) {
+                          non_narrowing_convertable<std::decay_t<decltype(value)>, std::decay_t<decltype(val)>>) {
                result = true;
 #if defined(__GNUC__) || defined(__GNUG__)
 #pragma GCC diagnostic push
@@ -307,13 +331,13 @@ namespace glz
 
    // call a member function
    template <class R, class T, class... Args>
-   call_return_t<R> call(T&& root_value, sv json_ptr, Args&&... args) noexcept
+   call_return_t<R> call(T&& root_value, sv json_ptr, Args&&... args)
    {
       call_result_t<R> result{};
 
       error_code ec{};
 
-      const auto valid = detail::seek_impl(
+      const auto valid = seek(
          [&ec, &result, &root_value, ... args = std::forward<Args>(args)](auto&& val) {
             using V = std::decay_t<decltype(val)>;
             if constexpr (std::is_member_function_pointer_v<V>) {
@@ -498,7 +522,7 @@ namespace glz
          n_items_per_group[i] = std::count(first_keys.begin(), first_keys.end(), unique_keys[i]);
       }
 
-      return glz::tuplet::tuple{n_items_per_group, n_unique, unique_keys};
+      return glz::tuple{n_items_per_group, n_unique, unique_keys};
    }
 
    template <auto Arr, std::size_t... Is>
@@ -526,7 +550,7 @@ namespace glz
       auto arrs = make_arrays<n_items_per_group>(std::make_index_sequence<n_unique>{});
       size_t start{};
 
-      for_each<n_unique>([&](auto I) {
+      for_each<n_unique>([&]<auto I>() {
          constexpr size_t n_items = n_items_per_group[I];
 
          glz::get<I>(arrs).first = unique_keys[I];
@@ -537,59 +561,52 @@ namespace glz
       return arrs;
    }
 
-   template <class T, string_literal key_str>
-   struct member_getter
-   {
-      static constexpr auto frozen_map = detail::make_map<T>();
-      static constexpr auto member_it = frozen_map.find(key_str.sv());
-   };
-
    // TODO support custom types
-   template <class Root_t, string_literal ptr, class Expected_t = void>
+   template <class Root, string_literal ptr, class Expected = void>
    constexpr bool valid()
    {
-      using V = std::decay_t<Root_t>;
+      using V = std::decay_t<Root>;
       if constexpr (ptr.sv() == sv{""}) {
-         return std::same_as<Expected_t, void> || std::same_as<V, Expected_t>;
+         return std::same_as<Expected, void> || std::same_as<V, Expected>;
       }
       else {
          constexpr auto tokens = tokenize_json_ptr(ptr.sv());
          constexpr auto key_str = tokens.first;
          constexpr auto rem_ptr = glz::string_literal_from_view<tokens.second.size()>(tokens.second);
-         if constexpr (glz::detail::glaze_object_t<V>) {
-            constexpr auto string_literal_key = glz::string_literal_from_view<key_str.size()>(key_str);
-            using G = member_getter<V, string_literal_key>;
-            if constexpr (G::member_it != G::frozen_map.end()) {
-               constexpr auto& element = G::member_it->second;
-               constexpr auto I = element.index();
-               constexpr auto& member_ptr = get<I>(element);
-
-               using mptr_t = std::decay_t<decltype(member_ptr)>;
-               using T = detail::member_t<V, mptr_t>;
+         if constexpr (glz::glaze_object_t<V>) {
+            constexpr auto& HashInfo = hash_info<V>;
+            constexpr auto I = decode_hash_with_size<JSON, V, HashInfo, HashInfo.type>::op(
+               key_str.data(), key_str.data() + key_str.size(), key_str.size());
+
+            if constexpr (I < reflect<V>::size) {
+               if constexpr (key_str != reflect<V>::keys[I]) {
+                  return false;
+               }
+               using T = refl_t<V, I>;
                if constexpr (is_specialization_v<T, includer>) {
-                  return valid<file_include, rem_ptr, Expected_t>();
+                  return valid<file_include, rem_ptr, Expected>();
                }
                else {
-                  return valid<T, rem_ptr, Expected_t>();
+                  return valid<T, rem_ptr, Expected>();
                }
             }
             else {
                return false;
             }
          }
-         else if constexpr (glz::detail::writable_map_t<V>) {
-            return valid<typename V::mapped_type, rem_ptr, Expected_t>();
+         else if constexpr (glz::writable_map_t<V>) {
+            return valid<typename V::mapped_type, rem_ptr, Expected>();
          }
-         else if constexpr (glz::detail::glaze_array_t<V>) {
+         else if constexpr (glz::glaze_array_t<V>) {
             constexpr auto member_array = glz::detail::make_array<std::decay_t<V>>();
-            constexpr auto optional_index = glz::detail::stoui(key_str); // TODO: Will not build if not int
+            constexpr auto optional_index = stoui(key_str); // TODO: Will not build if not int
             if constexpr (optional_index) {
                constexpr auto index = *optional_index;
                if constexpr (index >= 0 && index < member_array.size()) {
                   constexpr auto member = member_array[index];
                   constexpr auto member_ptr = std::get<member.index()>(member);
-                  using sub_t = decltype(glz::detail::get_member(std::declval<V>(), member_ptr));
-                  return valid<sub_t, rem_ptr, Expected_t>();
+                  using sub_t = decltype(glz::get_member(std::declval<V>(), member_ptr));
+                  return valid<sub_t, rem_ptr, Expected>();
                }
                else {
                   return false;
@@ -599,15 +616,15 @@ namespace glz
                return false;
             }
          }
-         else if constexpr (glz::detail::array_t<V>) {
-            if (glz::detail::stoui(key_str)) {
-               return valid<range_value_t<V>, rem_ptr, Expected_t>();
+         else if constexpr (glz::array_t<V>) {
+            if (stoui(key_str)) {
+               return valid<range_value_t<V>, rem_ptr, Expected>();
             }
             return false;
          }
-         else if constexpr (glz::detail::nullable_t<V>) {
+         else if constexpr (glz::nullable_t<V>) {
             using sub_t = decltype(*std::declval<V>());
-            return valid<sub_t, ptr, Expected_t>();
+            return valid<sub_t, ptr, Expected>();
          }
          else {
             return false;
diff --git a/deps/saucer/include/glaze/core/to.hpp b/deps/saucer/include/glaze/core/to.hpp
new file mode 100644
index 0000000..ab30b66
--- /dev/null
+++ b/deps/saucer/include/glaze/core/to.hpp
@@ -0,0 +1,42 @@
+// Glaze Library
+// For the license information refer to glaze.hpp
+
+#pragma once
+
+#include "glaze/core/common.hpp"
+#include "glaze/core/opts.hpp"
+
+// Common behavior for `to` specializations, typically applies for all formats
+
+namespace glz
+{
+   template <uint32_t Format>
+   struct to<Format, hidden>
+   {
+      template <auto Opts>
+      static void op(auto&& value, auto&&...) noexcept
+      {
+         static_assert(false_v<decltype(value)>, "hidden type should not be written");
+      }
+   };
+
+   template <uint32_t Format>
+   struct to<Format, skip>
+   {
+      template <auto Opts>
+      static void op(auto&& value, auto&&...) noexcept
+      {
+         static_assert(false_v<decltype(value)>, "skip type should not be written");
+      }
+   };
+
+   template <uint32_t Format, filesystem_path T>
+   struct to<Format, T>
+   {
+      template <auto Opts, class... Args>
+      static void op(auto&& value, is_context auto&& ctx, Args&&... args)
+      {
+         to<Format, decltype(value.string())>::template op<Opts>(value.string(), ctx, std::forward<Args>(args)...);
+      }
+   };
+}
diff --git a/deps/saucer/include/glaze/core/wrappers.hpp b/deps/saucer/include/glaze/core/wrappers.hpp
index 16b5de6..2144ba8 100644
--- a/deps/saucer/include/glaze/core/wrappers.hpp
+++ b/deps/saucer/include/glaze/core/wrappers.hpp
@@ -9,79 +9,90 @@
 
 namespace glz
 {
-   namespace detail
+   // treat a value as quoted to avoid double parsing into a value
+   template <class T>
+   struct quoted_t
    {
-      template <class T, auto OptsMemPtr>
-      struct opts_wrapper_t
-      {
-         static constexpr bool glaze_wrapper = true;
-         static constexpr auto glaze_reflect = false;
-         static constexpr auto opts_member = OptsMemPtr;
-         using value_type = T;
-         T& val;
-      };
+      static constexpr bool glaze_wrapper = true;
+      using value_type = T;
+      T& val;
+   };
 
-      template <class T>
-      concept is_opts_wrapper = requires {
-         requires T::glaze_wrapper == true;
-         requires T::glaze_reflect == false;
-         T::opts_member;
-         typename T::value_type;
-         requires std::is_lvalue_reference_v<decltype(T::val)>;
-      };
+   template <class T, auto OptsMemPtr>
+   struct opts_wrapper_t
+   {
+      static constexpr bool glaze_wrapper = true;
+      static constexpr auto glaze_reflect = false;
+      static constexpr auto opts_member = OptsMemPtr;
+      using value_type = T;
+      T& val;
+   };
 
-      template <auto MemPtr, auto OptsMemPtr>
-      inline constexpr decltype(auto) opts_wrapper() noexcept
-      {
-         return [](auto&& val) {
-            using V = std::remove_reference_t<decltype(val.*MemPtr)>;
-            return opts_wrapper_t<V, OptsMemPtr>{val.*MemPtr};
-         };
-      }
-
-      // custom_t allows a user to register member functions (and std::function members) to implement custom reading and
-      // writing
-      template <class T, class From, class To>
-      struct custom_t final
-      {
-         static constexpr auto glaze_reflect = false;
-         using from_t = From;
-         using to_t = To;
-         T& val;
-         From from;
-         To to;
+   template <class T>
+   concept is_opts_wrapper = requires {
+      requires T::glaze_wrapper == true;
+      requires T::glaze_reflect == false;
+      T::opts_member;
+      typename T::value_type;
+      requires std::is_lvalue_reference_v<decltype(T::val)>;
+   };
+
+   template <auto MemPtr, auto OptsMemPtr>
+   inline constexpr decltype(auto) opts_wrapper() noexcept
+   {
+      return [](auto&& val) {
+         using V = std::remove_reference_t<decltype(val.*MemPtr)>;
+         return opts_wrapper_t<V, OptsMemPtr>{val.*MemPtr};
       };
+   }
 
-      template <class T, class From, class To>
-      custom_t(T&, From, To) -> custom_t<T, From, To>;
+   // custom_t allows a user to register member functions, std::function members, and member variables
+   // to implement custom reading and writing
+   template <class T, class From, class To>
+   struct custom_t final
+   {
+      static constexpr auto glaze_reflect = false;
+      using from_t = From;
+      using to_t = To;
+      T& val;
+      From from;
+      To to;
+   };
+
+   template <class T, class From, class To>
+   custom_t(T&, From, To) -> custom_t<T, From, To>;
 
-      template <auto From, auto To>
-      inline constexpr auto custom_impl() noexcept
-      {
-         return [](auto&& v) { return custom_t{v, From, To}; };
-      }
+   template <auto From, auto To>
+   constexpr auto custom_impl() noexcept
+   {
+      return [](auto&& v) { return custom_t{v, From, To}; };
    }
 
+   // When reading into an array that is appendable, the new data will be appended rather than overwrite
+   template <auto MemPtr>
+   constexpr auto append_arrays = opts_wrapper<MemPtr, &opts::append_arrays>();
+
    // Read and write booleans as numbers
    template <auto MemPtr>
-   constexpr auto bools_as_numbers = detail::opts_wrapper<MemPtr, &opts::bools_as_numbers>();
+   constexpr auto bools_as_numbers = opts_wrapper<MemPtr, &opts::bools_as_numbers>();
 
    // Read and write numbers as strings
    template <auto MemPtr>
-   constexpr auto quoted_num = detail::opts_wrapper<MemPtr, &opts::quoted_num>();
+   constexpr auto quoted_num = opts_wrapper<MemPtr, &opts::quoted_num>();
 
-   // Read numbers as strings and write these string as numbers
+   // Treat types like std::string as numbers: read and write them quoted
    template <auto MemPtr>
-   constexpr auto number = detail::opts_wrapper<MemPtr, &opts::number>();
+   constexpr auto number = opts_wrapper<MemPtr, &opts::number>();
 
    // Write out string like types without quotes
    template <auto MemPtr>
-   constexpr auto raw = detail::opts_wrapper<MemPtr, &opts::raw>();
+   constexpr auto raw = opts_wrapper<MemPtr, &opts::raw>();
 
    // Reads into only existing fields and elements and then exits without parsing the rest of the input
    template <auto MemPtr>
-   constexpr auto partial_read = detail::opts_wrapper<MemPtr, &opts::partial_read>();
+   constexpr auto partial_read = opts_wrapper<MemPtr, &opts::partial_read>();
 
+   // Customize reading and writing
    template <auto From, auto To>
-   constexpr auto custom = detail::custom_impl<From, To>();
+   constexpr auto custom = custom_impl<From, To>();
 }
diff --git a/deps/saucer/include/glaze/core/write.hpp b/deps/saucer/include/glaze/core/write.hpp
index 7f358ff..aba2fb1 100644
--- a/deps/saucer/include/glaze/core/write.hpp
+++ b/deps/saucer/include/glaze/core/write.hpp
@@ -11,66 +11,68 @@
 namespace glz
 {
    // For writing to a std::string, std::vector<char>, std::deque<char> and the like
-   template <opts Opts, class T, output_buffer Buffer>
-      requires write_supported<Opts.format, T>
-   [[nodiscard]] error_ctx write(T&& value, Buffer& buffer, is_context auto&& ctx) noexcept
+   template <auto Opts, class T, output_buffer Buffer>
+      requires write_supported<T, Opts.format>
+   [[nodiscard]] error_ctx write(T&& value, Buffer& buffer, is_context auto&& ctx)
    {
       if constexpr (resizable<Buffer>) {
-         if (buffer.empty()) {
+         // A buffer could be size 1, to ensure we have sufficient memory we can't just check `empty()`
+         if (buffer.size() < 2 * write_padding_bytes) {
             buffer.resize(2 * write_padding_bytes);
          }
       }
       size_t ix = 0; // overwrite index
-      detail::write<Opts.format>::template op<Opts>(std::forward<T>(value), ctx, buffer, ix);
+      to<Opts.format, std::remove_cvref_t<T>>::template op<Opts>(std::forward<T>(value), ctx, buffer, ix);
       if constexpr (resizable<Buffer>) {
          buffer.resize(ix);
       }
 
-      return {ctx.error};
+      return {ctx.error, ctx.custom_error_message};
    }
 
-   template <auto& Partial, opts Opts, class T, output_buffer Buffer>
-      requires write_supported<Opts.format, T>
-   [[nodiscard]] error_ctx write(T&& value, Buffer& buffer) noexcept
+   template <auto& Partial, auto Opts, class T, output_buffer Buffer>
+      requires write_supported<T, Opts.format>
+   [[nodiscard]] error_ctx write(T&& value, Buffer& buffer)
    {
       if constexpr (resizable<Buffer>) {
-         if (buffer.empty()) {
+         // A buffer could be size 1, to ensure we have sufficient memory we can't just check `empty()`
+         if (buffer.size() < 2 * write_padding_bytes) {
             buffer.resize(2 * write_padding_bytes);
          }
       }
       context ctx{};
       size_t ix = 0;
-      detail::write_partial<Opts.format>::template op<Partial, Opts>(std::forward<T>(value), ctx, buffer, ix);
+      serialize_partial<Opts.format>::template op<Partial, Opts>(std::forward<T>(value), ctx, buffer, ix);
       if constexpr (resizable<Buffer>) {
          buffer.resize(ix);
       }
-      return {ctx.error};
+      return {ctx.error, ctx.custom_error_message};
    }
 
-   template <auto& Partial, opts Opts, class T, raw_buffer Buffer>
-      requires write_supported<Opts.format, T>
-   [[nodiscard]] glz::expected<size_t, error_ctx> write(T&& value, Buffer& buffer) noexcept
+   template <auto& Partial, auto Opts, class T, raw_buffer Buffer>
+      requires write_supported<T, Opts.format>
+   [[nodiscard]] glz::expected<size_t, error_ctx> write(T&& value, Buffer& buffer)
    {
       context ctx{};
       size_t ix = 0;
-      detail::write_partial<Opts.format>::template op<Partial, Opts>(std::forward<T>(value), ctx, buffer, ix);
+      serialize_partial<Opts.format>::template op<Partial, Opts>(std::forward<T>(value), ctx, buffer, ix);
       if (bool(ctx.error)) [[unlikely]] {
-         return glz::unexpected(error_ctx{ctx.error});
+         return glz::unexpected(error_ctx{.ec = ctx.error, .custom_error_message = ctx.custom_error_message});
       }
       return {ix};
    }
 
-   template <opts Opts, class T, output_buffer Buffer>
-      requires write_supported<Opts.format, T>
-   [[nodiscard]] error_ctx write(T&& value, Buffer& buffer) noexcept
+   template <auto Opts, class T, output_buffer Buffer>
+      requires write_supported<T, Opts.format>
+   [[nodiscard]] error_ctx write(T&& value, Buffer& buffer)
    {
       context ctx{};
       return write<Opts>(std::forward<T>(value), buffer, ctx);
    }
 
-   template <opts Opts, class T>
-      requires write_supported<Opts.format, T>
-   [[nodiscard]] glz::expected<std::string, error_ctx> write(T&& value) noexcept
+   template <auto Opts, class T>
+      requires write_supported<T, Opts.format>
+   [[nodiscard]] glz::expected<std::string, error_ctx> write(T&& value)
    {
       std::string buffer{};
       context ctx{};
@@ -81,28 +83,28 @@ namespace glz
       return {buffer};
    }
 
-   template <opts Opts, class T, raw_buffer Buffer>
-      requires write_supported<Opts.format, T>
-   [[nodiscard]] glz::expected<size_t, error_ctx> write(T&& value, Buffer&& buffer, is_context auto&& ctx) noexcept
+   template <auto Opts, class T, raw_buffer Buffer>
+      requires write_supported<T, Opts.format>
+   [[nodiscard]] glz::expected<size_t, error_ctx> write(T&& value, Buffer&& buffer, is_context auto&& ctx)
    {
       size_t ix = 0;
-      detail::write<Opts.format>::template op<Opts>(std::forward<T>(value), ctx, buffer, ix);
+      to<Opts.format, std::remove_cvref_t<T>>::template op<Opts>(std::forward<T>(value), ctx, buffer, ix);
       if (bool(ctx.error)) [[unlikely]] {
          return glz::unexpected(error_ctx{ctx.error});
       }
       return {ix};
    }
 
-   template <opts Opts, class T, raw_buffer Buffer>
-      requires write_supported<Opts.format, T>
-   [[nodiscard]] glz::expected<size_t, error_ctx> write(T&& value, Buffer&& buffer) noexcept
+   template <auto Opts, class T, raw_buffer Buffer>
+      requires write_supported<T, Opts.format>
+   [[nodiscard]] glz::expected<size_t, error_ctx> write(T&& value, Buffer&& buffer)
    {
       context ctx{};
       return write<Opts>(std::forward<T>(value), std::forward<Buffer>(buffer), ctx);
    }
 
    // requires file_name to be null terminated
-   [[nodiscard]] inline error_code buffer_to_file(auto&& buffer, const sv file_name) noexcept
+   [[nodiscard]] inline error_code buffer_to_file(auto&& buffer, const sv file_name)
    {
       auto file = std::ofstream(file_name.data(), std::ios::out);
       if (!file) {
diff --git a/deps/saucer/include/glaze/core/write_chars.hpp b/deps/saucer/include/glaze/core/write_chars.hpp
index 3ff4a61..2522251 100644
--- a/deps/saucer/include/glaze/core/write_chars.hpp
+++ b/deps/saucer/include/glaze/core/write_chars.hpp
@@ -12,7 +12,7 @@
 #include "glaze/util/dump.hpp"
 #include "glaze/util/itoa.hpp"
 
-namespace glz::detail
+namespace glz
 {
    template <class T>
    GLZ_ALWAYS_INLINE constexpr auto sized_integer_conversion() noexcept
@@ -46,7 +46,7 @@ namespace glz::detail
    struct write_chars
    {
       template <auto Opts, class B>
-      inline static void op(num_t auto&& value, is_context auto&&, B&& b, auto&& ix) noexcept
+      inline static void op(num_t auto&& value, is_context auto&& ctx, B&& b, auto&& ix) noexcept
       {
          /*if constexpr (std::same_as<std::decay_t<B>, std::string>) {
             // more efficient strings in C++23:
@@ -55,27 +55,27 @@ namespace glz::detail
 
          // https://stackoverflow.com/questions/1701055/what-is-the-maximum-length-in-chars-needed-to-represent-any-double-value
          // maximum length for a double should be 24 chars, we use 64 to be sufficient for float128_t
-         if constexpr (resizable<B> && not Opts.write_unchecked) {
-            if (ix + 64 > b.size()) [[unlikely]] {
-               b.resize((std::max)(b.size() * 2, ix + 64));
+         if constexpr (resizable<B> && not check_write_unchecked(Opts)) {
+            if (const auto k = ix + 64; k > b.size()) {
+               b.resize(2 * k);
             }
          }
 
          using V = std::decay_t<decltype(value)>;
 
          if constexpr (std::floating_point<V>) {
-            if constexpr (uint8_t(Opts.float_max_write_precision) > 0 &&
-                          uint8_t(Opts.float_max_write_precision) < sizeof(V)) {
+            if constexpr (uint8_t(check_float_max_write_precision(Opts)) > 0 &&
+                          uint8_t(check_float_max_write_precision(Opts)) < sizeof(V)) {
                // we cast to a lower precision floating point value before writing out
-               if constexpr (uint8_t(Opts.float_max_write_precision) == 8) {
+               if constexpr (uint8_t(check_float_max_write_precision(Opts)) == 8) {
                   const auto reduced = static_cast<double>(value);
-                  const auto start = data_ptr(b) + ix;
+                  const auto start = reinterpret_cast<char*>(&b[ix]);
                   const auto end = glz::to_chars(start, reduced);
                   ix += size_t(end - start);
                }
-               else if constexpr (uint8_t(Opts.float_max_write_precision) == 4) {
+               else if constexpr (uint8_t(check_float_max_write_precision(Opts)) == 4) {
                   const auto reduced = static_cast<float>(value);
-                  const auto start = data_ptr(b) + ix;
+                  const auto start = reinterpret_cast<char*>(&b[ix]);
                   const auto end = glz::to_chars(start, reduced);
                   ix += size_t(end - start);
                }
@@ -84,15 +84,16 @@ namespace glz::detail
                }
             }
             else if constexpr (is_any_of<V, float, double>) {
-               const auto start = data_ptr(b) + ix;
+               const auto start = reinterpret_cast<char*>(&b[ix]);
                const auto end = glz::to_chars(start, value);
                ix += size_t(end - start);
             }
             else if constexpr (is_float128<V>) {
-               const auto start = data_ptr(b) + ix;
-               const auto [ptr, ec] = std::to_chars(start, data_ptr(b) + b.size(), value, std::chars_format::general);
+               const auto start = reinterpret_cast<char*>(&b[ix]);
+               const auto [ptr, ec] = std::to_chars(start, &b[0] + b.size(), value, std::chars_format::general);
                if (ec != std::errc()) {
-                  // TODO: Do we need to handle this error state?
+                  ctx.error = error_code::unexpected_end;
+                  return;
                }
                ix += size_t(ptr - start);
             }
@@ -101,13 +102,13 @@ namespace glz::detail
             }
          }
          else if constexpr (is_any_of<V, int32_t, uint32_t, int64_t, uint64_t>) {
-            const auto start = data_ptr(b) + ix;
+            const auto start = reinterpret_cast<char*>(&b[ix]);
             const auto end = glz::to_chars(start, value);
             ix += size_t(end - start);
          }
          else if constexpr (std::integral<V>) {
             using X = std::decay_t<decltype(sized_integer_conversion<V>())>;
-            const auto start = data_ptr(b) + ix;
+            const auto start = reinterpret_cast<char*>(&b[ix]);
             const auto end = glz::to_chars(start, static_cast<X>(value));
             ix += size_t(end - start);
          }
diff --git a/deps/saucer/include/glaze/csv.hpp b/deps/saucer/include/glaze/csv.hpp
index 9b643b0..f5ec9b1 100644
--- a/deps/saucer/include/glaze/csv.hpp
+++ b/deps/saucer/include/glaze/csv.hpp
@@ -5,3 +5,4 @@
 
 #include "glaze/csv/read.hpp"
 #include "glaze/csv/write.hpp"
+#include "glaze/thread/atomic.hpp"
diff --git a/deps/saucer/include/glaze/csv/read.hpp b/deps/saucer/include/glaze/csv/read.hpp
index 6119efc..4eb9eec 100644
--- a/deps/saucer/include/glaze/csv/read.hpp
+++ b/deps/saucer/include/glaze/csv/read.hpp
@@ -7,635 +7,872 @@
 
 #include "glaze/core/opts.hpp"
 #include "glaze/core/read.hpp"
+#include "glaze/core/reflect.hpp"
 #include "glaze/file/file_ops.hpp"
-#include "glaze/reflection/reflect.hpp"
+#include "glaze/util/glaze_fast_float.hpp"
 #include "glaze/util/parse.hpp"
-#include "glaze/util/strod.hpp"
 
 namespace glz
 {
-   namespace detail
+   template <>
+   struct parse<CSV>
    {
-#define GLZ_CSV_NL                             \
-   if (*it == '\n') {                          \
-      ++it;                                    \
-   }                                           \
-   else if (*it == '\r') {                     \
-      ++it;                                    \
-      if (*it == '\n') [[likely]] {            \
-         ++it;                                 \
-      }                                        \
-      else [[unlikely]] {                      \
-         ctx.error = error_code::syntax_error; \
-         return;                               \
-      }                                        \
-   }                                           \
-   else [[unlikely]] {                         \
-      ctx.error = error_code::syntax_error;    \
-      return;                                  \
+      template <auto Opts, class T, is_context Ctx, class It0, class It1>
+      static void op(T&& value, Ctx&& ctx, It0&& it, It1 end)
+      {
+         from<CSV, std::decay_t<T>>::template op<Opts>(std::forward<T>(value), std::forward<Ctx>(ctx),
+                                                       std::forward<It0>(it), std::forward<It1>(end));
+      }
+   };
+
+   GLZ_ALWAYS_INLINE bool csv_new_line(is_context auto& ctx, auto&& it, auto&& end) noexcept
+   {
+      if (it == end) [[unlikely]] {
+         ctx.error = error_code::unexpected_end;
+         return true;
+      }
+
+      if (*it == '\n') {
+         ++it;
+      }
+      else if (*it == '\r') {
+         ++it;
+         if (it == end) [[unlikely]] {
+            ctx.error = error_code::unexpected_end;
+            return true;
+         }
+         if (*it == '\n') [[likely]] {
+            ++it;
+         }
+         else [[unlikely]] {
+            ctx.error = error_code::syntax_error;
+            return true;
+         }
+      }
+      else [[unlikely]] {
+         ctx.error = error_code::syntax_error;
+         return true;
+      }
+      return false;
    }
 
-      template <>
-      struct read<csv>
+   template <glaze_value_t T>
+   struct from<CSV, T>
+   {
+      template <auto Opts, is_context Ctx, class It0, class It1>
+      static void op(auto&& value, Ctx&& ctx, It0&& it, It1&& end)
       {
-         template <auto Opts, class T, is_context Ctx, class It0, class It1>
-         static void op(T&& value, Ctx&& ctx, It0&& it, It1 end) noexcept
-         {
-            from_csv<std::decay_t<T>>::template op<Opts>(std::forward<T>(value), std::forward<Ctx>(ctx),
-                                                         std::forward<It0>(it), std::forward<It1>(end));
-         }
-      };
+         using V = decltype(get_member(std::declval<T>(), meta_wrapper_v<T>));
+         from<CSV, V>::template op<Opts>(get_member(value, meta_wrapper_v<T>), std::forward<Ctx>(ctx),
+                                         std::forward<It0>(it), std::forward<It1>(end));
+      }
+   };
 
-      template <glaze_value_t T>
-      struct from_csv<T>
+   template <num_t T>
+   struct from<CSV, T>
+   {
+      template <auto Opts, class It>
+      static void op(auto&& value, is_context auto&& ctx, It&& it, auto&& end) noexcept
       {
-         template <auto Opts, is_context Ctx, class It0, class It1>
-         static void op(auto&& value, Ctx&& ctx, It0&& it, It1&& end) noexcept
-         {
-            using V = decltype(get_member(std::declval<T>(), meta_wrapper_v<T>));
-            from_csv<V>::template op<Opts>(get_member(value, meta_wrapper_v<T>), std::forward<Ctx>(ctx),
-                                           std::forward<It0>(it), std::forward<It1>(end));
+         if (bool(ctx.error)) [[unlikely]] {
+            return;
          }
-      };
 
-      template <num_t T>
-      struct from_csv<T>
-      {
-         template <auto Opts, class It>
-         static void op(auto&& value, is_context auto&& ctx, It&& it, auto&&) noexcept
-         {
-            if (bool(ctx.error)) [[unlikely]] {
-               return;
-            }
+         if (it == end) [[unlikely]] {
+            ctx.error = error_code::unexpected_end;
+            return;
+         }
 
-            using V = decay_keep_volatile_t<decltype(value)>;
-            if constexpr (int_t<V>) {
-               if constexpr (std::is_unsigned_v<V>) {
-                  uint64_t i{};
-                  if (*it == '-') [[unlikely]] {
-                     ctx.error = error_code::parse_number_failure;
-                     return;
-                  }
-                  auto e = stoui64<V>(i, it);
-                  if (!e) [[unlikely]] {
-                     ctx.error = error_code::parse_number_failure;
-                     return;
-                  }
+         using V = decay_keep_volatile_t<decltype(value)>;
+         if constexpr (int_t<V>) {
+            if constexpr (std::is_unsigned_v<V>) {
+               uint64_t i{};
+               if (*it == '-') [[unlikely]] {
+                  ctx.error = error_code::parse_number_failure;
+                  return;
+               }
 
-                  if (i > (std::numeric_limits<V>::max)()) [[unlikely]] {
-                     ctx.error = error_code::parse_number_failure;
-                     return;
-                  }
-                  value = static_cast<V>(i);
+               if (not glz::atoi(i, it, end)) [[unlikely]] {
+                  ctx.error = error_code::parse_number_failure;
+                  return;
                }
-               else {
-                  uint64_t i{};
-                  int sign = 1;
-                  if (*it == '-') {
-                     sign = -1;
-                     ++it;
-                  }
-                  auto e = stoui64<V>(i, it);
-                  if (!e) [[unlikely]] {
-                     ctx.error = error_code::parse_number_failure;
-                     return;
-                  }
 
-                  if (i > (std::numeric_limits<V>::max)()) [[unlikely]] {
-                     ctx.error = error_code::parse_number_failure;
-                     return;
-                  }
-                  value = sign * static_cast<V>(i);
+               if (i > (std::numeric_limits<V>::max)()) [[unlikely]] {
+                  ctx.error = error_code::parse_number_failure;
+                  return;
                }
+               value = static_cast<V>(i);
             }
             else {
-               auto s = parse_float<V, Opts.force_conformance>(value, it);
-               if (!s) [[unlikely]] {
+               uint64_t i{};
+               int sign = 1;
+               if (*it == '-') {
+                  sign = -1;
+                  ++it;
+                  if (it == end) [[unlikely]] {
+                     ctx.error = error_code::unexpected_end;
+                     return;
+                  }
+               }
+               if (not glz::atoi(i, it, end)) [[unlikely]] {
                   ctx.error = error_code::parse_number_failure;
                   return;
                }
+
+               if (i > (std::numeric_limits<V>::max)()) [[unlikely]] {
+                  ctx.error = error_code::parse_number_failure;
+                  return;
+               }
+               value = sign * static_cast<V>(i);
             }
          }
-      };
-
-      template <string_t T>
-      struct from_csv<T>
-      {
-         template <auto Opts, class It>
-         static void op(auto&& value, is_context auto&& ctx, It&& it, auto&& end) noexcept
-         {
-            if (bool(ctx.error)) [[unlikely]] {
+         else {
+            auto [ptr, ec] = glz::from_chars<false>(it, end, value); // Always treat as non-null-terminated
+            if (ec != std::errc()) [[unlikely]] {
+               ctx.error = error_code::parse_number_failure;
                return;
             }
+            it = ptr;
+         }
+      }
+   };
 
-            value.clear();
-            auto start = it;
-            while (it < end) {
-               switch (*it) {
-               case ',':
-               case '\n': {
-                  value.append(start, static_cast<size_t>(it - start));
-                  return;
-               }
-               case '\\':
-               case '\b':
-               case '\f':
-               case '\r':
-               case '\t': {
-                  ctx.error = error_code::syntax_error;
-                  return;
-               }
-               case '\0': {
-                  ctx.error = error_code::unexpected_end;
-                  return;
-               }
-               default:
-                  ++it;
-               }
-            }
+   // CSV spec: https://www.ietf.org/rfc/rfc4180.txt
+   // Quotes are escaped via double quotes
 
-            value.append(start, static_cast<size_t>(it - start));
+   template <string_t T>
+   struct from<CSV, T>
+   {
+      template <auto Opts, class It>
+      static void op(auto&& value, is_context auto&& ctx, It&& it, auto&& end)
+      {
+         if (bool(ctx.error)) [[unlikely]] {
+            return;
          }
-      };
 
-      template <bool_t T>
-      struct from_csv<T>
-      {
-         template <auto Opts, class It>
-         static void op(auto&& value, is_context auto&& ctx, It&& it, auto&&) noexcept
-         {
-            if (bool(ctx.error)) [[unlikely]] {
-               return;
+         value.clear();
+
+         if (it == end) {
+            return;
+         }
+
+         if (*it == '"') {
+            // Quoted field
+            ++it; // Skip the opening quote
+
+            if constexpr (check_raw_string(Opts)) {
+               // Raw string mode: don't process escape sequences
+               while (it != end) {
+                  if (*it == '"') {
+                     ++it; // Skip the quote
+                     if (it == end || *it != '"') {
+                        // Single quote - end of field
+                        break;
+                     }
+                     // Double quote - add one quote and continue
+                     value.push_back('"');
+                     ++it;
+                  }
+                  else {
+                     value.push_back(*it);
+                     ++it;
+                  }
+               }
+            }
+            else {
+               // Normal mode: process escape sequences properly
+               while (it != end) {
+                  if (*it == '"') {
+                     ++it; // Skip the quote
+                     if (it == end) {
+                        // End of input after closing quote
+                        break;
+                     }
+                     if (*it == '"') {
+                        // Escaped quote
+                        value.push_back('"');
+                        ++it;
+                     }
+                     else {
+                        // Closing quote
+                        break;
+                     }
+                  }
+                  else {
+                     value.push_back(*it);
+                     ++it;
+                  }
+               }
             }
 
-            uint64_t temp;
-            auto s = stoui64(temp, it);
-            if (!s) [[unlikely]] {
-               ctx.error = error_code::expected_true_or_false;
+            // After closing quote, expect comma, newline, or end of input
+            if (it != end && *it != ',' && *it != '\n' && *it != '\r') {
+               // Invalid character after closing quote
+               ctx.error = error_code::syntax_error;
                return;
             }
-            value = static_cast<bool>(temp);
          }
-      };
+         else {
+            // Unquoted field
+            while (it != end && *it != ',' && *it != '\n' && *it != '\r') {
+               value.push_back(*it);
+               ++it;
+            }
+         }
+      }
+   };
 
-      template <readable_array_t T>
-      struct from_csv<T>
+   template <bool_t T>
+   struct from<CSV, T>
+   {
+      template <auto Opts, class It>
+      static void op(auto&& value, is_context auto&& ctx, It&& it, auto&& end) noexcept
       {
-         template <auto Opts, class It>
-         static void op(auto&& value, is_context auto&& ctx, It&& it, auto&& end) noexcept
-         {
-            read<csv>::op<Opts>(value.emplace_back(), ctx, it, end);
+         if (bool(ctx.error)) [[unlikely]] {
+            return;
          }
-      };
 
-      template <char delim>
-      inline void goto_delim(auto&& it, auto&& end) noexcept
-      {
-         while (++it != end && *it != delim)
-            ;
+         if (it == end) [[unlikely]] {
+            ctx.error = error_code::unexpected_end;
+            return;
+         }
+
+         uint64_t temp;
+         if (not glz::atoi(temp, it, end)) [[unlikely]] {
+            ctx.error = error_code::expected_true_or_false;
+            return;
+         }
+         value = static_cast<bool>(temp);
       }
+   };
 
-      inline auto read_column_wise_keys(auto&& ctx, auto&& it, auto&& end)
+   template <readable_array_t T>
+   struct from<CSV, T>
+   {
+      template <auto Opts, class It>
+      static void op(auto&& value, is_context auto&& ctx, It&& it, auto&& end)
       {
-         std::vector<std::pair<sv, size_t>> keys;
+         parse<CSV>::op<Opts>(value.emplace_back(), ctx, it, end);
+      }
+   };
 
-         auto read_key = [&](auto&& start, auto&& it) {
-            sv key{start, size_t(it - start)};
+   template <char delim>
+   inline void goto_delim(auto&& it, auto&& end) noexcept
+   {
+      while (it != end && *it != delim) {
+         ++it;
+      }
+   }
 
-            size_t csv_index{};
+   inline auto read_column_wise_keys(auto&& ctx, auto&& it, auto&& end)
+   {
+      std::vector<std::pair<sv, size_t>> keys;
 
-            const auto brace_pos = key.find('[');
-            if (brace_pos != sv::npos) {
-               const auto close_brace = key.find(']');
-               const auto index = key.substr(brace_pos + 1, close_brace - (brace_pos + 1));
-               key = key.substr(0, brace_pos);
-               const auto [ptr, ec] = std::from_chars(index.data(), index.data() + index.size(), csv_index);
-               if (ec != std::errc()) {
-                  ctx.error = error_code::syntax_error;
-                  return;
-               }
+      auto read_key = [&](auto&& start, auto&& it) {
+         sv key{start, size_t(it - start)};
+
+         size_t csv_index{};
+
+         const auto brace_pos = key.find('[');
+         if (brace_pos != sv::npos) {
+            const auto close_brace = key.find(']');
+            const auto index = key.substr(brace_pos + 1, close_brace - (brace_pos + 1));
+            key = key.substr(0, brace_pos);
+            const auto [ptr, ec] = std::from_chars(index.data(), index.data() + index.size(), csv_index);
+            if (ec != std::errc()) {
+               ctx.error = error_code::syntax_error;
+               return;
             }
+         }
 
-            keys.emplace_back(std::pair{key, csv_index});
-         };
+         keys.emplace_back(std::pair{key, csv_index});
+      };
 
-         auto start = it;
-         while (it != end) {
-            if (*it == ',') {
-               read_key(start, it);
+      auto start = it;
+      while (it != end) {
+         if (*it == ',') {
+            read_key(start, it);
+            ++it;
+            start = it;
+         }
+         else if (*it == '\r' || *it == '\n') {
+            auto line_end = it; // Position before incrementing
+            if (*it == '\r') {
                ++it;
-               start = it;
-            }
-            else if (*it == '\r' || *it == '\n') {
-               if (*it == '\r' && it[1] != '\n') [[unlikely]] {
+               if (it != end && *it != '\n') [[unlikely]] {
                   ctx.error = error_code::syntax_error;
                   return keys;
                }
+            }
 
-               if (start == it) {
-                  // trailing comma or empty
-               }
-               else {
-                  read_key(start, it);
-               }
-               break;
+            if (start == line_end) {
+               // trailing comma or empty
             }
             else {
-               ++it;
+               read_key(start, line_end); // Use original line ending position
             }
+            break;
+         }
+         else {
+            ++it;
          }
-
-         return keys;
       }
 
-      template <readable_map_t T>
-      struct from_csv<T>
+      return keys;
+   }
+
+   template <readable_map_t T>
+   struct from<CSV, T>
+   {
+      template <auto Opts, class It>
+      static void op(auto&& value, is_context auto&& ctx, It&& it, auto&& end)
       {
-         template <auto Opts, class It>
-         static void op(auto&& value, is_context auto&& ctx, It&& it, auto&& end)
-         {
-            if constexpr (Opts.layout == rowwise) {
-               while (it != end) {
-                  auto start = it;
-                  goto_delim<','>(it, end);
-                  sv key{start, static_cast<size_t>(it - start)};
-
-                  size_t csv_index;
-
-                  const auto brace_pos = key.find('[');
-                  if (brace_pos != sv::npos) {
-                     const auto close_brace = key.find(']');
-                     const auto index = key.substr(brace_pos + 1, close_brace - (brace_pos + 1));
-                     key = key.substr(0, brace_pos);
-                     const auto [ptr, ec] = std::from_chars(index.data(), index.data() + index.size(), csv_index);
-                     if (ec != std::errc()) {
-                        ctx.error = error_code::syntax_error;
-                        return;
-                     }
+         if constexpr (check_layout(Opts) == rowwise) {
+            while (it != end) {
+               auto start = it;
+               goto_delim<','>(it, end);
+               sv key{start, static_cast<size_t>(it - start)};
+
+               size_t csv_index{};
+
+               const auto brace_pos = key.find('[');
+               if (brace_pos != sv::npos) {
+                  const auto close_brace = key.find(']');
+                  const auto index = key.substr(brace_pos + 1, close_brace - (brace_pos + 1));
+                  key = key.substr(0, brace_pos);
+                  const auto [ptr, ec] = std::from_chars(index.data(), index.data() + index.size(), csv_index);
+                  if (ec != std::errc()) {
+                     ctx.error = error_code::syntax_error;
+                     return;
                   }
+               }
 
-                  GLZ_MATCH_COMMA;
+               if (it == end || *it != ',') [[unlikely]] {
+                  ctx.error = error_code::syntax_error;
+                  return;
+               }
+               ++it;
 
-                  using key_type = typename std::decay_t<decltype(value)>::key_type;
-                  auto& member = value[key_type(key)];
-                  using M = std::decay_t<decltype(member)>;
-                  if constexpr (fixed_array_value_t<M> && emplace_backable<M>) {
-                     size_t col = 0;
-                     while (it != end) {
-                        if (col < member.size()) [[likely]] {
-                           read<csv>::op<Opts>(member[col][csv_index], ctx, it, end);
-                        }
-                        else [[unlikely]] {
-                           read<csv>::op<Opts>(member.emplace_back()[csv_index], ctx, it, end);
-                        }
+               using key_type = typename std::decay_t<decltype(value)>::key_type;
+               auto& member = value[key_type(key)];
+               using M = std::decay_t<decltype(member)>;
+               if constexpr (fixed_array_value_t<M> && emplace_backable<M>) {
+                  size_t col = 0;
+                  while (it != end) {
+                     if (col < member.size()) [[likely]] {
+                        parse<CSV>::op<Opts>(member[col][csv_index], ctx, it, end);
+                     }
+                     else [[unlikely]] {
+                        parse<CSV>::op<Opts>(member.emplace_back()[csv_index], ctx, it, end);
+                     }
 
-                        if (*it == '\r') {
-                           ++it;
-                           if (*it == '\n') {
-                              ++it;
-                              break;
-                           }
-                           else [[unlikely]] {
-                              ctx.error = error_code::syntax_error;
-                              return;
-                           }
-                        }
-                        else if (*it == '\n') {
-                           ++it;
-                           break;
-                        }
+                     if (it == end) break;
 
-                        if (*it == ',') {
+                     if (*it == '\r') {
+                        ++it;
+                        if (it != end && *it == '\n') {
                            ++it;
                         }
-                        else {
-                           ctx.error = error_code::syntax_error;
-                           return;
-                        }
+                        break;
+                     }
+                     else if (*it == '\n') {
+                        ++it;
+                        break;
+                     }
 
-                        ++col;
+                     if (*it == ',') {
+                        ++it;
+                     }
+                     else {
+                        ctx.error = error_code::syntax_error;
+                        return;
                      }
+
+                     ++col;
                   }
-                  else {
-                     while (it != end) {
-                        read<csv>::op<Opts>(member, ctx, it, end);
+               }
+               else {
+                  while (it != end) {
+                     parse<CSV>::op<Opts>(member, ctx, it, end);
 
-                        if (*it == '\r') {
-                           ++it;
-                           if (*it == '\n') {
-                              ++it;
-                              break;
-                           }
-                           else [[unlikely]] {
-                              ctx.error = error_code::syntax_error;
-                              return;
-                           }
-                        }
-                        else if (*it == '\n') {
-                           ++it;
-                           break;
-                        }
+                     if (it == end) break;
 
-                        if (*it == ',') {
+                     if (*it == '\r') {
+                        ++it;
+                        if (it != end && *it == '\n') {
                            ++it;
                         }
-                        else {
-                           ctx.error = error_code::syntax_error;
-                           return;
-                        }
+                        break;
+                     }
+                     else if (*it == '\n') {
+                        ++it;
+                        break;
+                     }
+
+                     if (*it == ',') {
+                        ++it;
+                     }
+                     else {
+                        ctx.error = error_code::syntax_error;
+                        return;
                      }
                   }
                }
             }
-            else // column wise
-            {
-               const auto keys = read_column_wise_keys(ctx, it, end);
+         }
+         else // column wise
+         {
+            const auto keys = read_column_wise_keys(ctx, it, end);
 
-               if (bool(ctx.error)) {
-                  return;
-               }
+            if (bool(ctx.error)) {
+               return;
+            }
 
-               GLZ_CSV_NL;
+            if (csv_new_line(ctx, it, end)) {
+               return;
+            }
 
-               const auto n_keys = keys.size();
+            const auto n_keys = keys.size();
 
-               size_t row = 0;
+            size_t row = 0;
 
-               while (it != end) {
-                  for (size_t i = 0; i < n_keys; ++i) {
-                     using key_type = typename std::decay_t<decltype(value)>::key_type;
-                     auto& member = value[key_type(keys[i].first)];
-                     using M = std::decay_t<decltype(member)>;
-                     if constexpr (fixed_array_value_t<M> && emplace_backable<M>) {
-                        const auto index = keys[i].second;
-                        if (row < member.size()) [[likely]] {
-                           read<csv>::op<Opts>(member[row][index], ctx, it, end);
-                        }
-                        else [[unlikely]] {
-                           read<csv>::op<Opts>(member.emplace_back()[index], ctx, it, end);
-                        }
-                     }
-                     else {
-                        read<csv>::op<Opts>(member, ctx, it, end);
+            while (it != end) {
+               for (size_t i = 0; i < n_keys; ++i) {
+                  using key_type = typename std::decay_t<decltype(value)>::key_type;
+                  auto& member = value[key_type(keys[i].first)];
+                  using M = std::decay_t<decltype(member)>;
+                  if constexpr (fixed_array_value_t<M> && emplace_backable<M>) {
+                     const auto index = keys[i].second;
+                     if (row < member.size()) [[likely]] {
+                        parse<CSV>::op<Opts>(member[row][index], ctx, it, end);
                      }
-
-                     if (*it == ',') {
-                        ++it;
+                     else [[unlikely]] {
+                        parse<CSV>::op<Opts>(member.emplace_back()[index], ctx, it, end);
                      }
                   }
+                  else {
+                     parse<CSV>::op<Opts>(member, ctx, it, end);
+                  }
 
-                  if (*it == '\r') {
+                  if (it != end && *it == ',') {
                      ++it;
-                     if (*it == '\n') {
-                        ++it;
-                        ++row;
-                     }
-                     else [[unlikely]] {
-                        ctx.error = error_code::syntax_error;
-                        return;
-                     }
                   }
-                  else if (*it == '\n') {
+               }
+
+               if (it == end) break;
+
+               if (*it == '\r') {
+                  ++it;
+                  if (it != end && *it == '\n') {
                      ++it;
                      ++row;
                   }
+                  else [[unlikely]] {
+                     ctx.error = error_code::syntax_error;
+                     return;
+                  }
+               }
+               else if (*it == '\n') {
+                  ++it;
+                  ++row;
                }
             }
          }
-      };
+      }
+   };
+
+   // For types like std::vector<T> where T is a struct/object
+   template <readable_array_t T>
+      requires(glaze_object_t<typename T::value_type> || reflectable<typename T::value_type>)
+   struct from<CSV, T>
+   {
+      using U = typename T::value_type;
 
-      template <class T>
-         requires(glaze_object_t<T> || reflectable<T>)
-      struct from_csv<T>
+      template <auto Opts, class It>
+      static void op(auto&& value, is_context auto&& ctx, It&& it, auto&& end)
       {
-         template <auto Opts, class It>
-         static void op(auto&& value, is_context auto&& ctx, It&& it, auto&& end)
-         {
-            static constexpr auto num_members = reflection_count<T>;
-
-            decltype(auto) frozen_map = [&]() -> decltype(auto) {
-               if constexpr (reflectable<T> && num_members > 0) {
-#if ((defined _MSC_VER) && (!defined __clang__))
-                  static thread_local auto cmap = make_map<T, Opts.use_hash_comparison>();
-#else
-                  static thread_local constinit auto cmap = make_map<T, Opts.use_hash_comparison>();
-#endif
-                  // We want to run this populate outside of the while loop
-                  populate_map(value, cmap); // Function required for MSVC to build
-                  return cmap;
+         static constexpr auto N = reflect<U>::size;
+         static constexpr auto HashInfo = hash_info<U>;
+
+         // Clear existing data if not appending
+         if constexpr (!Opts.append_arrays) {
+            value.clear();
+         }
+
+         if constexpr (check_layout(Opts) == colwise) {
+            // Read column headers
+            std::vector<size_t> member_indices;
+
+            if constexpr (check_use_headers(Opts)) {
+               auto headers = read_column_wise_keys(ctx, it, end);
+
+               if (bool(ctx.error)) [[unlikely]] {
+                  return;
                }
-               else if constexpr (glaze_object_t<T> && num_members > 0) {
-                  static constexpr auto cmap = make_map<T, Opts.use_hash_comparison>();
-                  return cmap;
+
+               if (csv_new_line(ctx, it, end)) {
+                  return;
                }
-               else {
-                  return nullptr;
+
+               // Map header names to member indices
+               for (const auto& [key, idx] : headers) {
+                  const auto member_idx = decode_hash_with_size<CSV, U, HashInfo, HashInfo.type>::op(
+                     key.data(), key.data() + key.size(), key.size());
+
+                  if (member_idx >= N) [[unlikely]] {
+                     ctx.error = error_code::unknown_key;
+                     return;
+                  }
+
+                  member_indices.push_back(member_idx);
+               }
+            }
+            else {
+               // Use default order of members
+               for (size_t i = 0; i < N; ++i) {
+                  member_indices.push_back(i);
                }
-            }();
+            }
 
-            if constexpr (Opts.layout == rowwise) {
-               while (it != end) {
-                  auto start = it;
-                  goto_delim<','>(it, end);
-                  sv key{start, static_cast<size_t>(it - start)};
-
-                  size_t csv_index{};
-
-                  const auto brace_pos = key.find('[');
-                  if (brace_pos != sv::npos) {
-                     const auto close_brace = key.find(']');
-                     const auto index = key.substr(brace_pos + 1, close_brace - (brace_pos + 1));
-                     key = key.substr(0, brace_pos);
-                     const auto [ptr, ec] = std::from_chars(index.data(), index.data() + index.size(), csv_index);
-                     if (ec != std::errc()) [[unlikely]] {
+            const auto n_cols = member_indices.size();
+
+            // Read rows
+            while (it != end) {
+               U struct_value{};
+
+               for (size_t i = 0; i < n_cols; ++i) {
+                  const auto member_idx = member_indices[i];
+
+                  visit<N>(
+                     [&]<size_t I>() {
+                        if (I == member_idx) {
+                           decltype(auto) member = [&]() -> decltype(auto) {
+                              if constexpr (reflectable<U>) {
+                                 return get_member(struct_value, get<I>(to_tie(struct_value)));
+                              }
+                              else {
+                                 return get_member(struct_value, get<I>(reflect<U>::values));
+                              }
+                           }();
+
+                           parse<CSV>::op<Opts>(member, ctx, it, end);
+                        }
+                     },
+                     member_idx);
+
+                  if (bool(ctx.error)) [[unlikely]] {
+                     return;
+                  }
+
+                  if (i < n_cols - 1) {
+                     if (it == end || *it != ',') [[unlikely]] {
                         ctx.error = error_code::syntax_error;
                         return;
                      }
+                     ++it;
                   }
+               }
 
-                  GLZ_MATCH_COMMA;
+               value.push_back(std::move(struct_value));
 
-                  const auto& member_it = frozen_map.find(key);
+               if (it == end) {
+                  break;
+               }
 
-                  if (member_it != frozen_map.end()) [[likely]] {
-                     std::visit(
-                        [&](auto&& member_ptr) {
-                           auto&& member = get_member(value, member_ptr);
-                           using M = std::decay_t<decltype(member)>;
-                           if constexpr (fixed_array_value_t<M> && emplace_backable<M>) {
-                              size_t col = 0;
-                              while (it != end) {
-                                 if (col < member.size()) [[likely]] {
-                                    read<csv>::op<Opts>(member[col][csv_index], ctx, it, end);
-                                 }
-                                 else [[unlikely]] {
-                                    read<csv>::op<Opts>(member.emplace_back()[csv_index], ctx, it, end);
-                                 }
+               // Handle newlines
+               if (*it == '\r') {
+                  ++it;
+                  if (it != end && *it == '\n') {
+                     ++it;
+                  }
+                  else [[unlikely]] {
+                     ctx.error = error_code::syntax_error;
+                     return;
+                  }
+               }
+               else if (*it == '\n') {
+                  ++it;
+               }
+               else [[unlikely]] {
+                  ctx.error = error_code::syntax_error;
+                  return;
+               }
 
-                                 if (*it == '\r') {
-                                    ++it;
-                                    if (*it == '\n') {
-                                       ++it;
-                                       break;
-                                    }
-                                    else [[unlikely]] {
-                                       ctx.error = error_code::syntax_error;
-                                       return;
-                                    }
-                                 }
-                                 else if (*it == '\n') {
-                                    ++it;
-                                    break;
-                                 }
-                                 else if (it == end) {
-                                    return;
-                                 }
+               if (it == end) {
+                  break;
+               }
+            }
+         }
+         else // rowwise layout
+         {
+            // Row-wise isn't a typical format for vector of structs in CSV
+            // But we could implement if needed
+            ctx.error = error_code::feature_not_supported;
+            return;
+         }
+      }
+   };
+
+   template <class T>
+      requires((glaze_object_t<T> || reflectable<T>) && not custom_read<T>)
+   struct from<CSV, T>
+   {
+      template <auto Opts, class It>
+      static void op(auto&& value, is_context auto&& ctx, It&& it, auto&& end)
+      {
+         static constexpr auto N = reflect<T>::size;
+         static constexpr auto HashInfo = hash_info<T>;
+
+         if constexpr (check_layout(Opts) == rowwise) {
+            while (it != end) {
+               auto start = it;
+               goto_delim<','>(it, end);
+               sv key{start, static_cast<size_t>(it - start)};
+
+               size_t csv_index{};
+
+               const auto brace_pos = key.find('[');
+               if (brace_pos != sv::npos) {
+                  const auto close_brace = key.find(']');
+                  const auto index = key.substr(brace_pos + 1, close_brace - (brace_pos + 1));
+                  key = key.substr(0, brace_pos);
+                  const auto [ptr, ec] = std::from_chars(index.data(), index.data() + index.size(), csv_index);
+                  if (ec != std::errc()) [[unlikely]] {
+                     ctx.error = error_code::syntax_error;
+                     return;
+                  }
+               }
+
+               if (it == end || *it != ',') [[unlikely]] {
+                  ctx.error = error_code::syntax_error;
+                  return;
+               }
+               ++it;
+
+               const auto index = decode_hash_with_size<CSV, T, HashInfo, HashInfo.type>::op(
+                  key.data(), key.data() + key.size(), key.size());
+
+               if (index < N) [[likely]] {
+                  visit<N>(
+                     [&]<size_t I>() {
+                        decltype(auto) member = [&]() -> decltype(auto) {
+                           if constexpr (reflectable<T>) {
+                              return get_member(value, get<I>(to_tie(value)));
+                           }
+                           else {
+                              return get_member(value, get<I>(reflect<T>::values));
+                           }
+                        }();
+
+                        using M = std::decay_t<decltype(member)>;
+                        if constexpr (fixed_array_value_t<M> && emplace_backable<M>) {
+                           size_t col = 0;
+                           while (it != end) {
+                              if (col < member.size()) [[likely]] {
+                                 parse<CSV>::op<Opts>(member[col][csv_index], ctx, it, end);
+                              }
+                              else [[unlikely]] {
+                                 parse<CSV>::op<Opts>(member.emplace_back()[csv_index], ctx, it, end);
+                              }
 
-                                 if (*it == ',') [[likely]] {
+                              if (it == end) break;
+
+                              if (*it == '\r') {
+                                 ++it;
+                                 if (it != end && *it == '\n') {
                                     ++it;
+                                    break;
                                  }
                                  else [[unlikely]] {
                                     ctx.error = error_code::syntax_error;
                                     return;
                                  }
+                              }
+                              else if (*it == '\n') {
+                                 ++it;
+                                 break;
+                              }
 
-                                 ++col;
+                              if (*it == ',') [[likely]] {
+                                 ++it;
                               }
+                              else [[unlikely]] {
+                                 ctx.error = error_code::syntax_error;
+                                 return;
+                              }
+
+                              ++col;
                            }
-                           else {
-                              while (it != end) {
-                                 read<csv>::op<Opts>(member, ctx, it, end);
+                        }
+                        else {
+                           while (it != end) {
+                              parse<CSV>::op<Opts>(member, ctx, it, end);
 
-                                 if (*it == '\r') {
-                                    ++it;
-                                    if (*it == '\n') {
-                                       ++it;
-                                       break;
-                                    }
-                                    else [[unlikely]] {
-                                       ctx.error = error_code::syntax_error;
-                                       return;
-                                    }
-                                 }
-                                 else if (*it == '\n') {
-                                    ++it;
-                                    break;
-                                 }
+                              if (it == end) break;
 
-                                 if (*it == ',') [[likely]] {
+                              if (*it == '\r') {
+                                 ++it;
+                                 if (it != end && *it == '\n') {
                                     ++it;
+                                    break;
                                  }
                                  else [[unlikely]] {
                                     ctx.error = error_code::syntax_error;
                                     return;
                                  }
                               }
+                              else if (*it == '\n') {
+                                 ++it;
+                                 break;
+                              }
+
+                              if (*it == ',') [[likely]] {
+                                 ++it;
+                              }
+                              else [[unlikely]] {
+                                 ctx.error = error_code::syntax_error;
+                                 return;
+                              }
                            }
-                        },
-                        member_it->second);
+                        }
+                     },
+                     index);
 
-                     if (bool(ctx.error)) [[unlikely]] {
-                        return;
-                     }
-                  }
-                  else [[unlikely]] {
-                     ctx.error = error_code::unknown_key;
+                  if (bool(ctx.error)) [[unlikely]] {
                      return;
                   }
                }
-            }
-            else // column wise
-            {
-               const auto keys = read_column_wise_keys(ctx, it, end);
-
-               if (bool(ctx.error)) [[unlikely]] {
+               else [[unlikely]] {
+                  ctx.error = error_code::unknown_key;
                   return;
                }
+            }
+         }
+         else // column wise
+         {
+            const auto keys = read_column_wise_keys(ctx, it, end);
+
+            if (bool(ctx.error)) [[unlikely]] {
+               return;
+            }
 
-               GLZ_CSV_NL;
-
-               const auto n_keys = keys.size();
-
-               size_t row = 0;
-
-               bool at_end{it == end};
-               if (!at_end) {
-                  while (true) {
-                     for (size_t i = 0; i < n_keys; ++i) {
-                        const auto& member_it = frozen_map.find(keys[i].first);
-                        if (member_it != frozen_map.end()) [[likely]] {
-                           std::visit(
-                              [&](auto&& member_ptr) {
-                                 auto&& member = get_member(value, member_ptr);
-                                 using M = std::decay_t<decltype(member)>;
-                                 if constexpr (fixed_array_value_t<M> && emplace_backable<M>) {
-                                    const auto index = keys[i].second;
-                                    if (row < member.size()) [[likely]] {
-                                       read<csv>::op<Opts>(member[row][index], ctx, it, end);
+            if (csv_new_line(ctx, it, end)) {
+               return;
+            }
+
+            const auto n_keys = keys.size();
+
+            size_t row = 0;
+
+            bool at_end{it == end};
+            if (!at_end) {
+               while (true) {
+                  for (size_t i = 0; i < n_keys; ++i) {
+                     const auto key = keys[i].first;
+                     const auto index = decode_hash_with_size<CSV, T, HashInfo, HashInfo.type>::op(
+                        key.data(), key.data() + key.size(), key.size());
+
+                     if (index < N) [[likely]] {
+                        visit<N>(
+                           [&]<size_t I>() {
+                              decltype(auto) member = [&]() -> decltype(auto) {
+                                 if constexpr (reflectable<T>) {
+                                    return get_member(value, get<I>(to_tie(value)));
+                                 }
+                                 else {
+                                    return get_member(value, get<I>(reflect<T>::values));
+                                 }
+                              }();
+
+                              using M = std::decay_t<decltype(member)>;
+                              if constexpr (fixed_array_value_t<M> && emplace_backable<M>) {
+                                 const auto index = keys[i].second;
+                                 if (row < member.size()) [[likely]] {
+                                    auto& element = member[row];
+                                    if (index < element.size()) {
+                                       parse<CSV>::op<Opts>(element[index], ctx, it, end);
                                     }
-                                    else [[unlikely]] {
-                                       read<csv>::op<Opts>(member.emplace_back()[index], ctx, it, end);
+                                    else {
+                                       ctx.error = error_code::syntax_error;
+                                       return;
                                     }
                                  }
-                                 else {
-                                    read<csv>::op<Opts>(member, ctx, it, end);
+                                 else [[unlikely]] {
+                                    auto& element = member.emplace_back();
+                                    if (index < element.size()) {
+                                       parse<CSV>::op<Opts>(element[index], ctx, it, end);
+                                    }
+                                    else {
+                                       ctx.error = error_code::syntax_error;
+                                       return;
+                                    }
                                  }
-                              },
-                              member_it->second);
-                        }
-                        else [[unlikely]] {
-                           ctx.error = error_code::unknown_key;
+                              }
+                              else {
+                                 parse<CSV>::op<Opts>(member, ctx, it, end);
+                              }
+                           },
+                           index);
+
+                        if (bool(ctx.error)) [[unlikely]] {
                            return;
                         }
-                        at_end = it == end;
-                        if (!at_end && *it == ',') {
-                           ++it;
-                           at_end = it == end;
-                        }
                      }
-                     if (!at_end) [[likely]] {
-                        GLZ_CSV_NL;
+                     else [[unlikely]] {
+                        ctx.error = error_code::unknown_key;
+                        return;
+                     }
 
-                        ++row;
+                     at_end = it == end;
+                     if (!at_end && *it == ',') {
+                        ++it;
                         at_end = it == end;
-                        if (at_end) break;
                      }
-                     else
-                        break;
+                  }
+                  if (!at_end) [[likely]] {
+                     if (csv_new_line(ctx, it, end)) {
+                        return;
+                     }
+
+                     ++row;
+                     at_end = it == end;
+                     if (at_end) break;
+                  }
+                  else {
+                     break;
                   }
                }
             }
          }
-      };
-   }
+      }
+   };
 
-   template <uint32_t layout = rowwise, read_csv_supported T, class Buffer>
-   [[nodiscard]] inline auto read_csv(T&& value, Buffer&& buffer) noexcept
+   template <uint32_t layout = rowwise, read_supported<CSV> T, class Buffer>
+   [[nodiscard]] inline auto read_csv(T&& value, Buffer&& buffer)
    {
-      return read<opts{.format = csv, .layout = layout}>(value, std::forward<Buffer>(buffer));
+      return read<opts_csv{.layout = layout}>(value, std::forward<Buffer>(buffer));
    }
 
-   template <uint32_t layout = rowwise, read_csv_supported T, class Buffer>
-   [[nodiscard]] inline auto read_csv(Buffer&& buffer) noexcept
+   template <uint32_t layout = rowwise, read_supported<CSV> T, class Buffer>
+   [[nodiscard]] inline auto read_csv(Buffer&& buffer)
    {
       T value{};
-      read<opts{.format = csv, .layout = layout}>(value, std::forward<Buffer>(buffer));
+      read<opts_csv{.layout = layout}>(value, std::forward<Buffer>(buffer));
       return value;
    }
 
-   template <uint32_t layout = rowwise, read_csv_supported T>
-   [[nodiscard]] inline error_ctx read_file_csv(T& value, const sv file_name)
+   template <uint32_t layout = rowwise, read_supported<CSV> T, is_buffer Buffer>
+   [[nodiscard]] inline error_ctx read_file_csv(T& value, const sv file_name, Buffer&& buffer)
    {
       context ctx{};
       ctx.current_file = file_name;
 
-      std::string buffer;
       const auto ec = file_to_buffer(buffer, ctx.current_file);
 
       if (bool(ec)) {
          return {ec};
       }
 
-      return read<opts{.format = csv, .layout = layout}>(value, buffer, ctx);
+      return read<opts_csv{.layout = layout}>(value, buffer, ctx);
    }
 }
diff --git a/deps/saucer/include/glaze/csv/write.hpp b/deps/saucer/include/glaze/csv/write.hpp
index 92fbc36..6a84cb1 100644
--- a/deps/saucer/include/glaze/csv/write.hpp
+++ b/deps/saucer/include/glaze/csv/write.hpp
@@ -11,124 +11,125 @@
 
 namespace glz
 {
-   namespace detail
+   template <>
+   struct serialize<CSV>
    {
-      template <>
-      struct write<csv>
+      template <auto Opts, class T, is_context Ctx, class B, class IX>
+      static void op(T&& value, Ctx&& ctx, B&& b, IX&& ix)
       {
-         template <auto Opts, class T, is_context Ctx, class B, class IX>
-         static void op(T&& value, Ctx&& ctx, B&& b, IX&& ix) noexcept
-         {
-            to_csv<std::decay_t<T>>::template op<Opts>(std::forward<T>(value), std::forward<Ctx>(ctx),
-                                                       std::forward<B>(b), std::forward<IX>(ix));
-         }
-      };
+         to<CSV, std::decay_t<T>>::template op<Opts>(std::forward<T>(value), std::forward<Ctx>(ctx), std::forward<B>(b),
+                                                     std::forward<IX>(ix));
+      }
+   };
 
-      template <glaze_value_t T>
-      struct to_csv<T>
+   template <glaze_value_t T>
+   struct to<CSV, T>
+   {
+      template <auto Opts, is_context Ctx, class B, class IX>
+      static void op(auto&& value, Ctx&& ctx, B&& b, IX&& ix)
       {
-         template <auto Opts, is_context Ctx, class B, class IX>
-         static void op(auto&& value, Ctx&& ctx, B&& b, IX&& ix) noexcept
-         {
-            using V = decltype(get_member(std::declval<T>(), meta_wrapper_v<T>));
-            to_csv<V>::template op<Opts>(get_member(value, meta_wrapper_v<T>), std::forward<Ctx>(ctx),
-                                         std::forward<B>(b), std::forward<IX>(ix));
-         }
-      };
+         using V = decltype(get_member(std::declval<T>(), meta_wrapper_v<T>));
+         to<CSV, V>::template op<Opts>(get_member(value, meta_wrapper_v<T>), std::forward<Ctx>(ctx), std::forward<B>(b),
+                                       std::forward<IX>(ix));
+      }
+   };
 
-      template <num_t T>
-      struct to_csv<T>
+   template <num_t T>
+   struct to<CSV, T>
+   {
+      template <auto Opts, class B>
+      static void op(auto&& value, is_context auto&& ctx, B&& b, auto&& ix)
       {
-         template <auto Opts, class B>
-         static void op(auto&& value, is_context auto&& ctx, B&& b, auto&& ix) noexcept
-         {
-            write_chars::op<Opts>(value, ctx, b, ix);
-         }
-      };
+         write_chars::op<Opts>(value, ctx, b, ix);
+      }
+   };
 
-      template <bool_t T>
-      struct to_csv<T>
+   template <bool_t T>
+   struct to<CSV, T>
+   {
+      template <auto Opts, class B>
+      static void op(auto&& value, is_context auto&&, B&& b, auto&& ix)
       {
-         template <auto Opts, class B>
-         static void op(auto&& value, is_context auto&&, B&& b, auto&& ix) noexcept
-         {
-            if (value) {
-               dump<'1'>(b, ix);
-            }
-            else {
-               dump<'0'>(b, ix);
-            }
+         if (value) {
+            dump<'1'>(b, ix);
+         }
+         else {
+            dump<'0'>(b, ix);
          }
-      };
+      }
+   };
 
-      template <writable_array_t T>
-      struct to_csv<T>
+   template <writable_array_t T>
+   struct to<CSV, T>
+   {
+      template <auto Opts, class B>
+      static void op(auto&& value, is_context auto&& ctx, B&& b, auto&& ix)
       {
-         template <auto Opts, class B>
-         static void op(auto&& value, is_context auto&& ctx, B&& b, auto&& ix) noexcept
-         {
-            if constexpr (resizable<T>) {
-               if constexpr (Opts.layout == rowwise) {
-                  const auto n = value.size();
-                  for (size_t i = 0; i < n; ++i) {
-                     write<csv>::op<Opts>(value[i], ctx, b, ix);
-
-                     if (i != (n - 1)) {
-                        dump<','>(b, ix);
-                     }
-                  }
-               }
-               else {
-                  static_assert(false_v<T>, "Dynamic arrays within dynamic arrays are unsupported");
-               }
-            }
-            else {
+         if constexpr (resizable<T>) {
+            if constexpr (check_layout(Opts) == rowwise) {
                const auto n = value.size();
                for (size_t i = 0; i < n; ++i) {
-                  write<csv>::op<Opts>(value[i], ctx, b, ix);
+                  serialize<CSV>::op<Opts>(value[i], ctx, b, ix);
 
                   if (i != (n - 1)) {
                      dump<','>(b, ix);
                   }
                }
             }
+            else {
+               static_assert(false_v<T>, "Dynamic arrays within dynamic arrays are unsupported");
+            }
          }
-      };
+         else {
+            const auto n = value.size();
+            for (size_t i = 0; i < n; ++i) {
+               serialize<CSV>::op<Opts>(value[i], ctx, b, ix);
 
-      template <class T>
-         requires str_t<T> || char_t<T>
-      struct to_csv<T>
-      {
-         template <auto Opts, class B>
-         static void op(auto&& value, is_context auto&&, B&& b, auto&& ix) noexcept
-         {
-            dump_maybe_empty(value, b, ix);
+               if (i != (n - 1)) {
+                  dump<','>(b, ix);
+               }
+            }
          }
-      };
+      }
+   };
 
-      template <writable_map_t T>
-      struct to_csv<T>
+   template <class T>
+      requires str_t<T> || char_t<T>
+   struct to<CSV, T>
+   {
+      template <auto Opts, class B>
+      static void op(auto&& value, is_context auto&&, B&& b, auto&& ix)
       {
-         template <auto Opts, class B>
-         static void op(auto&& value, is_context auto&& ctx, B&& b, auto&& ix) noexcept
-         {
-            if constexpr (Opts.layout == rowwise) {
-               for (auto& [name, data] : value) {
+         dump_maybe_empty(value, b, ix);
+      }
+   };
+
+   template <writable_map_t T>
+   struct to<CSV, T>
+   {
+      template <auto Opts, class B>
+      static void op(auto&& value, is_context auto&& ctx, B&& b, auto&& ix)
+      {
+         if constexpr (check_layout(Opts) == rowwise) {
+            for (auto& [name, data] : value) {
+               if constexpr (check_use_headers(Opts)) {
                   dump_maybe_empty(name, b, ix);
                   dump<','>(b, ix);
-                  const auto n = data.size();
-                  for (size_t i = 0; i < n; ++i) {
-                     write<csv>::op<Opts>(data[i], ctx, b, ix);
-                     if (i < n - 1) {
-                        dump<','>(b, ix);
-                     }
+               }
+               const auto n = data.size();
+               for (size_t i = 0; i < n; ++i) {
+                  serialize<CSV>::op<Opts>(data[i], ctx, b, ix);
+                  if (i < n - 1) {
+                     dump<','>(b, ix);
                   }
-                  dump<'\n'>(b, ix);
                }
+               dump<'\n'>(b, ix);
             }
-            else {
-               // dump titles
-               const auto n = value.size();
+         }
+         else {
+            // dump titles
+            const auto n = value.size();
+            if constexpr (check_use_headers(Opts)) {
                size_t i = 0;
                for (auto& [name, data] : value) {
                   dump_maybe_empty(name, b, ix);
@@ -137,123 +138,120 @@ namespace glz
                      dump<','>(b, ix);
                   }
                }
-
                dump<'\n'>(b, ix);
+            }
 
-               size_t row = 0;
-               bool end = false;
-               while (true) {
-                  i = 0;
-                  for (auto& [name, data] : value) {
-                     if (row >= data.size()) {
-                        end = true;
-                        break;
-                     }
-
-                     write<csv>::op<Opts>(data[row], ctx, b, ix);
-                     ++i;
-                     if (i < n) {
-                        dump<','>(b, ix);
-                     }
-                  }
-
-                  if (end) {
+            size_t row = 0;
+            bool end = false;
+            while (true) {
+               size_t i = 0;
+               for (auto& [name, data] : value) {
+                  if (row >= data.size()) {
+                     end = true;
                      break;
                   }
 
-                  dump<'\n'>(b, ix);
+                  serialize<CSV>::op<Opts>(data[row], ctx, b, ix);
+                  ++i;
+                  if (i < n) {
+                     dump<','>(b, ix);
+                  }
+               }
 
-                  ++row;
+               if (end) {
+                  break;
                }
+
+               dump<'\n'>(b, ix);
+
+               ++row;
             }
          }
-      };
+      }
+   };
 
-      template <class T>
-         requires(glaze_object_t<T> || reflectable<T>)
-      struct to_csv<T>
+   template <class T>
+      requires((glaze_object_t<T> || reflectable<T>) && not custom_write<T>)
+   struct to<CSV, T>
+   {
+      template <auto Opts, class B>
+      static void op(auto&& value, is_context auto&& ctx, B&& b, auto&& ix)
       {
-         template <auto Opts, class B>
-         static void op(auto&& value, is_context auto&& ctx, B&& b, auto&& ix) noexcept
-         {
-            using V = std::decay_t<T>;
-
-            static constexpr auto N = reflection_count<T>;
+         static constexpr auto N = reflect<T>::size;
 
-            [[maybe_unused]] decltype(auto) t = [&] {
-               if constexpr (reflectable<T>) {
-                  return to_tuple(value);
-               }
-               else {
-                  return nullptr;
-               }
-            }();
-
-            if constexpr (Opts.layout == rowwise) {
-               for_each<N>([&](auto I) {
-                  using Element = glaze_tuple_element<I, N, T>;
-                  static constexpr size_t member_index = Element::member_index;
-
-                  using item_type = typename std::decay<typename Element::type>::type;
-                  using value_type = typename item_type::value_type;
+         [[maybe_unused]] decltype(auto) t = [&] {
+            if constexpr (reflectable<T>) {
+               return to_tie(value);
+            }
+            else {
+               return nullptr;
+            }
+         }();
 
-                  static constexpr sv key = key_name<I, T, Element::use_reflection>;
+         if constexpr (check_layout(Opts) == rowwise) {
+            for_each<N>([&]<auto I>() {
+               using value_type = typename std::decay_t<refl_t<T, I>>::value_type;
 
-                  decltype(auto) mem = [&]() -> decltype(auto) {
-                     if constexpr (reflectable<T>) {
-                        return std::get<I>(t);
-                     }
-                     else {
-                        return get<member_index>(get<I>(meta_v<V>));
-                     }
-                  }();
+               static constexpr sv key = reflect<T>::keys[I];
 
-                  if constexpr (writable_array_t<value_type>) {
-                     decltype(auto) member = get_member(value, mem);
-                     const auto count = member.size();
-                     const auto size = member[0].size();
-                     for (size_t i = 0; i < size; ++i) {
+               decltype(auto) mem = [&]() -> decltype(auto) {
+                  if constexpr (reflectable<T>) {
+                     return get<I>(t);
+                  }
+                  else {
+                     return get<I>(reflect<T>::values);
+                  }
+               }();
+
+               if constexpr (writable_array_t<value_type>) {
+                  decltype(auto) member = get_member(value, mem);
+                  const auto count = member.size();
+                  const auto size = member[0].size();
+                  for (size_t i = 0; i < size; ++i) {
+                     if constexpr (check_use_headers(Opts)) {
                         dump<key>(b, ix);
                         dump<'['>(b, ix);
                         write_chars::op<Opts>(i, ctx, b, ix);
                         dump<']'>(b, ix);
                         dump<','>(b, ix);
+                     }
 
-                        for (size_t j = 0; j < count; ++j) {
-                           write<csv>::op<Opts>(member[j][i], ctx, b, ix);
-                           if (j != count - 1) {
-                              dump<','>(b, ix);
-                           }
+                     for (size_t j = 0; j < count; ++j) {
+                        serialize<CSV>::op<Opts>(member[j][i], ctx, b, ix);
+                        if (j != count - 1) {
+                           dump<','>(b, ix);
                         }
+                     }
 
-                        if (i != size - 1) {
-                           dump<'\n'>(b, ix);
-                        }
+                     if (i != size - 1) {
+                        dump<'\n'>(b, ix);
                      }
                   }
-                  else {
+               }
+               else {
+                  if constexpr (check_use_headers(Opts)) {
                      dump<key>(b, ix);
                      dump<','>(b, ix);
-                     write<csv>::op<Opts>(get_member(value, mem), ctx, b, ix);
-                     dump<'\n'>(b, ix);
                   }
-               });
-            }
-            else {
-               // write titles
-               for_each<N>([&](auto I) {
-                  using Element = glaze_tuple_element<I, N, T>;
-                  static constexpr size_t member_index = Element::member_index;
-                  using X = std::decay_t<typename Element::type>;
+                  serialize<CSV>::op<Opts>(get_member(value, mem), ctx, b, ix);
+                  dump<'\n'>(b, ix);
+               }
+            });
+         }
+         else {
+            // write titles
+            if constexpr (check_use_headers(Opts)) {
+               for_each<N>([&]<auto I>() {
+                  using X = refl_t<T, I>;
 
-                  static constexpr sv key = key_name<I, T, Element::use_reflection>;
+                  static constexpr sv key = reflect<T>::keys[I];
 
                   decltype(auto) member = [&]() -> decltype(auto) {
                      if constexpr (reflectable<T>) {
-                        return std::get<I>(t);
+                        return get<I>(t);
                      }
                      else {
-                        return get<member_index>(get<I>(meta_v<V>));
+                        return get<I>(reflect<T>::values);
                      }
                   }();
 
@@ -270,93 +268,141 @@ namespace glz
                      }
                   }
                   else {
-                     write<csv>::op<Opts>(key, ctx, b, ix);
+                     serialize<CSV>::op<Opts>(key, ctx, b, ix);
                   }
 
-                  if (I != N - 1) {
+                  if constexpr (I != N - 1) {
                      dump<','>(b, ix);
                   }
                });
 
                dump<'\n'>(b, ix);
+            }
 
-               size_t row = 0;
-               bool end = false;
-
-               while (true) {
-                  for_each<N>([&](auto I) {
-                     using Element = glaze_tuple_element<I, N, T>;
-                     static constexpr size_t member_index = Element::member_index;
-                     using X = std::decay_t<typename Element::type>;
+            size_t row = 0;
+            bool end = false;
 
-                     decltype(auto) mem = [&]() -> decltype(auto) {
-                        if constexpr (reflectable<T>) {
-                           return std::get<I>(t);
-                        }
-                        else {
-                           return get<member_index>(get<I>(meta_v<V>));
-                        }
-                     }();
-
-                     if constexpr (fixed_array_value_t<X>) {
-                        decltype(auto) member = get_member(value, mem);
-                        if (row >= member.size()) {
-                           end = true;
-                           return;
-                        }
+            while (true) {
+               for_each<N>([&]<auto I>() {
+                  using X = std::decay_t<refl_t<T, I>>;
 
-                        const auto n = member[0].size();
-                        for (size_t i = 0; i < n; ++i) {
-                           write<csv>::op<Opts>(member[row][i], ctx, b, ix);
-                           if (i != n - 1) {
-                              dump<','>(b, ix);
-                           }
-                        }
+                  decltype(auto) mem = [&]() -> decltype(auto) {
+                     if constexpr (reflectable<T>) {
+                        return get<I>(t);
                      }
                      else {
-                        decltype(auto) member = get_member(value, mem);
-                        if (row >= member.size()) {
-                           end = true;
-                           return;
-                        }
+                        return get<I>(reflect<T>::values);
+                     }
+                  }();
 
-                        write<csv>::op<Opts>(member[row], ctx, b, ix);
+                  if constexpr (fixed_array_value_t<X>) {
+                     decltype(auto) member = get_member(value, mem);
+                     if (row >= member.size()) {
+                        end = true;
+                        return;
+                     }
 
-                        if (I != N - 1) {
+                     const auto n = member[0].size();
+                     for (size_t i = 0; i < n; ++i) {
+                        serialize<CSV>::op<Opts>(member[row][i], ctx, b, ix);
+                        if (i != n - 1) {
                            dump<','>(b, ix);
                         }
                      }
-                  });
-
-                  if (end) {
-                     break;
                   }
+                  else {
+                     decltype(auto) member = get_member(value, mem);
+                     if (row >= member.size()) {
+                        end = true;
+                        return;
+                     }
 
-                  ++row;
+                     serialize<CSV>::op<Opts>(member[row], ctx, b, ix);
 
-                  dump<'\n'>(b, ix);
+                     if (I != N - 1) {
+                        dump<','>(b, ix);
+                     }
+                  }
+               });
+
+               if (end) {
+                  break;
                }
+
+               ++row;
+
+               dump<'\n'>(b, ix);
             }
          }
-      };
-   }
+      }
+   };
+
+   // For types like std::vector<T> where T is a struct/object
+   template <writable_array_t T>
+      requires(glaze_object_t<typename T::value_type> || reflectable<typename T::value_type>)
+   struct to<CSV, T>
+   {
+      using U = typename T::value_type;
+
+      template <auto Opts, class B>
+      static void op(auto&& value, is_context auto&& ctx, B&& b, auto&& ix)
+      {
+         static constexpr auto N = reflect<U>::size;
+
+         // Write headers (field names) if enabled
+         if constexpr (check_use_headers(Opts)) {
+            for_each<N>([&]<auto I>() {
+               static constexpr sv key = reflect<U>::keys[I];
+               serialize<CSV>::op<Opts>(key, ctx, b, ix);
+
+               if (I < N - 1) {
+                  dump<','>(b, ix);
+               }
+            });
+
+            dump<'\n'>(b, ix);
+         }
+
+         // Write each struct as a row
+         for (const auto& item : value) {
+            for_each<N>([&]<auto I>() {
+               decltype(auto) mem = [&]() -> decltype(auto) {
+                  if constexpr (reflectable<U>) {
+                     return get<I>(to_tie(item));
+                  }
+                  else {
+                     return get<I>(reflect<U>::values);
+                  }
+               }();
+
+               serialize<CSV>::op<Opts>(get_member(item, mem), ctx, b, ix);
+
+               if (I < N - 1) {
+                  dump<','>(b, ix);
+               }
+            });
+
+            dump<'\n'>(b, ix);
+         }
+      }
+   };
 
-   template <uint32_t layout = rowwise, write_csv_supported T, class Buffer>
-   [[nodiscard]] auto write_csv(T&& value, Buffer&& buffer) noexcept
+   template <uint32_t layout = rowwise, write_supported<CSV> T, class Buffer>
+   [[nodiscard]] auto write_csv(T&& value, Buffer&& buffer)
    {
-      return write<opts{.format = csv, .layout = layout}>(std::forward<T>(value), std::forward<Buffer>(buffer));
+      return write<opts_csv{.layout = layout}>(std::forward<T>(value), std::forward<Buffer>(buffer));
    }
 
-   template <uint32_t layout = rowwise, write_csv_supported T>
-   [[nodiscard]] expected<std::string, error_ctx> write_csv(T&& value) noexcept
+   template <uint32_t layout = rowwise, write_supported<CSV> T>
+   [[nodiscard]] expected<std::string, error_ctx> write_csv(T&& value)
    {
-      return write<opts{.format = csv, .layout = layout}>(std::forward<T>(value));
+      return write<opts_csv{.layout = layout}>(std::forward<T>(value));
    }
 
-   template <uint32_t layout = rowwise, write_csv_supported T>
-   [[nodiscard]] error_ctx write_file_csv(T&& value, const std::string& file_name, auto&& buffer) noexcept
+   template <uint32_t layout = rowwise, write_supported<CSV> T>
+   [[nodiscard]] error_ctx write_file_csv(T&& value, const std::string& file_name, auto&& buffer)
    {
-      const auto ec = write<opts{.format = csv, .layout = layout}>(std::forward<T>(value), buffer);
+      const auto ec = write<opts_csv{.layout = layout}>(std::forward<T>(value), buffer);
       if (bool(ec)) [[unlikely]] {
          return ec;
       }
diff --git a/deps/saucer/include/glaze/eetf.hpp b/deps/saucer/include/glaze/eetf.hpp
new file mode 100644
index 0000000..dc87c06
--- /dev/null
+++ b/deps/saucer/include/glaze/eetf.hpp
@@ -0,0 +1,11 @@
+// Glaze Library
+// For the license information refer to glaze.hpp
+
+#pragma once
+
+#if defined GLZ_ENABLE_EETF
+
+#include "glaze/eetf/read.hpp"
+#include "glaze/eetf/write.hpp"
+
+#endif
diff --git a/deps/saucer/include/glaze/eetf/cmp.hpp b/deps/saucer/include/glaze/eetf/cmp.hpp
new file mode 100644
index 0000000..dd907e2
--- /dev/null
+++ b/deps/saucer/include/glaze/eetf/cmp.hpp
@@ -0,0 +1,50 @@
+#pragma once
+
+namespace glz::eetf
+{
+
+   namespace detail
+   {
+
+      // Primary template
+      template <typename Tag>
+      struct in_impl;
+
+      // Specialization for `int...`
+      template <int N, int... Vs>
+      struct in_impl<std::integer_sequence<int, N, Vs...>>
+      {
+         bool value{false};
+
+         template <int_t T>
+         constexpr in_impl(const T& val) : value{(val == N) || in_impl<std::integer_sequence<int, Vs...>>(val).value}
+         {}
+      };
+
+      template <int N>
+      struct in_impl<std::integer_sequence<int, N>>
+      {
+         bool value{false};
+
+         template <int_t T>
+         constexpr in_impl(const T& val) : value{val == N}
+         {}
+      };
+
+   } // namespace detail
+
+   template <typename T>
+   using in = detail::in_impl<T>;
+
+   namespace cmp
+   {
+
+      template <template <class> class Op, int... Vs, typename T>
+      constexpr bool is(const T& val)
+      {
+         return Op<std::integer_sequence<int, Vs...>>(val).value;
+      }
+
+   };
+
+} // namespace erlterm
diff --git a/deps/saucer/include/glaze/eetf/defs.hpp b/deps/saucer/include/glaze/eetf/defs.hpp
new file mode 100644
index 0000000..6e4fca5
--- /dev/null
+++ b/deps/saucer/include/glaze/eetf/defs.hpp
@@ -0,0 +1,12 @@
+#pragma once
+
+#include <glaze/core/common.hpp>
+
+#include "types.hpp"
+
+namespace glz
+{
+   template <class T>
+   concept atom_t = string_t<T> && std::same_as<typename T::tag, eetf::tag_atom>;
+
+} // namespace glz
diff --git a/deps/saucer/include/glaze/eetf/ei.hpp b/deps/saucer/include/glaze/eetf/ei.hpp
new file mode 100644
index 0000000..8ab1240
--- /dev/null
+++ b/deps/saucer/include/glaze/eetf/ei.hpp
@@ -0,0 +1,435 @@
+#pragma once
+
+#include <ei.h>
+
+#include <glaze/concepts/container_concepts.hpp>
+#include <glaze/core/common.hpp>
+#include <glaze/core/context.hpp>
+
+#include "defs.hpp"
+#include "types.hpp"
+
+namespace glz
+{
+
+#define CHECK_OFFSET(off)                     \
+   if ((it + (off)) > end) [[unlikely]] {     \
+      ctx.error = error_code::unexpected_end; \
+      return;                                 \
+   }
+
+   using header_pair = std::pair<std::size_t, std::size_t>;
+
+   namespace detail
+   {
+      template <class F, is_context Ctx, class It0, class It1>
+      GLZ_ALWAYS_INLINE void decode_impl(F&& func, Ctx&& ctx, It0&& it, It1&& end)
+      {
+         int index{};
+         if (func(it, &index) < 0) [[unlikely]] {
+            ctx.error = error_code::parse_number_failure;
+            return;
+         }
+
+         CHECK_OFFSET(index);
+         std::advance(it, index);
+      }
+
+      template <output_buffer B, class IX>
+      [[nodiscard]] GLZ_ALWAYS_INLINE int resize_buffer(B&& b, IX&& ix, int index)
+      {
+         if (b.size() < static_cast<std::size_t>(index)) {
+            b.resize((std::max)(b.size() * 2, static_cast<std::size_t>(index)));
+         }
+
+         return static_cast<int>(ix);
+      }
+
+      template <class F, is_context Ctx, class B, class IX>
+      GLZ_ALWAYS_INLINE void encode_impl(F&& func, Ctx&& ctx, B&& b, IX&& ix)
+      {
+         int index{static_cast<int>(ix)};
+         if (func(nullptr, &index) < 0) {
+            ctx.error = error_code::seek_failure;
+            return;
+         }
+
+         index = resize_buffer(b, ix, index);
+         if (func(reinterpret_cast<char*>(b.data()), &index) < 0) {
+            ctx.error = error_code::seek_failure;
+            return;
+         }
+
+         ix = index;
+      }
+
+   } // namespace detail
+
+   template <class It>
+   [[nodiscard]] GLZ_ALWAYS_INLINE int decode_version(is_context auto&& ctx, It&& it)
+   {
+      int index{};
+      int version{};
+      if (ei_decode_version(it, &index, &version) < 0) [[unlikely]] {
+         ctx.error = error_code::syntax_error;
+         return -1;
+      }
+
+      std::advance(it, index);
+      return version;
+   }
+
+   template <class It>
+   GLZ_ALWAYS_INLINE int get_type(is_context auto&& ctx, It&& it)
+   {
+      int type{};
+      int size{};
+      int index{};
+      if (ei_get_type(it, &index, &type, &size) < 0) {
+         ctx.error = error_code::syntax_error;
+         return -1;
+      }
+
+      return type;
+   }
+
+   template <class It0, class It1>
+   auto skip_term(is_context auto&& ctx, It0&& it, It1&& end)
+   {
+      int index{};
+      if (ei_skip_term(it, &index) < 0) {
+         ctx.error = error_code::syntax_error;
+         index = 0;
+      }
+
+      CHECK_OFFSET(index);
+      std::advance(it, index);
+   }
+
+   template <num_t T, class... Args>
+   GLZ_ALWAYS_INLINE void decode_number(T&& value, Args&&... args)
+   {
+      using namespace std::placeholders;
+      using V = std::remove_cvref_t<T>;
+      if constexpr (std::floating_point<std::remove_cvref_t<T>>) {
+         double v;
+         detail::decode_impl(std::bind(ei_decode_double, _1, _2, &v), std::forward<Args>(args)...);
+         value = static_cast<std::remove_cvref_t<T>>(v);
+      }
+      else {
+         if constexpr (sizeof(V) > sizeof(long)) {
+            if constexpr (std::is_signed_v<V>) {
+               long long v;
+               detail::decode_impl(std::bind(ei_decode_longlong, _1, _2, &v), std::forward<Args>(args)...);
+               value = static_cast<T>(v);
+            }
+            else {
+               unsigned long long v;
+               detail::decode_impl(std::bind(ei_decode_ulonglong, _1, _2, &v), std::forward<Args>(args)...);
+               value = static_cast<T>(v);
+            }
+         }
+         else {
+            if constexpr (std::is_signed_v<V>) {
+               long v;
+               detail::decode_impl(std::bind(ei_decode_long, _1, _2, &v), std::forward<Args>(args)...);
+               value = static_cast<T>(v);
+            }
+            else {
+               unsigned long v;
+               detail::decode_impl(std::bind(ei_decode_ulong, _1, _2, &v), std::forward<Args>(args)...);
+               value = static_cast<T>(v);
+            }
+         }
+      }
+   }
+
+   template <class It0, class It1>
+   GLZ_ALWAYS_INLINE void decode_token(auto&& value, is_context auto&& ctx, It0&& it, It1&& end)
+   {
+      using namespace std::placeholders;
+
+      int index{};
+      int type{};
+      int sz{};
+      if (ei_get_type(it, &index, &type, &sz) < 0) [[unlikely]] {
+         ctx.error = error_code::syntax_error;
+         return;
+      }
+
+      CHECK_OFFSET(sz);
+
+      value.resize(sz);
+      if (eetf::is_atom(type)) {
+         detail::decode_impl(std::bind(ei_decode_atom, _1, _2, value.data()), ctx, it, end);
+      }
+      else {
+         detail::decode_impl(std::bind(ei_decode_string, _1, _2, value.data()), ctx, it, end);
+      }
+   }
+
+   template <class... Args>
+   GLZ_ALWAYS_INLINE void decode_boolean(auto&& value, Args&&... args)
+   {
+      using namespace std::placeholders;
+
+      int v{};
+      detail::decode_impl(std::bind(ei_decode_boolean, _1, _2, &v), std::forward<Args>(args)...);
+      value = v != 0;
+   }
+
+   template <auto Opts, class T, class It0>
+   void decode_binary(T&& value, std::size_t sz, is_context auto&& ctx, It0&& it, auto&& end)
+   {
+      using namespace std::placeholders;
+
+      CHECK_OFFSET(sz * sizeof(std::uint8_t));
+
+      using V = range_value_t<std::decay_t<T>>;
+
+      if constexpr (resizable<T>) {
+         value.resize(sz);
+         if constexpr (check_shrink_to_fit(Opts)) {
+            value.shrink_to_fit();
+         }
+      }
+      else {
+         if (sz > value.size()) {
+            ctx.error = error_code::syntax_error;
+            return;
+         }
+      }
+
+      [[maybe_unused]] long szl{};
+      if constexpr (sizeof(V) == sizeof(std::uint8_t)) {
+         detail::decode_impl(std::bind(ei_decode_binary, _1, _2, value.data(), &szl), ctx, it, end);
+      }
+      else {
+         std::vector<std::uint8_t> buff(sz);
+         detail::decode_impl(std::bind(ei_decode_binary, _1, _2, buff.data(), &szl), ctx, it, end);
+         std::copy(buff.begin(), buff.end(), value.begin());
+      }
+   }
+
+   template <is_context Ctx, class It>
+   GLZ_ALWAYS_INLINE auto decode_list_header(Ctx&& ctx, It&& it)
+   {
+      int arity{};
+      int index{};
+      if (ei_decode_list_header(it, &index, &arity) < 0) [[unlikely]] {
+         ctx.error = error_code::syntax_error;
+         return header_pair(-1ull, -1ull);
+      }
+
+      return header_pair(static_cast<std::size_t>(arity), static_cast<std::size_t>(index));
+   }
+
+   template <auto Opts, class T>
+   GLZ_ALWAYS_INLINE void decode_list(T&& value, is_context auto&& ctx, auto&& it, auto&& end)
+   {
+      using V = range_value_t<std::decay_t<T>>;
+
+      auto [arity, index] = decode_list_header(ctx, it);
+      if (bool(ctx.error)) {
+         return;
+      }
+
+      if constexpr (resizable<T>) {
+         value.resize(arity);
+         if constexpr (check_shrink_to_fit(Opts)) {
+            value.shrink_to_fit();
+         }
+      }
+      else {
+         if (static_cast<std::size_t>(arity) > value.size()) {
+            ctx.error = error_code::syntax_error;
+            return;
+         }
+      }
+
+      CHECK_OFFSET(index);
+      std::advance(it, index);
+
+      for (std::size_t idx = 0; idx < arity; idx++) {
+         V v;
+         from<EETF, V>::template op<Opts>(v, ctx, it, end);
+         if (bool(ctx.error)) [[unlikely]] {
+            return;
+         }
+
+         value[idx] = std::move(v);
+      }
+
+      // TODO handle elang list endings
+   }
+
+   template <auto Opts, class T, is_context Ctx, class It0, class It1>
+   GLZ_ALWAYS_INLINE void decode_sequence(T&& value, Ctx&& ctx, It0&& it, It1&& end)
+   {
+      int index{};
+      int type{};
+      int sz{};
+      if (ei_get_type(it, &index, &type, &sz) < 0) [[unlikely]] {
+         ctx.error = error_code::syntax_error;
+         return;
+      }
+
+      if (eetf::is_binary(type)) {
+         decode_binary<Opts>(std::forward<T>(value), static_cast<std::size_t>(sz), std::forward<Ctx>(ctx),
+                             std::forward<It0>(it), std::forward<It1>(end));
+      }
+      else if (eetf::is_list(type)) {
+         if (eetf::is_string(type)) {
+            std::string buff;
+            decode_token(buff, std::forward<Ctx>(ctx), std::forward<It0>(it), std::forward<It1>(end));
+            if constexpr (resizable<T>) {
+               value.resize(sz);
+               if constexpr (check_shrink_to_fit(Opts)) {
+                  value.shrink_to_fit();
+               }
+            }
+            else {
+               if (static_cast<std::size_t>(sz) > value.size()) {
+                  ctx.error = error_code::syntax_error;
+                  return;
+               }
+            }
+            std::copy(buff.begin(), buff.end(), value.begin());
+         }
+         else {
+            decode_list<Opts>(std::forward<T>(value), std::forward<Ctx>(ctx), std::forward<It0>(it),
+                              std::forward<It1>(end));
+         }
+      }
+      // else if tuple?
+      else {
+         ctx.error = error_code::elements_not_convertible_to_design;
+      }
+   }
+
+   template <is_context Ctx, class It>
+   GLZ_ALWAYS_INLINE auto decode_map_header(Ctx&& ctx, It&& it)
+   {
+      int arity{};
+      int index{};
+      if (ei_decode_map_header(it, &index, &arity) < 0) [[unlikely]] {
+         ctx.error = error_code::syntax_error;
+         return header_pair(-1ull, -1ull);
+      }
+
+      return header_pair(static_cast<std::size_t>(arity), static_cast<std::size_t>(index));
+   }
+
+   template <is_context Ctx, class It>
+   GLZ_ALWAYS_INLINE auto decode_tuple_header(Ctx&& ctx, It&& it)
+   {
+      int arity{};
+      int index{};
+      if (ei_decode_tuple_header(it, &index, &arity) < 0) [[unlikely]] {
+         ctx.error = error_code::syntax_error;
+         return header_pair(-1ull, -1ull);
+      }
+
+      return header_pair(static_cast<std::size_t>(arity), static_cast<std::size_t>(index));
+   }
+
+   template <class B, class IX>
+   GLZ_ALWAYS_INLINE void encode_version(is_context auto&& ctx, B&& b, IX&& ix)
+   {
+      int index{static_cast<int>(ix)};
+      if (ei_encode_version(reinterpret_cast<char*>(b.data()), &index) < 0) [[unlikely]] {
+         ctx.error = error_code::unexpected_end;
+         return;
+      }
+
+      ix = index;
+   }
+
+   template <class... Args>
+   GLZ_ALWAYS_INLINE void encode_boolean(const bool value, Args&&... args)
+   {
+      using namespace std::placeholders;
+      detail::encode_impl(std::bind(ei_encode_boolean, _1, _2, value), std::forward<Args>(args)...);
+   }
+
+   template <class T, class... Args>
+   GLZ_ALWAYS_INLINE void encode_number(T&& value, Args&&... args)
+   {
+      using namespace std::placeholders;
+
+      using V = std::remove_cvref_t<T>;
+      if constexpr (std::floating_point<std::remove_cvref_t<T>>) {
+         detail::encode_impl(std::bind(ei_encode_double, _1, _2, value), std::forward<Args>(args)...);
+      }
+      else if constexpr (sizeof(T) > sizeof(long)) {
+         if constexpr (std::is_signed_v<V>) {
+            detail::encode_impl(std::bind(ei_encode_longlong, _1, _2, value), std::forward<Args>(args)...);
+         }
+         else {
+            detail::encode_impl(std::bind(ei_encode_ulonglong, _1, _2, value), std::forward<Args>(args)...);
+         }
+      }
+      else {
+         if constexpr (std::is_signed_v<V>) {
+            detail::encode_impl(std::bind(ei_encode_long, _1, _2, value), std::forward<Args>(args)...);
+         }
+         else {
+            detail::encode_impl(std::bind(ei_encode_ulong, _1, _2, value), std::forward<Args>(args)...);
+         }
+      }
+   }
+
+   template <class... Args>
+   GLZ_ALWAYS_INLINE void encode_atom(auto&& value, Args&&... args)
+   {
+      using namespace std::placeholders;
+      detail::encode_impl(std::bind(ei_encode_atom, _1, _2, value.data()), std::forward<Args>(args)...);
+   }
+
+   template <class... Args>
+   GLZ_ALWAYS_INLINE void encode_atom_len(auto&& value, std::size_t sz, Args&&... args)
+   {
+      using namespace std::placeholders;
+      detail::encode_impl(std::bind(ei_encode_atom_len, _1, _2, value.data(), static_cast<int>(sz)),
+                          std::forward<Args>(args)...);
+   }
+
+   template <class... Args>
+   GLZ_ALWAYS_INLINE void encode_string(auto&& value, Args&&... args)
+   {
+      using namespace std::placeholders;
+      detail::encode_impl(std::bind(ei_encode_string, _1, _2, value.data()), std::forward<Args>(args)...);
+   }
+
+   template <class... Args>
+   GLZ_ALWAYS_INLINE void encode_tuple_header(std::size_t arity, Args&&... args)
+   {
+      using namespace std::placeholders;
+      detail::encode_impl(std::bind(ei_encode_tuple_header, _1, _2, static_cast<int>(arity)),
+                          std::forward<Args>(args)...);
+   }
+
+   template <class... Args>
+   GLZ_ALWAYS_INLINE void encode_list_header(std::size_t arity, Args&&... args)
+   {
+      using namespace std::placeholders;
+      detail::encode_impl(std::bind(ei_encode_list_header, _1, _2, static_cast<int>(arity)),
+                          std::forward<Args>(args)...);
+   }
+
+   template <class... Args>
+   GLZ_ALWAYS_INLINE void encode_list_tail(Args&&... args)
+   {
+      using namespace std::placeholders;
+      detail::encode_impl(std::bind(ei_encode_list_header, _1, _2, 0), std::forward<Args>(args)...);
+   }
+
+   template <class... Args>
+   GLZ_ALWAYS_INLINE void encode_map_header(std::size_t arity, Args&&... args)
+   {
+      using namespace std::placeholders;
+      detail::encode_impl(std::bind(ei_encode_map_header, _1, _2, static_cast<int>(arity)),
+                          std::forward<Args>(args)...);
+   }
+
+} // namespace glz
diff --git a/deps/saucer/include/glaze/eetf/opts.hpp b/deps/saucer/include/glaze/eetf/opts.hpp
new file mode 100644
index 0000000..f5c65b7
--- /dev/null
+++ b/deps/saucer/include/glaze/eetf/opts.hpp
@@ -0,0 +1,21 @@
+#pragma once
+
+#include <glaze/core/opts.hpp>
+
+namespace glz::eetf
+{
+
+   // layout erlang term
+   inline constexpr uint8_t map_layout = 0;
+   inline constexpr uint8_t proplist_layout = 1;
+
+   struct eetf_opts
+   {
+      uint32_t format;
+      uint8_t layout{map_layout};
+      bool error_on_unknown_keys{true};
+      bool shrink_to_fit{false};
+      uint32_t internal{};
+   };
+
+} // namespace glz::eetf
diff --git a/deps/saucer/include/glaze/eetf/read.hpp b/deps/saucer/include/glaze/eetf/read.hpp
new file mode 100644
index 0000000..53e12cb
--- /dev/null
+++ b/deps/saucer/include/glaze/eetf/read.hpp
@@ -0,0 +1,391 @@
+#pragma once
+
+#include <glaze/core/read.hpp>
+#include <glaze/core/reflect.hpp>
+
+#include "defs.hpp"
+#include "ei.hpp"
+#include "opts.hpp"
+
+namespace glz
+{
+
+   template <>
+   struct skip_value<EETF>
+   {
+      template <auto Opts>
+      GLZ_ALWAYS_INLINE static void op(is_context auto&& ctx, auto&& it, auto&& end) noexcept
+      {
+         skip_term(ctx, it, end);
+      }
+   };
+
+   template <>
+   struct parse<EETF>
+   {
+      template <auto Opts, class T, is_context Ctx, class It0, class It1>
+         requires(not check_no_header(Opts))
+      GLZ_ALWAYS_INLINE static void op(T&& value, Ctx&& ctx, It0&& it, It1&& end) noexcept
+      {
+         // TODO Check version
+         const auto version = decode_version(ctx, it);
+         if (version != 131) { // TODO find in erlang files
+            ctx.error = error_code::version_mismatch;
+            return;
+         }
+
+         if (it == end) {
+            ctx.error = error_code::unexpected_end;
+            return;
+         }
+
+         parse<Opts.format>::template op<no_header_on<Opts>()>(std::forward<T>(value), std::forward<Ctx>(ctx),
+                                                               std::forward<It0>(it), std::forward<It1>(end));
+      }
+
+      template <auto Opts, class T, is_context Ctx, class It0, class It1>
+         requires(check_no_header(Opts))
+      GLZ_ALWAYS_INLINE static void op(T&& value, Ctx&& ctx, It0&& it, It1&& end) noexcept
+      {
+         if (bool(ctx.error)) {
+            return;
+         }
+
+         if constexpr (std::is_const_v<std::remove_reference_t<T>>) {
+            if constexpr (Opts.error_on_const_read) {
+               ctx.error = error_code::attempt_const_read;
+            }
+            else {
+               // do not read anything into the const value
+               skip_value<EETF>::op<Opts>(std::forward<Ctx>(ctx), std::forward<It0>(it), std::forward<It1>(end));
+            }
+         }
+         else {
+            from<EETF, std::remove_cvref_t<T>>::template op<Opts>(std::forward<T>(value), std::forward<Ctx>(ctx),
+                                                                  std::forward<It0>(it), std::forward<It1>(end));
+         }
+      }
+   };
+
+   template <readable_array_t T>
+   struct from<EETF, T> final
+   {
+      template <auto Opts, is_context Ctx, class It0, class It1>
+      GLZ_ALWAYS_INLINE static void op(auto&& value, Ctx&& ctx, It0&& it, It1&& end) noexcept
+      {
+         decode_sequence<Opts>(std::forward<T>(value), std::forward<Ctx>(ctx), std::forward<It0>(it),
+                               std::forward<It1>(end));
+      }
+   };
+
+   template <boolean_like T>
+   struct from<EETF, T>
+   {
+      template <auto Opts, is_context Ctx, class It0, class It1>
+      GLZ_ALWAYS_INLINE static void op(auto&& value, Ctx&& ctx, It0&& it, It1&& end) noexcept
+      {
+         if (bool(ctx.error)) [[unlikely]] {
+            return;
+         }
+
+         if (it == end) {
+            return;
+         }
+
+         decode_boolean(std::forward<T>(value), std::forward<Ctx>(ctx), std::forward<It0>(it), std::forward<It1>(end));
+      }
+   };
+
+   template <num_t T>
+   struct from<EETF, T> final
+   {
+      template <auto Opts, is_context Ctx, class It0, class It1>
+      GLZ_ALWAYS_INLINE static void op(auto&& value, Ctx&& ctx, It0&& it, It1&& end) noexcept
+      {
+         if (bool(ctx.error)) [[unlikely]] {
+            return;
+         }
+
+         if (it == end) {
+            return;
+         }
+
+         decode_number(std::forward<T>(value), std::forward<Ctx>(ctx), std::forward<It0>(it), std::forward<It1>(end));
+      }
+   };
+
+   template <atom_t T>
+   struct from<EETF, T> final
+   {
+      template <auto Opts, is_context Ctx, class It0, class It1>
+      GLZ_ALWAYS_INLINE static void op(auto&& value, Ctx&& ctx, It0&& it, It1&& end) noexcept
+      {
+         if (bool(ctx.error)) [[unlikely]] {
+            return;
+         }
+
+         value.clear();
+
+         if (it == end) {
+            return;
+         }
+
+         decode_token(std::forward<T>(value), std::forward<Ctx>(ctx), std::forward<It0>(it), std::forward<It1>(end));
+      }
+   };
+
+   template <str_t T>
+   struct from<EETF, T> final
+   {
+      template <auto Opts, is_context Ctx, class It0, class It1>
+      GLZ_ALWAYS_INLINE static void op(auto&& value, Ctx&& ctx, It0&& it, It1&& end) noexcept
+      {
+         if (bool(ctx.error)) [[unlikely]] {
+            return;
+         }
+
+         value.clear();
+
+         if (it == end) {
+            return;
+         }
+
+         decode_token(std::forward<T>(value), std::forward<Ctx>(ctx), std::forward<It0>(it), std::forward<It1>(end));
+      }
+   };
+
+   template <class T>
+      requires(tuple_t<T> || is_std_tuple<T>)
+   struct from<EETF, T> final
+   {
+      template <auto Opts>
+      static void op(auto&& value, is_context auto&& ctx, auto&& it, auto&& end) noexcept
+      {
+         if (bool(ctx.error)) [[unlikely]] {
+            return;
+         }
+
+         if (it == end) {
+            return;
+         }
+
+         auto [fields_count, index] = decode_tuple_header(ctx, it);
+         if (bool(ctx.error)) [[unlikely]] {
+            return;
+         }
+
+         if (it + index > end) {
+            ctx.error = error_code::unexpected_end;
+            return;
+         }
+
+         it += index;
+
+         using V = std::decay_t<T>;
+         constexpr auto N = glz::tuple_size_v<V>;
+
+         if (fields_count != N) {
+            ctx.error = error_code::syntax_error;
+            return;
+         }
+
+         if constexpr (is_std_tuple<T>) {
+            for_each<N>([&]<size_t I>() { parse<EETF>::op<Opts>(std::get<I>(value), ctx, it, end); });
+         }
+         else {
+            for_each<N>([&]<size_t I>() { parse<EETF>::op<Opts>(glz::get<I>(value), ctx, it, end); });
+         }
+      }
+   };
+
+   template <class T>
+      requires glaze_object_t<T> || reflectable<T>
+   struct from<EETF, T> final
+   {
+      template <is_context Ctx, class It0, class It1>
+      class field_iterator
+      {
+        public:
+         template <typename F>
+         field_iterator(F&& f, Ctx&& ctx, It0&& it, It1&& end)
+         {
+            term_header = f(ctx, it);
+            if (bool(ctx.error)) [[unlikely]] {
+               return;
+            }
+
+            CHECK_OFFSET(term_header.second);
+            std::advance(it, term_header.second);
+         }
+
+         field_iterator(error_code ec, Ctx&& ctx) : term_header{-1ull, -1ull} { ctx.error = ec; }
+
+         template <auto Opts>
+         bool next(Ctx&& ctx, It0&& it, It1&& end)
+         {
+            if (term_header.first == 0) {
+               return false;
+            }
+
+            if constexpr (Opts.layout == glz::eetf::proplist_layout) {
+               const auto header = decode_tuple_header(ctx, it);
+               if (bool(ctx.error)) [[unlikely]] {
+                  return false;
+               }
+
+               if (header.first != 2) [[unlikely]] {
+                  ctx.error = error_code::syntax_error;
+                  return false;
+               }
+
+               if ((it + header.second) > end) [[unlikely]] {
+                  ctx.error = error_code::unexpected_end;
+                  return false;
+               }
+
+               std::advance(it, header.second);
+            }
+
+            term_header.first -= 1;
+            return true;
+         }
+
+         bool empty() const { return term_header.first == 0; }
+
+        private:
+         header_pair term_header;
+      };
+
+      template <auto Opts, is_context Ctx, class It0, class It1>
+      static auto make_term_iterator(Ctx&& ctx, It0&& it, It1&& end)
+      {
+         using fi = field_iterator<Ctx, It0, It1>;
+         const auto tag = get_type(ctx, it);
+         if (bool(ctx.error)) [[unlikely]] {
+            return fi(ctx.error, ctx);
+         }
+
+         if (eetf::is_map(tag) && Opts.layout == glz::eetf::map_layout) {
+            return fi(decode_map_header<Ctx, It0>, ctx, it, end);
+         }
+         else if (eetf::is_list(tag) && Opts.layout == glz::eetf::proplist_layout) {
+            return fi(decode_list_header<Ctx, It0>, ctx, it, end);
+         }
+
+         return fi(error_code::invalid_header, ctx);
+      }
+
+      template <auto Opts, is_context Ctx, class It0, class It1>
+      static void op(auto&& value, Ctx&& ctx, It0&& it, It1&& end) noexcept
+      {
+         if (bool(ctx.error)) [[unlikely]] {
+            return;
+         }
+
+         if (it == end) {
+            return;
+         }
+
+         auto term_it = make_term_iterator<Opts>(ctx, it, end);
+         if (bool(ctx.error)) [[unlikely]] {
+            return;
+         }
+
+         // empty term
+         if (term_it.empty()) [[unlikely]] {
+            return;
+         }
+
+         static constexpr auto N = reflect<T>::size;
+         while (term_it.template next<Opts>(ctx, it, end)) {
+            if constexpr (N > 0) {
+               static constexpr auto HashInfo = hash_info<T>;
+
+               eetf::atom mkey;
+               from<EETF, eetf::atom>::op<Opts>(mkey, ctx, it, end);
+               if (bool(ctx.error)) [[unlikely]] {
+                  return;
+               }
+
+               const auto n = mkey.size();
+               const auto index =
+                  decode_hash_with_size<EETF, T, HashInfo, HashInfo.type>::op(mkey.data(), mkey.data() + n, n);
+               if (index < N) [[likely]] {
+                  const sv key{mkey.data(), n};
+
+                  visit<N>(
+                     [&]<size_t I>() {
+                        static constexpr auto TargetKey = get<I>(reflect<T>::keys);
+                        static constexpr auto Length = TargetKey.size();
+                        if ((Length == n) && compare<Length>(TargetKey.data(), key.data())) [[likely]] {
+                           if constexpr (reflectable<T>) {
+                              parse<EETF>::op<Opts>(get_member(value, get<I>(to_tie(value))), ctx, it, end);
+                           }
+                           else {
+                              parse<EETF>::op<Opts>(get_member(value, get<I>(reflect<T>::values)), ctx, it, end);
+                           }
+                        }
+                        else {
+                           if constexpr (Opts.error_on_unknown_keys) {
+                              ctx.error = error_code::unknown_key;
+                              return;
+                           }
+                           else {
+                              skip_value<EETF>::op<Opts>(ctx, it, end);
+                              if (bool(ctx.error)) [[unlikely]]
+                                 return;
+                           }
+                        }
+                     },
+                     index);
+
+                  if (bool(ctx.error)) [[unlikely]] {
+                     return;
+                  }
+               }
+               else [[unlikely]] {
+                  if constexpr (Opts.error_on_unknown_keys) {
+                     ctx.error = error_code::unknown_key;
+                     return;
+                  }
+                  else {
+                     skip_value<EETF>::op<Opts>(ctx, it, end);
+                     if (bool(ctx.error)) [[unlikely]]
+                        return;
+                  }
+               }
+            }
+            else if constexpr (Opts.error_on_unknown_keys) {
+               ctx.error = error_code::unknown_key;
+               return;
+            }
+            else {
+               skip_value<EETF>::op<Opts>(ctx, it, end);
+               if (bool(ctx.error)) [[unlikely]] {
+                  return;
+               }
+            }
+         }
+      }
+   };
+
+   template <uint8_t layout = glz::eetf::map_layout, read_supported<EETF> T, class Buffer>
+   [[nodiscard]] inline error_ctx read_term(T&& value, Buffer&& buffer) noexcept
+   {
+      return read<eetf::eetf_opts{.format = EETF, .layout = layout}>(value, std::forward<Buffer>(buffer));
+   }
+
+   template <uint8_t layout = glz::eetf::map_layout, read_supported<EETF> T, is_buffer Buffer>
+   [[nodiscard]] expected<T, error_ctx> read_term(Buffer&& buffer) noexcept
+   {
+      T value{};
+      context ctx{};
+      const error_ctx ec =
+         read<eetf::eetf_opts{.format = EETF, .layout = layout}>(value, std::forward<Buffer>(buffer), ctx);
+      if (ec) {
+         return unexpected<error_ctx>(ec);
+      }
+      return value;
+   }
+
+} // namespace glz
diff --git a/deps/saucer/include/glaze/eetf/types.hpp b/deps/saucer/include/glaze/eetf/types.hpp
new file mode 100644
index 0000000..0023327
--- /dev/null
+++ b/deps/saucer/include/glaze/eetf/types.hpp
@@ -0,0 +1,80 @@
+#pragma once
+
+#include <ei.h>
+
+#include <array>
+#include <cstdint>
+#include <string>
+
+#include "cmp.hpp"
+
+namespace glz::eetf
+{
+   struct tag_atom
+   {};
+
+   struct tag_string
+   {};
+
+   template <typename Tag>
+   struct tagged_string : std::string
+   {
+      using tag = Tag;
+   };
+
+   using atom = tagged_string<tag_atom>;
+   constexpr atom operator""_atom(const char* str, std::size_t sz)
+   {
+      // TODO check if valid atom
+      return atom(std::string(str, sz));
+   }
+
+   template <typename Tag>
+   [[nodiscard]] constexpr bool is_atom(const Tag& tag)
+   {
+      return cmp::is<in, ERL_ATOM_EXT, ERL_SMALL_ATOM_EXT, ERL_ATOM_UTF8_EXT, ERL_SMALL_ATOM_UTF8_EXT>(tag);
+   }
+
+   template <typename Tag>
+   [[nodiscard]] constexpr bool is_integer(const Tag& tag)
+   {
+      return cmp::is<in, ERL_INTEGER_EXT, ERL_SMALL_INTEGER_EXT, ERL_SMALL_BIG_EXT, ERL_LARGE_BIG_EXT>(tag);
+   }
+
+   template <typename Tag>
+   [[nodiscard]] constexpr bool is_floating_point(const Tag& tag)
+   {
+      return cmp::is<in, ERL_FLOAT_EXT, NEW_FLOAT_EXT>(tag);
+   }
+
+   template <typename Tag>
+   [[nodiscard]] constexpr bool is_string(const Tag& tag)
+   {
+      return cmp::is<in, ERL_STRING_EXT, ERL_NIL_EXT>(tag);
+   }
+
+   template <typename Tag>
+   [[nodiscard]] constexpr bool is_tuple(const Tag& tag)
+   {
+      return cmp::is<in, ERL_SMALL_TUPLE_EXT, ERL_LARGE_TUPLE_EXT>(tag);
+   }
+
+   template <typename Tag>
+   [[nodiscard]] constexpr bool is_list(const Tag& tag)
+   {
+      return cmp::is<in, ERL_LIST_EXT, ERL_STRING_EXT, ERL_NIL_EXT>(tag);
+   }
+
+   template <typename Tag>
+   [[nodiscard]] constexpr bool is_map(const Tag& tag)
+   {
+      return cmp::is<in, ERL_MAP_EXT>(tag);
+   }
+
+   template <typename Tag>
+   [[nodiscard]] constexpr bool is_binary(const Tag& tag)
+   {
+      return cmp::is<in, ERL_BINARY_EXT>(tag);
+   }
+
+} // namespace glz::eetf
diff --git a/deps/saucer/include/glaze/eetf/wrappers.hpp b/deps/saucer/include/glaze/eetf/wrappers.hpp
new file mode 100644
index 0000000..49e8970
--- /dev/null
+++ b/deps/saucer/include/glaze/eetf/wrappers.hpp
@@ -0,0 +1,53 @@
+#pragma once
+
+#include <glaze/core/wrappers.hpp>
+
+#include "opts.hpp"
+#include "read.hpp"
+#include "types.hpp"
+#include "write.hpp"
+
+namespace glz
+{
+   template <class T>
+   struct atom_as_string_t
+   {
+      static constexpr bool glaze_wrapper = true;
+      using value_type = T;
+      T& val;
+   };
+
+   template <class T>
+   struct from<EETF, atom_as_string_t<T>>
+   {
+      template <auto Opts>
+      static void op(auto&& value, auto&&... args)
+      {
+         static thread_local eetf::atom a{};
+         parse<EETF>::op<Opts>(a, args...);
+         value.val = a;
+      }
+   };
+
+   template <class T>
+   struct to<EETF, atom_as_string_t<T>>
+   {
+      template <auto Opts>
+      static void op(auto&& value, is_context auto&& ctx, auto&& b, auto&& ix)
+      {
+         static thread_local eetf::atom s(value.val);
+         using S = core_t<decltype(s)>;
+         to<EETF, S>::template op<Opts>(s, ctx, b, ix);
+      }
+   };
+
+   template <auto MemPtr>
+   inline constexpr decltype(auto) aas_impl() noexcept
+   {
+      return [](auto&& val) { return atom_as_string_t<std::remove_reference_t<decltype(val.*MemPtr)>>{val.*MemPtr}; };
+   }
+
+   // Read and write atoms as string
+   template <auto MemPtr>
+   constexpr auto atom_as_string = aas_impl<MemPtr>();
+}
diff --git a/deps/saucer/include/glaze/eetf/write.hpp b/deps/saucer/include/glaze/eetf/write.hpp
new file mode 100644
index 0000000..b5656aa
--- /dev/null
+++ b/deps/saucer/include/glaze/eetf/write.hpp
@@ -0,0 +1,299 @@
+#pragma once
+
+#include <glaze/core/reflect.hpp>
+#include <glaze/core/write.hpp>
+
+#include "defs.hpp"
+#include "ei.hpp"
+#include "opts.hpp"
+
+namespace glz
+{
+
+   template <>
+   struct serialize<EETF>
+   {
+      template <auto Opts, class T, class... Args>
+         requires(check_no_header(Opts))
+      GLZ_ALWAYS_INLINE static void op(T&& value, Args&&... args) noexcept
+      {
+         to<EETF, std::remove_cvref_t<T>>::template op<Opts>(std::forward<T>(value), std::forward<Args>(args)...);
+      }
+   };
+
+   template <boolean_like T>
+   struct to<EETF, T>
+   {
+      template <auto Opts, class V, class... Args>
+         requires(not check_no_header(Opts))
+      GLZ_ALWAYS_INLINE static void op(V&& v, Args... args) noexcept
+      {
+         encode_version(std::forward<Args>(args)...);
+         op<no_header_on<Opts>()>(std::forward<V>(v), std::forward<Args>(args)...);
+      }
+
+      template <auto Opts, class... Args>
+         requires(check_no_header(Opts))
+      GLZ_ALWAYS_INLINE static void op(const bool value, Args&&... args) noexcept
+      {
+         encode_boolean(value, std::forward<Args>(args)...);
+      }
+   };
+
+   template <num_t T>
+   struct to<EETF, T> final
+   {
+      template <auto Opts, class V, class... Args>
+         requires(not check_no_header(Opts))
+      GLZ_ALWAYS_INLINE static void op(V&& v, Args... args) noexcept
+      {
+         encode_version(std::forward<Args>(args)...);
+         op<no_header_on<Opts>()>(std::forward<V>(v), std::forward<Args>(args)...);
+      }
+
+      template <auto Opts, class... Args>
+         requires(check_no_header(Opts))
+      GLZ_ALWAYS_INLINE static void op(auto&& value, Args&&... args) noexcept
+      {
+         encode_number(value, std::forward<Args>(args)...);
+      }
+   };
+
+   template <atom_t T>
+   struct to<EETF, T> final
+   {
+      template <auto Opts, class V, class... Args>
+         requires(not check_no_header(Opts))
+      GLZ_ALWAYS_INLINE static void op(V&& v, Args... args) noexcept
+      {
+         encode_version(std::forward<Args>(args)...);
+         op<no_header_on<Opts>()>(std::forward<V>(v), std::forward<Args>(args)...);
+      }
+
+      template <auto Opts, class... Args>
+         requires(check_no_header(Opts))
+      GLZ_ALWAYS_INLINE static void op(auto&& value, Args&&... args) noexcept
+      {
+         encode_atom(value, std::forward<Args>(args)...);
+      }
+   };
+
+   // using for write reflectable map keys
+   template <str_t T>
+   struct to<EETF, T> final
+   {
+      template <auto Opts, class V, class... Args>
+         requires(not check_no_header(Opts))
+      GLZ_ALWAYS_INLINE static void op(V&& v, Args... args) noexcept
+      {
+         encode_version(std::forward<Args>(args)...);
+         op<no_header_on<Opts>()>(std::forward<V>(v), std::forward<Args>(args)...);
+      }
+
+      template <auto Opts, class... Args>
+         requires(check_no_header(Opts))
+      GLZ_ALWAYS_INLINE static void op(auto&& value, Args&&... args) noexcept
+      {
+         encode_atom_len(value, value.size(), std::forward<Args>(args)...);
+      }
+   };
+
+   template <string_t T>
+   struct to<EETF, T> final
+   {
+      template <auto Opts, class V, class... Args>
+         requires(not check_no_header(Opts))
+      GLZ_ALWAYS_INLINE static void op(V&& v, Args... args) noexcept
+      {
+         encode_version(std::forward<Args>(args)...);
+         op<no_header_on<Opts>()>(std::forward<V>(v), std::forward<Args>(args)...);
+      }
+
+      template <auto Opts, class... Args>
+         requires(check_no_header(Opts))
+      GLZ_ALWAYS_INLINE static void op(auto&& value, Args&&... args) noexcept
+      {
+         encode_string(value, std::forward<Args>(args)...);
+      }
+   };
+
+   template <class T>
+      requires(tuple_t<T> || is_std_tuple<T>)
+   struct to<EETF, T> final
+   {
+      template <auto Opts, class V, class... Args>
+         requires(not check_no_header(Opts))
+      GLZ_ALWAYS_INLINE static void op(V&& v, Args... args) noexcept
+      {
+         encode_version(std::forward<Args>(args)...);
+         op<no_header_on<Opts>()>(std::forward<V>(v), std::forward<Args>(args)...);
+      }
+
+      template <auto Opts, is_context Ctx, class... Args>
+         requires(check_no_header(Opts))
+      GLZ_ALWAYS_INLINE static void op(auto&& value, Ctx&& ctx, Args&&... args) noexcept
+      {
+         static constexpr auto N = glz::tuple_size_v<T>;
+
+         encode_tuple_header(N, ctx, std::forward<Args>(args)...);
+         if (bool(ctx.error)) [[unlikely]] {
+            return;
+         }
+
+         if constexpr (is_std_tuple<T>) {
+            [&]<size_t... I>(std::index_sequence<I...>) {
+               (serialize<EETF>::op<Opts>(std::get<I>(value), ctx, args...), ...);
+            }(std::make_index_sequence<N>{});
+         }
+         else {
+            [&]<size_t... I>(std::index_sequence<I...>) {
+               (serialize<EETF>::op<Opts>(glz::get<I>(value), ctx, args...), ...);
+            }(std::make_index_sequence<N>{});
+         }
+      }
+   };
+
+   template <writable_array_t T>
+   struct to<EETF, T> final
+   {
+      template <auto Opts, class V, class... Args>
+         requires(not check_no_header(Opts))
+      GLZ_ALWAYS_INLINE static void op(V&& v, Args... args) noexcept
+      {
+         encode_version(std::forward<Args>(args)...);
+         op<no_header_on<Opts>()>(std::forward<V>(v), std::forward<Args>(args)...);
+      }
+
+      template <auto Opts, is_context Ctx, class... Args>
+         requires(check_no_header(Opts))
+      GLZ_ALWAYS_INLINE static void op(auto&& value, Ctx&& ctx, Args&&... args) noexcept
+      {
+         const auto n = value.size();
+         encode_list_header(n, ctx, std::forward<Args>(args)...);
+         if (bool(ctx.error)) [[unlikely]] {
+            return;
+         }
+
+         for (auto& i : value) {
+            serialize<EETF>::op<Opts>(i, ctx, args...);
+         }
+
+         encode_list_tail(ctx, std::forward<Args>(args)...);
+      }
+   };
+
+   template <writable_map_t T>
+   struct to<EETF, T> final
+   {
+      template <auto Opts, class V, class... Args>
+         requires(not check_no_header(Opts))
+      GLZ_ALWAYS_INLINE static void op(V&& v, Args... args) noexcept
+      {
+         encode_version(std::forward<Args>(args)...);
+         op<no_header_on<Opts>()>(std::forward<V>(v), std::forward<Args>(args)...);
+      }
+
+      template <auto Opts, is_context Ctx, class... Args>
+         requires(check_no_header(Opts))
+      GLZ_ALWAYS_INLINE static void op(T&& value, Ctx&& ctx, Args&&... args) noexcept
+      {
+         const auto n = value.size();
+         encode_map_header(n, ctx, std::forward<Args>(args)...);
+         if (bool(ctx.error)) [[unlikely]] {
+            return;
+         }
+
+         for (auto&& [k, v] : value) {
+            serialize<EETF>::op<Opts>(k, ctx, args...);
+            serialize<EETF>::op<Opts>(v, ctx, args...);
+         }
+      }
+   };
+
+   template <class T>
+      requires glaze_object_t<T> || reflectable<T>
+   struct to<EETF, T> final
+   {
+      template <auto Opts, class V, class... Args>
+         requires(not check_no_header(Opts))
+      GLZ_ALWAYS_INLINE static void op(V&& v, Args&&... args) noexcept
+      {
+         encode_version(std::forward<Args>(args)...);
+         op<no_header_on<Opts>()>(std::forward<V>(v), std::forward<Args>(args)...);
+      }
+
+      template <auto Opts, class... Args>
+         requires(check_no_header(Opts))
+      GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, Args&&... args) noexcept
+      {
+         static constexpr auto N = reflect<T>::size;
+
+         if constexpr (Opts.layout == eetf::map_layout) {
+            encode_map_header(N, ctx, std::forward<Args>(args)...);
+         }
+         else {
+            encode_list_header(N, ctx, std::forward<Args>(args)...);
+         }
+
+         if (bool(ctx.error)) [[unlikely]] {
+            return;
+         }
+
+         [[maybe_unused]] decltype(auto) t = [&]() -> decltype(auto) {
+            if constexpr (reflectable<T>) {
+               return to_tie(value);
+            }
+            else {
+               return nullptr;
+            }
+         }();
+
+         for_each<N>([&]<size_t I>() {
+            if constexpr (Opts.layout == eetf::proplist_layout) {
+               encode_tuple_header(2, ctx, std::forward<Args>(args)...);
+            }
+
+            static constexpr sv key = reflect<T>::keys[I];
+            serialize<EETF>::op<Opts>(key, ctx, std::forward<Args>(args)...);
+
+            decltype(auto) member = [&]() -> decltype(auto) {
+               if constexpr (reflectable<T>) {
+                  return get<I>(t);
+               }
+               else {
+                  return get<I>(reflect<T>::values);
+               }
+            }();
+
+            serialize<EETF>::op<Opts>(get_member(value, member), ctx, std::forward<Args>(args)...);
+         });
+      }
+   };
+
+   template <class T>
+   struct to<EETF, T> final
+   {
+      // empty for compilation error if use unsupported value type
+   };
+
+   template <uint8_t layout = glz::eetf::map_layout, write_supported<EETF> T, output_buffer Buffer>
+   [[nodiscard]] error_ctx write_term(T&& value, Buffer&& buffer) noexcept
+   {
+      return write<eetf::eetf_opts{.format = EETF, .layout = layout}>(std::forward<T>(value),
+                                                                      std::forward<Buffer>(buffer));
+   }
+
+   template <uint8_t layout = glz::eetf::map_layout, write_supported<EETF> T, raw_buffer Buffer>
+   [[nodiscard]] expected<size_t, error_ctx> write_term(T&& value, Buffer&& buffer) noexcept
+   {
+      return write<eetf::eetf_opts{.format = EETF, .layout = layout}>(std::forward<T>(value),
+                                                                      std::forward<Buffer>(buffer));
+   }
+
+   template <write_supported<EETF> T>
+   [[nodiscard]] expected<std::string, error_ctx> write_term(T&& value) noexcept
+   {
+      return write<eetf::eetf_opts{.format = EETF}>(std::forward<T>(value));
+   }
+
+} // namespace glz
diff --git a/deps/saucer/include/glaze/exceptions/binary_exceptions.hpp b/deps/saucer/include/glaze/exceptions/binary_exceptions.hpp
index ac0b118..7ab0e2e 100644
--- a/deps/saucer/include/glaze/exceptions/binary_exceptions.hpp
+++ b/deps/saucer/include/glaze/exceptions/binary_exceptions.hpp
@@ -11,30 +11,30 @@
 namespace glz::ex
 {
    template <class T, class Buffer>
-   void read_binary(T& value, Buffer&& buffer)
+   void read_beve(T& value, Buffer&& buffer)
    {
-      auto ec = glz::read_binary(value, std::forward<Buffer>(buffer));
+      auto ec = glz::read_beve(value, std::forward<Buffer>(buffer));
       if (ec) {
-         throw std::runtime_error("read_binary error");
+         throw std::runtime_error("read_beve error");
       }
    }
 
    template <class T, class Buffer>
-   [[nodiscard]] T read_binary(Buffer&& buffer) noexcept
+   [[nodiscard]] T read_beve(Buffer&& buffer)
    {
-      const auto ex = glz::read_binary<T>(std::forward<Buffer>(buffer));
+      const auto ex = glz::read_beve<T>(std::forward<Buffer>(buffer));
       if (ex) {
-         throw std::runtime_error("read_binary error");
+         throw std::runtime_error("read_beve error");
       }
       return ex.value();
    }
 
    template <auto Opts = opts{}, class T>
-   void read_file_binary(T& value, const sv file_name, auto&& buffer)
+   void read_file_beve(T& value, const sv file_name, auto&& buffer)
    {
-      const auto ec = glz::read_file_binary(value, file_name, buffer);
+      const auto ec = glz::read_file_beve(value, file_name, buffer);
       if (ec) {
-         throw std::runtime_error("read_file_binary error for: " + std::string(file_name));
+         throw std::runtime_error("read_file_beve error for: " + std::string(file_name));
       }
    }
 }
@@ -42,26 +42,26 @@ namespace glz::ex
 namespace glz::ex
 {
    template <class T, class Buffer>
-   void write_binary(T&& value, Buffer&& buffer)
+   void write_beve(T&& value, Buffer&& buffer)
    {
-      glz::write_binary(std::forward<T>(value), std::forward<Buffer>(buffer));
+      glz::write_beve(std::forward<T>(value), std::forward<Buffer>(buffer));
    }
 
    template <class T>
-   [[nodiscard]] auto write_binary(T&& value)
+   [[nodiscard]] auto write_beve(T&& value)
    {
-      return glz::write_binary(std::forward<T>(value));
+      return glz::write_beve(std::forward<T>(value));
    }
 
    template <class T>
-   void write_file_binary(T&& value, const std::string& file_name, auto&& buffer)
+   void write_file_beve(T&& value, const std::string& file_name, auto&& buffer)
    {
-      auto ec = glz::write_file_binary(std::forward<T>(value), file_name, buffer);
+      auto ec = glz::write_file_beve(std::forward<T>(value), file_name, buffer);
       if (ec == glz::error_code::file_open_failure) {
          throw std::runtime_error("file failed to open: " + file_name);
       }
       else if (ec) {
-         throw std::runtime_error("write_file_binary error for: " + file_name);
+         throw std::runtime_error("write_file_beve error for: " + file_name);
       }
    }
 }
diff --git a/deps/saucer/include/glaze/exceptions/core_exceptions.hpp b/deps/saucer/include/glaze/exceptions/core_exceptions.hpp
index b6cd802..17b1f83 100644
--- a/deps/saucer/include/glaze/exceptions/core_exceptions.hpp
+++ b/deps/saucer/include/glaze/exceptions/core_exceptions.hpp
@@ -10,8 +10,8 @@
 
 namespace glz::ex
 {
-   template <opts Opts, class T>
-      requires read_supported<Opts.format, T>
+   template <auto Opts, class T>
+      requires read_supported<T, Opts.format>
    void read(T&& value, auto&& buffer)
    {
       const auto ec = glz::read<Opts>(std::forward<T>(value), buffer);
@@ -24,8 +24,8 @@ namespace glz::ex
 namespace glz::ex
 {
    // For writing to a std::string, std::vector<char>, std::deque<char> and the like
-   template <opts Opts, class T, output_buffer Buffer>
-      requires write_supported<Opts.format, T>
+   template <auto Opts, class T, output_buffer Buffer>
+      requires write_supported<T, Opts.format>
    void write(T&& value, Buffer& buffer, is_context auto&& ctx)
    {
       const auto ec = glz::write<Opts>(std::forward<T>(value), buffer, ctx);
@@ -34,8 +34,8 @@ namespace glz::ex
       }
    }
 
-   template <auto& Partial, opts Opts, class T, output_buffer Buffer>
-      requires write_supported<Opts.format, T>
+   template <auto& Partial, auto Opts, class T, output_buffer Buffer>
+      requires write_supported<T, Opts.format>
    void write(T&& value, Buffer& buffer)
    {
       const auto ec = glz::write(std::forward<T>(value), buffer);
@@ -44,16 +44,16 @@ namespace glz::ex
       }
    }
 
-   template <opts Opts, class T, output_buffer Buffer>
-      requires write_supported<Opts.format, T>
+   template <auto Opts, class T, output_buffer Buffer>
+      requires write_supported<T, Opts.format>
    void write(T&& value, Buffer& buffer)
    {
       glz::context ctx{};
       glz::ex::write<Opts>(std::forward<T>(value), buffer, ctx);
    }
 
-   template <opts Opts, class T>
-      requires write_supported<Opts.format, T>
+   template <auto Opts, class T>
+      requires write_supported<T, Opts.format>
    [[nodiscard]] std::string write(T&& value)
    {
       const auto e = glz::write<Opts>(std::forward<T>(value));
@@ -63,8 +63,8 @@ namespace glz::ex
       return e.value();
    }
 
-   template <opts Opts, class T, raw_buffer Buffer>
-      requires write_supported<Opts.format, T>
+   template <auto Opts, class T, raw_buffer Buffer>
+      requires write_supported<T, Opts.format>
    [[nodiscard]] size_t write(T&& value, Buffer&& buffer)
    {
       const auto e = write<Opts>(std::forward<T>(value), std::forward<Buffer>(buffer));
diff --git a/deps/saucer/include/glaze/exceptions/csv_exceptions.hpp b/deps/saucer/include/glaze/exceptions/csv_exceptions.hpp
index 081fd33..df3f1aa 100644
--- a/deps/saucer/include/glaze/exceptions/csv_exceptions.hpp
+++ b/deps/saucer/include/glaze/exceptions/csv_exceptions.hpp
@@ -22,7 +22,7 @@ namespace glz::ex
    template <uint32_t layout = rowwise, class T, class Buffer>
    inline auto read_csv(Buffer&& buffer)
    {
-      auto ex = glz::read<T, opts{.format = csv, .layout = layout}>(std::forward<Buffer>(buffer));
+      auto ex = glz::read<T, opts_csv{.layout = layout}>(std::forward<Buffer>(buffer));
       if (ex) {
          throw std::runtime_error("read_csv error");
       }
@@ -44,7 +44,7 @@ namespace glz::ex
    template <class T, class Buffer>
    inline auto write_csv(T&& value, Buffer&& buffer)
    {
-      const auto ec = write<opts{.format = csv}>(std::forward<T>(value), std::forward<Buffer>(buffer));
+      const auto ec = write<opts_csv{}>(std::forward<T>(value), std::forward<Buffer>(buffer));
       if (ec) {
          throw std::runtime_error("write_csv error");
       }
diff --git a/deps/saucer/include/glaze/exceptions/json_schema_exceptions.hpp b/deps/saucer/include/glaze/exceptions/json_schema_exceptions.hpp
index db15810..188cdbd 100644
--- a/deps/saucer/include/glaze/exceptions/json_schema_exceptions.hpp
+++ b/deps/saucer/include/glaze/exceptions/json_schema_exceptions.hpp
@@ -10,7 +10,7 @@
 
 namespace glz::ex
 {
-   template <class T, opts Opts = opts{}, class Buffer>
+   template <class T, auto Opts = opts{}, class Buffer>
    void write_json_schema(Buffer&& buffer)
    {
       const auto ec = glz::write_json_schema<T, Opts>(buffer);
@@ -19,7 +19,7 @@ namespace glz::ex
       }
    }
 
-   template <class T, opts Opts = opts{}>
+   template <class T, auto Opts = opts{}>
    [[nodiscard]] std::string write_json_schema()
    {
       std::string buffer{};
diff --git a/deps/saucer/include/glaze/ext/cli_menu.hpp b/deps/saucer/include/glaze/ext/cli_menu.hpp
index 0f64ef7..9cdf5f8 100644
--- a/deps/saucer/include/glaze/ext/cli_menu.hpp
+++ b/deps/saucer/include/glaze/ext/cli_menu.hpp
@@ -18,9 +18,7 @@ namespace glz
    // To support bool and std::atomic<bool> and other custom boolean types
    template <class T>
    concept cli_menu_boolean = requires(T t) {
-      {
-         t
-      } -> std::convertible_to<bool>;
+      { t } -> std::convertible_to<bool>;
    };
 
    namespace detail
@@ -54,13 +52,20 @@ namespace glz
       }
    }
 
-   template <opts Opts = opts{.prettify = true}, class T>
-      requires(detail::glaze_object_t<T> || detail::reflectable<T>)
-   inline void run_cli_menu(T& value, cli_menu_boolean auto& show_menu)
+   // When running with exceptions enabled we allow the user to provide an exceptions callback, which will be invoked
+   // when an exception is thrown from running a menu item. The exception callback must take a `const std::exception&`
+
+   template <auto Opts = opts{.prettify = true}, class T, cli_menu_boolean ShowMenu = std::atomic<bool>>
+      requires(glaze_object_t<T> || reflectable<T>)
+#if __cpp_exceptions
+   inline void run_cli_menu(T& value, ShowMenu&& show_menu, auto&& exception_callback)
+#else
+   inline void run_cli_menu(T& value, ShowMenu&& show_menu = true)
+#endif
    {
       using namespace detail;
 
-      static constexpr auto N = reflection_count<T>;
+      static constexpr auto N = reflect<T>::size;
 
       auto execute_menu_item = [&](const auto item_number) {
          if (item_number == N + 1) {
@@ -70,7 +75,7 @@ namespace glz
 
          [[maybe_unused]] decltype(auto) t = [&] {
             if constexpr (reflectable<T>) {
-               return to_tuple(value);
+               return to_tie(value);
             }
             else {
                return nullptr;
@@ -78,24 +83,81 @@ namespace glz
          }();
 
          if (item_number > 0 && item_number <= long(N)) {
-            for_each_short_circuit<N>([&](auto I) {
-               if (I == item_number - 1) {
-                  using Element = glaze_tuple_element<I, N, T>;
-                  static constexpr size_t member_index = Element::member_index;
-                  using E = typename Element::type;
+            visit<N>(
+               [&]<size_t I>() {
+                  using E = refl_t<T, I>;
 
                   // MSVC bug requires Index alias here
-                  decltype(auto) func = [&](auto Index) -> decltype(auto) {
+                  decltype(auto) func = [&]<size_t J>() -> decltype(auto) {
                      if constexpr (reflectable<T>) {
-                        return std::get<Index>(t);
+                        return get_member(value, get<J>(t));
                      }
                      else {
-                        return get_member(value, get<member_index>(get<Index>(meta_v<T>)));
+                        return get_member(value, get<J>(reflect<T>::values));
                      }
-                  }(I);
+                  }.template operator()<I>();
 
                   using Func = decltype(func);
-                  if constexpr (std::is_invocable_v<Func>) {
+                  if constexpr (std::is_member_function_pointer_v<std::decay_t<Func>>) {
+                     using F = std::decay_t<Func>;
+                     using Ret = typename return_type<F>::type;
+                     using Tuple = typename inputs_as_tuple<F>::type;
+                     constexpr auto n_args = glz::tuple_size_v<Tuple>;
+
+                     if constexpr (n_args == 0) {
+                        if constexpr (std::same_as<Ret, void>) {
+                           (value.*func)();
+                        }
+                        else {
+                           const auto result = glz::write<Opts>((value.*func)()).value_or("result serialization error");
+                           std::printf("%.*s\n", int(result.size()), result.data());
+                        }
+                     }
+                     else if constexpr (n_args == 1) {
+                        using Params = glz::tuple_element_t<0, Tuple>;
+                        using P = std::decay_t<Params>;
+                        constexpr auto N = glz::tuple_size_v<Tuple>;
+                        static_assert(N == 1, "Only one input is allowed for your function");
+                        static thread_local std::array<char, 256> input{};
+                        if constexpr (is_help<P>) {
+                           std::printf("%.*s\n", int(P::help_message.size()), P::help_message.data());
+                           print_input_type<typename P::value_type>();
+                        }
+                        else {
+                           print_input_type<P>();
+                        }
+
+                        if (fgets(input.data(), int(input.size()), stdin)) {
+                           std::string_view input_sv{input.data()};
+                           if (input_sv.back() == '\n') {
+                              input_sv = input_sv.substr(0, input_sv.size() - 1);
+                           }
+                           P params{};
+                           const auto ec = glz::read<Opts>(params, input_sv);
+                           if (ec) {
+                              const auto error = glz::format_error(ec, input_sv);
+                              std::printf("%.*s\n", int(error.size()), error.data());
+                           }
+                           else {
+                              if constexpr (std::same_as<Ret, void>) {
+                                 (value.*func)(params);
+                              }
+                              else {
+                                 const auto result =
+                                    glz::write<Opts>((value.*func)(params)).value_or("result serialization error");
+                                 std::printf("%.*s\n", int(result.size()), result.data());
+                              }
+                           }
+                        }
+                        else {
+                           std::fprintf(stderr, "Invalid input.\n");
+                        }
+                     }
+                     else {
+                        static_assert(false_v<Func>, "function cannot have more than one input");
+                     }
+                  }
+                  else if constexpr (std::is_invocable_v<Func>) {
                      using R = std::invoke_result_t<Func>;
                      if constexpr (std::same_as<R, void>) {
                         func();
@@ -149,22 +211,28 @@ namespace glz
                   else if constexpr (glaze_object_t<E> || reflectable<E>) {
                      std::atomic<bool> menu_boolean = true;
                      if constexpr (reflectable<T>) {
-                        run_cli_menu<Opts>(std::get<I>(t), menu_boolean);
+#if __cpp_exceptions
+                        run_cli_menu<Opts>(get<I>(t), menu_boolean, exception_callback);
+#else
+                        run_cli_menu<Opts>(get<I>(t), menu_boolean);
+#endif
                      }
                      else {
-                        decltype(auto) v = get_member(value, get<Element::member_index>(get<I>(meta_v<T>)));
+                        decltype(auto) v = get_member(value, get<I>(reflect<T>::values));
+#if __cpp_exceptions
+                        run_cli_menu<Opts>(v, menu_boolean, exception_callback);
+#else
                         run_cli_menu<Opts>(v, menu_boolean);
+#endif
                      }
                   }
-                  else if constexpr (Opts.hide_non_invocable) {
+                  else if constexpr (check_hide_non_invocable(Opts)) {
                   }
                   else {
                      static_assert(false_v<Func>, "Your function is not invocable or not concrete");
                   }
-                  return true; // exit
-               }
-               return false; // continue
-            });
+               },
+               item_number - 1);
          }
          else {
             std::fprintf(stderr, "Invalid menu item.\n");
@@ -173,18 +241,17 @@ namespace glz
 
       while (show_menu) {
          std::printf("================================\n");
-         for_each<N>([&](auto I) {
-            using Element = glaze_tuple_element<I, N, T>;
-            constexpr sv key = key_name<I, T, Element::use_reflection>;
+         for_each<N>([&]<auto I>() {
+            using E = refl_t<T, I>;
+            constexpr sv key = reflect<T>::keys[I];
 
-            using E = typename Element::type;
             if constexpr (glaze_object_t<E> || reflectable<E>) {
                std::printf("  %d   %.*s\n", uint32_t(I + 1), int(key.size()), key.data());
             }
             else {
                [[maybe_unused]] decltype(auto) t = [&] {
                   if constexpr (reflectable<T>) {
-                     return to_tuple(value);
+                     return to_tie(value);
                   }
                   else {
                      return nullptr;
@@ -193,21 +260,24 @@ namespace glz
 
                decltype(auto) func = [&]() -> decltype(auto) {
                   if constexpr (reflectable<T>) {
-                     return std::get<I>(t);
+                     return get<I>(t);
                   }
                   else {
-                     return get_member(value, get<Element::member_index>(get<I>(meta_v<T>)));
+                     return get_member(value, get<I>(reflect<T>::values));
                   }
                }();
 
                using Func = decltype(func);
-               if constexpr (std::is_invocable_v<Func>) {
+               if constexpr (std::is_member_function_pointer_v<std::decay_t<Func>>) {
+                  std::printf("  %d   %.*s\n", uint32_t(I + 1), int(key.size()), key.data());
+               }
+               else if constexpr (std::is_invocable_v<Func>) {
                   std::printf("  %d   %.*s\n", uint32_t(I + 1), int(key.size()), key.data());
                }
                else if constexpr (is_invocable_concrete<std::remove_cvref_t<Func>>) {
                   std::printf("  %d   %.*s\n", uint32_t(I + 1), int(key.size()), key.data());
                }
-               else if constexpr (Opts.hide_non_invocable) {
+               else if constexpr (check_hide_non_invocable(Opts)) {
                   // do not print non-invocable member
                }
                else {
@@ -230,11 +300,37 @@ namespace glz
                goto restart_input;
             }
 
+            auto* it = buf;
+            for (const auto* end = buf + 5; it < end; ++it) {
+               if (*it == '\n' || *it == '\0') {
+                  break;
+               }
+            }
+            std::string_view str{buf, size_t(it - buf)};
+            if (str == "cls" || str == "clear") {
+               std::printf("\n");
+               continue;
+            }
+
             char* endptr{};
             errno = 0; // reset error number
             cmd = std::strtol(buf, &endptr, 10);
             if ((errno != ERANGE) && (endptr != buf) && (*endptr == '\0' || *endptr == '\n')) {
+#if __cpp_exceptions
+               if constexpr (std::invocable<decltype(exception_callback), const std::exception&>) {
+                  try {
+                     execute_menu_item(cmd);
+                  }
+                  catch (const std::exception& e) {
+                     exception_callback(e);
+                  }
+               }
+               else {
+                  execute_menu_item(cmd);
+               }
+#else
                execute_menu_item(cmd);
+#endif
                continue;
             }
          }
@@ -243,11 +339,13 @@ namespace glz
       }
    }
 
-   template <opts Opts = opts{.prettify = true}, class T>
-      requires(detail::glaze_object_t<T> || detail::reflectable<T>)
-   inline void run_cli_menu(T& value)
+#if __cpp_exceptions
+   // Version without exception callback for platforms with exceptions enabled
+   template <auto Opts = opts{.prettify = true}, class T, cli_menu_boolean ShowMenu = std::atomic<bool>>
+      requires(glaze_object_t<T> || reflectable<T>)
+   inline void run_cli_menu(T& value, ShowMenu&& show_menu = true)
    {
-      std::atomic<bool> menu_boolean = true;
-      run_cli_menu<Opts>(value, menu_boolean);
+      run_cli_menu<Opts>(value, show_menu, nullptr);
    }
+#endif
 }
diff --git a/deps/saucer/include/glaze/ext/eigen.hpp b/deps/saucer/include/glaze/ext/eigen.hpp
index ff583cc..a1102d9 100644
--- a/deps/saucer/include/glaze/ext/eigen.hpp
+++ b/deps/saucer/include/glaze/ext/eigen.hpp
@@ -12,8 +12,8 @@ static_assert(false, "Eigen must be included to use glaze/ext/eigen.hpp");
 #include <span>
 
 #include "glaze/api/std/array.hpp"
-#include "glaze/binary/read.hpp"
-#include "glaze/binary/write.hpp"
+#include "glaze/beve/read.hpp"
+#include "glaze/beve/write.hpp"
 #include "glaze/core/common.hpp"
 #include "glaze/core/meta.hpp"
 #include "glaze/json/json_ptr.hpp"
@@ -22,134 +22,205 @@ static_assert(false, "Eigen must be included to use glaze/ext/eigen.hpp");
 
 namespace glz
 {
-   namespace detail
+   template <matrix_t T>
+      requires(T::RowsAtCompileTime >= 0 && T::ColsAtCompileTime >= 0)
+   struct from<BEVE, T>
    {
-      template <class T>
-      concept matrix_t = requires(T matrix) {
-         matrix.resize(2, 4);
-         matrix.data();
-         {
-            matrix.rows()
-         } -> std::convertible_to<size_t>;
-         {
-            matrix.cols()
-         } -> std::convertible_to<size_t>;
-         {
-            matrix.size()
-         } -> std::convertible_to<size_t>;
-      } && !range<T>;
-
-      template <matrix_t T>
-         requires(T::RowsAtCompileTime >= 0 && T::ColsAtCompileTime >= 0)
-      struct from_binary<T>
+      template <auto Opts>
+      static void op(auto& value, is_context auto&& ctx, auto&& it, auto&& end)
       {
-         template <auto Opts>
-         static void op(auto& value, is_context auto&& ctx, auto&& it, auto&& end)
-         {
-            ++it;
-            constexpr uint8_t layout = uint8_t(!T::IsRowMajor);
-            if (uint8_t(*it) != layout) {
-               ctx.error = error_code::syntax_error;
-            }
-            ++it;
-            std::array<Eigen::Index, 2> extents;
-            detail::read<binary>::op<Opts>(extents, ctx, it, end);
-
-            std::span<typename T::Scalar, T::RowsAtCompileTime * T::ColsAtCompileTime> view(value.data(), value.size());
-            detail::read<binary>::op<Opts>(view, ctx, it, end);
+         ++it;
+         if (it >= end) [[unlikely]] {
+            ctx.error = error_code::unexpected_end;
+            return;
          }
-      };
-
-      template <matrix_t T>
-         requires(T::RowsAtCompileTime < 0 || T::ColsAtCompileTime < 0)
-      struct from_binary<T>
+         constexpr uint8_t layout = uint8_t(!T::IsRowMajor);
+         if (uint8_t(*it) != layout) {
+            ctx.error = error_code::syntax_error;
+         }
+         ++it;
+         std::array<Eigen::Index, 2> extents;
+         parse<BEVE>::op<Opts>(extents, ctx, it, end);
+
+         std::span<typename T::Scalar, T::RowsAtCompileTime * T::ColsAtCompileTime> view(value.data(), value.size());
+         parse<BEVE>::op<Opts>(view, ctx, it, end);
+      }
+   };
+
+   // A dynamic matrix in both rows and columns
+   template <matrix_t T>
+      requires(T::RowsAtCompileTime < 0 && T::ColsAtCompileTime < 0)
+   struct from<BEVE, T>
+   {
+      template <auto Opts>
+      static void op(auto& value, is_context auto&& ctx, auto&& it, auto&& end)
       {
-         template <auto Opts>
-         static void op(auto& value, is_context auto&& ctx, auto&& it, auto&& end)
-         {
-            ++it;
-            constexpr uint8_t layout = uint8_t(!T::IsRowMajor);
-            if (uint8_t(*it) != layout) {
-               ctx.error = error_code::syntax_error;
-            }
-            ++it;
-            std::array<Eigen::Index, 2> extents;
-            detail::read<binary>::op<Opts>(extents, ctx, it, end);
-
-            std::span<typename T::Scalar> view(value.data(), extents[0] * extents[1]);
-            detail::read<binary>::op<Opts>(view, ctx, it, end);
+         ++it;
+         if (it >= end) [[unlikely]] {
+            ctx.error = error_code::unexpected_end;
+            return;
          }
-      };
-
-      template <matrix_t T>
-         requires(T::RowsAtCompileTime >= 0 && T::ColsAtCompileTime >= 0)
-      struct to_binary<T>
+         constexpr uint8_t layout = uint8_t(!T::IsRowMajor);
+         if (uint8_t(*it) != layout) {
+            ctx.error = error_code::syntax_error;
+            return;
+         }
+         ++it;
+         std::array<Eigen::Index, 2> extents;
+         parse<BEVE>::op<Opts>(extents, ctx, it, end);
+
+         value.resize(extents[0], extents[1]);
+         std::span<typename T::Scalar> view(value.data(), extents[0] * extents[1]);
+         parse<BEVE>::op<Opts>(view, ctx, it, end);
+      }
+   };
+
+   template <matrix_t T>
+      requires(T::RowsAtCompileTime >= 0 && T::ColsAtCompileTime >= 0)
+   struct to<BEVE, T>
+   {
+      template <auto Opts>
+      static void op(auto&& value, is_context auto&& ctx, auto&&... args)
       {
-         template <auto Opts>
-         static void op(auto&& value, is_context auto&& ctx, auto&&... args) noexcept
-         {
-            constexpr uint8_t matrix = 0b00010'000;
-            constexpr uint8_t tag = tag::extensions | matrix;
-            dump_type(tag, args...);
+         constexpr uint8_t matrix = 0b00010'000;
+         constexpr uint8_t tag = tag::extensions | matrix;
+         dump_type(tag, args...);
 
-            constexpr uint8_t layout = uint8_t(!T::IsRowMajor);
-            dump_type(layout, args...);
+         constexpr uint8_t layout = uint8_t(!T::IsRowMajor);
+         dump_type(layout, args...);
 
-            std::array<Eigen::Index, 2> extents{T::RowsAtCompileTime, T::ColsAtCompileTime};
-            detail::write<binary>::op<Opts>(extents, ctx, args...);
+         std::array<Eigen::Index, 2> extents{T::RowsAtCompileTime, T::ColsAtCompileTime};
+         serialize<BEVE>::op<Opts>(extents, ctx, args...);
 
-            std::span<typename T::Scalar, T::RowsAtCompileTime * T::ColsAtCompileTime> view(value.data(), value.size());
-            detail::write<binary>::op<Opts>(view, ctx, args...);
-         }
-      };
+         std::span<typename T::Scalar, T::RowsAtCompileTime * T::ColsAtCompileTime> view(value.data(), value.size());
+         serialize<BEVE>::op<Opts>(view, ctx, args...);
+      }
+   };
 
-      template <matrix_t T>
-         requires(T::RowsAtCompileTime < 0 || T::ColsAtCompileTime < 0)
-      struct to_binary<T>
+   // A dynamic matrix in both rows and columns
+   template <matrix_t T>
+      requires(T::RowsAtCompileTime < 0 && T::ColsAtCompileTime < 0)
+   struct to<BEVE, T>
+   {
+      template <auto Opts>
+      static void op(auto&& value, is_context auto&& ctx, auto&&... args)
       {
-         template <auto Opts>
-         static void op(auto&& value, is_context auto&& ctx, auto&&... args) noexcept
-         {
-            constexpr uint8_t matrix = 0b00010'000;
-            constexpr uint8_t tag = tag::extensions | matrix;
-            dump_type(tag, args...);
+         constexpr uint8_t matrix = 0b00010'000;
+         constexpr uint8_t tag = tag::extensions | matrix;
+         dump_type(tag, args...);
 
-            constexpr uint8_t layout = uint8_t(!T::IsRowMajor);
-            dump_type(layout, args...);
+         constexpr uint8_t layout = uint8_t(!T::IsRowMajor);
+         dump_type(layout, args...);
 
-            std::array<Eigen::Index, 2> extents{value.rows(), value.cols()};
-            detail::write<binary>::op<Opts>(extents, ctx, args...);
+         std::array<Eigen::Index, 2> extents{value.rows(), value.cols()};
+         serialize<BEVE>::op<Opts>(extents, ctx, args...);
 
-            std::span<typename T::Scalar> view(value.data(), extents[0] * extents[1]);
-            detail::write<binary>::op<Opts>(view, ctx, args...);
-         }
-      };
+         std::span<typename T::Scalar> view(value.data(), extents[0] * extents[1]);
+         serialize<BEVE>::op<Opts>(view, ctx, args...);
+      }
+   };
 
-      template <matrix_t T>
-         requires(T::RowsAtCompileTime >= 0 && T::ColsAtCompileTime >= 0)
-      struct from_json<T>
+   template <matrix_t T>
+      requires(T::RowsAtCompileTime >= 0 && T::ColsAtCompileTime >= 0)
+   struct from<JSON, T>
+   {
+      template <auto Opts>
+      static void op(auto& value, is_context auto&& ctx, auto&& it, auto&& end)
+      {
+         std::span<typename T::Scalar, T::RowsAtCompileTime * T::ColsAtCompileTime> view(value.data(), value.size());
+         parse<JSON>::op<Opts>(view, ctx, it, end);
+      }
+   };
+
+   template <matrix_t T>
+      requires(T::RowsAtCompileTime >= 0 && T::ColsAtCompileTime >= 0)
+   struct to<JSON, T>
+   {
+      template <auto Opts>
+      static void op(auto&& value, is_context auto&& ctx, auto&& b, auto&& ix)
+      {
+         std::span<typename T::Scalar, T::RowsAtCompileTime * T::ColsAtCompileTime> view(value.data(), value.size());
+         using Value = std::remove_cvref_t<decltype(value)>;
+         to<JSON, Value>::template op<Opts>(view, ctx, b, ix);
+      }
+   };
+
+   // A dynamic matrix in both rows and columns
+   template <matrix_t T>
+      requires(T::RowsAtCompileTime < 0 && T::ColsAtCompileTime < 0)
+   struct to<JSON, T>
+   {
+      template <auto Opts>
+      static void op(auto&& value, is_context auto&& ctx, auto&& b, auto&& ix)
+      {
+         dump<'['>(b, ix);
+         using RowColT = std::array<Eigen::Index, 2>;
+         RowColT extents{value.rows(), value.cols()};
+         to<JSON, RowColT>::template op<Opts>(extents, ctx, b, ix);
+         dump<','>(b, ix);
+
+         std::span<typename T::Scalar> view(value.data(), value.size());
+         using Value = std::remove_cvref_t<decltype(view)>;
+         to<JSON, Value>::template op<Opts>(view, ctx, b, ix);
+         dump<']'>(b, ix);
+      }
+   };
+
+   // A dynamic matrix in both rows and columns
+   template <matrix_t T>
+      requires(T::RowsAtCompileTime < 0 && T::ColsAtCompileTime < 0)
+   struct from<JSON, T>
+   {
+      template <auto Opts>
+      static void op(auto& value, is_context auto&& ctx, auto&& it, auto&& end)
       {
-         template <auto Opts>
-         static void op(auto& value, is_context auto&& ctx, auto&& it, auto&& end)
-         {
-            std::span<typename T::Scalar, T::RowsAtCompileTime * T::ColsAtCompileTime> view(value.data(), value.size());
-            detail::read<json>::op<Opts>(view, ctx, it, end);
+         if (match_invalid_end<'[', Opts>(ctx, it, end)) {
+            return;
          }
-      };
+         std::array<Eigen::Index, 2> extents; // NOLINT
+         parse<JSON>::op<Opts>(extents, ctx, it, end);
+         value.resize(extents[0], extents[1]);
+         if (*it == ',') {
+            // we have data
+            ++it;
+            if constexpr (not Opts.null_terminated) {
+               if (it == end) [[unlikely]] {
+                  ctx.error = error_code::unexpected_end;
+                  return;
+               }
+            }
+            std::span<typename T::Scalar> view(value.data(), extents[0] * extents[1]);
+            parse<JSON>::op<Opts>(view, ctx, it, end);
+         }
+         match<']'>(ctx, it);
+      }
+   };
 
-      template <matrix_t T>
-         requires(T::RowsAtCompileTime >= 0 && T::ColsAtCompileTime >= 0)
-      struct to_json<T>
+   template <typename Scalar, int Dim, int Mode>
+   struct from<JSON, Eigen::Transform<Scalar, Dim, Mode>>
+   {
+      template <auto Opts>
+      static void op(auto& value, is_context auto&& ctx, auto&& it, auto&& end)
       {
-         template <auto Opts>
-         static void op(auto&& value, is_context auto&& ctx, auto&& b, auto&& ix) noexcept
-         {
-            std::span<typename T::Scalar, T::RowsAtCompileTime * T::ColsAtCompileTime> view(value.data(), value.size());
-            detail::write<json>::op<Opts>(view, ctx, b, ix);
-         }
-      };
-   } // namespace detail
-} // namespace glaze
+         constexpr auto size = Mode == Eigen::TransformTraits::AffineCompact ? (Dim + 1) * Dim : (Dim + 1) * (Dim + 1);
+         std::span<Scalar, size> view(value.data(), size);
+         parse<JSON>::op<Opts>(view, ctx, it, end);
+      }
+   };
+
+   template <typename Scalar, int Dim, int Mode>
+   struct to<JSON, Eigen::Transform<Scalar, Dim, Mode>>
+   {
+      template <auto Opts>
+      static void op(auto&& value, is_context auto&& ctx, auto&& b, auto&& ix)
+      {
+         constexpr auto size = Mode == Eigen::TransformTraits::AffineCompact ? (Dim + 1) * Dim : (Dim + 1) * (Dim + 1);
+         std::span<Scalar, size> view(value.data(), size);
+         using Value = std::remove_cvref_t<decltype(value)>;
+         to<JSON, Value>::template op<Opts>(view, ctx, b, ix);
+      }
+   };
+}
 
 template <class Scalar, int Rows, int Cols>
 struct glz::meta<Eigen::Matrix<Scalar, Rows, Cols>>
diff --git a/deps/saucer/include/glaze/ext/glaze_asio.hpp b/deps/saucer/include/glaze/ext/glaze_asio.hpp
index 887e3ea..90499e6 100644
--- a/deps/saucer/include/glaze/ext/glaze_asio.hpp
+++ b/deps/saucer/include/glaze/ext/glaze_asio.hpp
@@ -11,88 +11,288 @@
 #endif
 #include <boost/asio.hpp>
 #else
-static_assert(false, "standalone asio must be included to use glaze/ext/glaze_asio.hpp");
+static_assert(false, "standalone or boost asio must be included to use glaze/ext/glaze_asio.hpp");
 #endif
 
 #include <cassert>
 #include <coroutine>
 #include <iostream>
 
-#include "glaze/rpc/repe.hpp"
+#include "glaze/rpc/registry.hpp"
+#include "glaze/util/memory_pool.hpp"
 
 namespace glz
 {
+   namespace repe
+   {
+      inline void encode_error(const error_code& ec, message& msg)
+      {
+         msg.header.ec = ec;
+         msg.body.clear();
+      }
+
+      template <has_size ErrorMessage>
+      inline void encode_error(const error_code& ec, message& msg, ErrorMessage&& error_message)
+      {
+         msg.header.ec = ec;
+         if (error_message.size() > (std::numeric_limits<uint32_t>::max)()) {
+            return;
+         }
+         if (error_message.empty()) {
+            return;
+         }
+         const auto error_size = 4 + error_message.size(); // 4 bytes for message length
+         msg.header.body_length = error_size;
+         msg.body = error_message;
+      }
+
+      template <class ErrorMessage>
+         requires(not has_size<ErrorMessage>)
+      inline void encode_error(const error_code& ec, message& msg, ErrorMessage&& error_message)
+      {
+         encode_error(ec, msg, std::string_view{error_message});
+      }
+
+      // Decodes a repe::message when an error has been encountered
+      inline std::string decode_error(message& msg)
+      {
+         if (bool(msg.error())) {
+            const auto ec = msg.header.ec;
+            if (msg.header.body_length >= 4) {
+               const std::string_view error_message = msg.body;
+               std::string ret = "REPE error: ";
+               ret.append(format_error(ec));
+               ret.append(" | ");
+               ret.append(error_message);
+               return {ret};
+            }
+            else {
+               return std::string{"REPE error: "} + format_error(ec);
+            }
+         }
+         return {"no error"};
+      }
+
+      // Decodes a repe::message into a structure
+      // Returns a std::string with a formatted error on error
+      template <auto Opts = opts{}, class T>
+      inline std::optional<std::string> decode_message(T&& value, message& msg)
+      {
+         if (bool(msg.header.ec)) {
+            const auto ec = msg.header.ec;
+            if (msg.header.body_length >= 4) {
+               const std::string_view error_message = msg.body;
+               std::string ret = "REPE error: ";
+               ret.append(format_error(ec));
+               ret.append(" | ");
+               ret.append(error_message);
+               return {ret};
+            }
+            else {
+               return std::string{"REPE error: "} + format_error(ec);
+            }
+         }
+
+         // we don't const qualify `msg` for performance
+         auto ec = glz::read<Opts>(std::forward<T>(value), msg.body);
+         if (ec) {
+            return {glz::format_error(ec, msg.body)};
+         }
+
+         return {};
+      }
+   }
+
 #if defined(GLZ_USING_BOOST_ASIO)
-   namespace asio = boost::asio;
+   namespace asio
+   {
+      using namespace boost::asio;
+      using error_code = boost::system::error_code;
+   }
 #endif
-   inline void send_buffer(asio::ip::tcp::socket& socket, const std::string_view str)
+   inline void send_buffer(asio::ip::tcp::socket& socket, repe::message& msg)
    {
-      const uint64_t size = str.size();
-      std::array<asio::const_buffer, 2> buffers{asio::buffer(&size, sizeof(uint64_t)), asio::buffer(str)};
+      if (msg.header.length == 0) {
+         encode_error(error_code::invalid_header, msg);
+         return;
+      }
 
-      asio::write(socket, buffers, asio::transfer_exactly(sizeof(uint64_t) + size));
+      std::array<asio::const_buffer, 3> buffers{asio::buffer(&msg.header, sizeof(msg.header)), asio::buffer(msg.query),
+                                                asio::buffer(msg.body)};
+
+      asio::error_code e{};
+      asio::write(socket, buffers, asio::transfer_exactly(msg.header.length), e);
+      if (e) {
+         encode_error(error_code::connection_failure, msg, e.message());
+         return;
+      }
    }
 
-   inline void receive_buffer(asio::ip::tcp::socket& socket, std::string& str)
+   inline void receive_buffer(asio::ip::tcp::socket& socket, repe::message& msg)
    {
-      uint64_t size;
-      asio::read(socket, asio::buffer(&size, sizeof(size)), asio::transfer_exactly(sizeof(uint64_t)));
-      str.resize(size);
-      asio::read(socket, asio::buffer(str), asio::transfer_exactly(size));
+      asio::error_code e{};
+      asio::read(socket, asio::buffer(&msg.header, sizeof(msg.header)), asio::transfer_exactly(sizeof(msg.header)), e);
+      if (e) {
+         encode_error(error_code::connection_failure, msg, e.message());
+         return;
+      }
+      msg.query.resize(msg.header.query_length);
+      asio::read(socket, asio::buffer(msg.query), asio::transfer_exactly(msg.header.query_length));
+      msg.body.resize(msg.header.body_length);
+      asio::read(socket, asio::buffer(msg.body), asio::transfer_exactly(msg.header.body_length), e);
+      if (e) {
+         encode_error(error_code::connection_failure, msg, e.message());
+         return;
+      }
    }
 
-   inline asio::awaitable<void> co_send_buffer(asio::ip::tcp::socket& socket, const std::string_view str)
+   inline asio::awaitable<void> co_send_buffer(asio::ip::tcp::socket& socket, const repe::message& msg)
    {
-      const uint64_t size = str.size();
-      std::array<asio::const_buffer, 2> buffers{asio::buffer(&size, sizeof(uint64_t)), asio::buffer(str)};
+      if (msg.header.length == 0) {
+         throw std::runtime_error("No length provided in REPE header");
+      }
+      if (msg.header.query_length != msg.query.size()) {
+         throw std::runtime_error("Query length mismatch in REPE header");
+      }
+      if (msg.header.body_length != msg.body.size()) {
+         throw std::runtime_error("Body length mismatch in REPE header");
+      }
+
+      // Prepare the buffers: header, query, and body
+      std::array<asio::const_buffer, 3> buffers{asio::buffer(&msg.header, sizeof(msg.header)), asio::buffer(msg.query),
+                                                asio::buffer(msg.body)};
+
+      // Calculate the total bytes to send
+      std::size_t total_length = sizeof(msg.header) + msg.header.query_length + msg.header.body_length;
 
-      co_await asio::async_write(socket, buffers, asio::transfer_exactly(sizeof(uint64_t) + size), asio::use_awaitable);
+      // Asynchronously write the buffers to the socket
+      co_await asio::async_write(socket, buffers, asio::transfer_exactly(total_length), asio::use_awaitable);
    }
 
-   inline asio::awaitable<void> co_receive_buffer(asio::ip::tcp::socket& socket, std::string& str)
+   inline asio::awaitable<void> co_receive_buffer(asio::ip::tcp::socket& socket, repe::message& msg)
    {
-      uint64_t size;
-      co_await asio::async_read(socket, asio::buffer(&size, sizeof(size)), asio::transfer_exactly(sizeof(uint64_t)),
+      // Asynchronously read the header
+      co_await asio::async_read(socket, asio::buffer(&msg.header, sizeof(msg.header)),
+                                asio::transfer_exactly(sizeof(msg.header)), asio::use_awaitable);
+
+      // Validate and read the query
+      msg.query.resize(msg.header.query_length);
+      co_await asio::async_read(socket, asio::buffer(msg.query), asio::transfer_exactly(msg.header.query_length),
+                                asio::use_awaitable);
+
+      // Validate and read the body
+      msg.body.resize(msg.header.body_length);
+      co_await asio::async_read(socket, asio::buffer(msg.body), asio::transfer_exactly(msg.header.body_length),
                                 asio::use_awaitable);
-      str.resize(size);
-      co_await asio::async_read(socket, asio::buffer(str), asio::transfer_exactly(size), asio::use_awaitable);
    }
 
-   inline asio::awaitable<void> call_rpc(asio::ip::tcp::socket& socket, std::string& buffer)
+   // TODO: Make this socket_pool behave more like the object_pool and return a shared_ptr<socket>
+   struct socket_pool
    {
-      co_await co_send_buffer(socket, buffer);
-      co_await co_receive_buffer(socket, buffer);
-   }
+      std::string host{"localhost"}; // host name
+      std::string service{""}; // often the port
+      std::mutex mtx{};
+      std::vector<std::shared_ptr<asio::ip::tcp::socket>> sockets{2};
+      std::vector<size_t> available{0, 1}; // indices of available sockets
 
-   template <class>
-   struct func_traits;
+      std::shared_ptr<asio::io_context> ctx{};
+      std::shared_ptr<std::atomic<bool>> is_connected = std::make_shared<std::atomic<bool>>(false);
 
-   template <class Result>
-   struct func_traits<Result()>
-   {
-      using result_type = Result;
-      using params_type = void;
-      using std_func_sig = std::function<Result()>;
+      // provides a pointer to a socket and an index
+      std::tuple<std::shared_ptr<asio::ip::tcp::socket>, size_t, std::error_code> get()
+      {
+         std::unique_lock lock{mtx};
+
+         if (not ctx) {
+            // TODO: make this error into an error code
+            throw std::runtime_error("asio::io_context is null");
+         }
+
+         // reset all socket pointers if a connection failed
+         if (not*is_connected) {
+            for (auto& socket : sockets) {
+               socket.reset();
+            }
+         }
+
+         if (available.empty()) {
+            const auto current_size = sockets.size();
+            const auto new_size = sockets.size() * 2;
+            sockets.resize(new_size);
+            for (size_t i = current_size; i < new_size; ++i) {
+               available.emplace_back(i);
+            }
+         }
+
+         const auto index = available.back();
+         available.pop_back();
+         auto& socket = sockets[index];
+#if !defined(GLZ_USING_BOOST_ASIO)
+         std::error_code ec{};
+#else
+         boost::system::error_code ec{};
+#endif
+         if (socket) {
+            return {socket, index, ec};
+         }
+         else {
+            socket = std::make_shared<asio::ip::tcp::socket>(*ctx);
+            asio::ip::tcp::resolver resolver{*ctx};
+            const auto endpoint = resolver.resolve(host, service, ec);
+            if (ec) {
+               return {nullptr, index, ec};
+            }
+            asio::connect(*socket, endpoint, ec);
+            if (ec) {
+               return {nullptr, index, ec};
+            }
+            socket->set_option(asio::ip::tcp::no_delay(true), ec);
+            if (ec) {
+               return {nullptr, index, ec};
+            }
+            (*is_connected) = true;
+            return {socket, index, ec};
+         }
+      }
+
+      void free(const size_t index)
+      {
+         std::unique_lock lock{mtx};
+         available.emplace_back(index);
+      }
    };
 
-   template <class Result, class Params>
-   struct func_traits<Result(Params)>
+   struct unique_socket
    {
-      using result_type = Result;
-      using params_type = Params;
-      using std_func_sig = std::function<Result(Params)>;
-   };
+      socket_pool* pool{};
+      std::shared_ptr<asio::ip::tcp::socket> ptr{};
+      size_t index{};
+#if !defined(GLZ_USING_BOOST_ASIO)
+      std::error_code ec{};
+#else
+      boost::system::error_code ec{};
+#endif
+
+      std::shared_ptr<asio::ip::tcp::socket> value() { return ptr; }
+
+      const std::shared_ptr<asio::ip::tcp::socket> value() const { return ptr; }
+
+      operator bool() const { return bool(ptr) && bool(pool) && not bool(ec); }
 
-   template <class T>
-   using func_result_t = typename func_traits<T>::result_type;
+      asio::ip::tcp::socket& operator*() { return *ptr; }
 
-   template <class T>
-   using func_params_t = typename func_traits<T>::params_type;
+      const asio::ip::tcp::socket& operator*() const { return *ptr; }
 
-   template <class T>
-   using std_func_sig_t = typename func_traits<T>::std_func_sig;
+      unique_socket(socket_pool* input_pool) : pool(input_pool) { std::tie(ptr, index, ec) = pool->get(); }
+      unique_socket(const unique_socket&) = default;
+      unique_socket(unique_socket&&) = default;
+      unique_socket& operator=(const unique_socket&) = default;
+      unique_socket& operator=(unique_socket&&) = default;
 
-   template <opts Opts = opts{}>
+      ~unique_socket() { pool->free(index); }
+   };
+
+   template <auto Opts = opts{}>
    struct asio_client
    {
       std::string host{"localhost"}; // host name
@@ -106,183 +306,237 @@ namespace glz
       };
 
       std::shared_ptr<asio::io_context> ctx{};
-      std::shared_ptr<asio::ip::tcp::socket> socket{};
+      std::shared_ptr<glz::socket_pool> socket_pool{};
+      std::shared_ptr<glz::memory_pool<repe::message>> message_pool =
+         std::make_shared<glz::memory_pool<repe::message>>();
 
-      std::shared_ptr<repe::buffer_pool> buffer_pool = std::make_shared<repe::buffer_pool>();
+      std::shared_ptr<std::atomic<bool>> is_connected =
+         std::make_shared<std::atomic<bool>>(false); // will be set to pool's boolean
 
-      [[nodiscard]] std::error_code init()
-      {
-         ctx = std::make_shared<asio::io_context>(concurrency);
-         socket = std::make_shared<asio::ip::tcp::socket>(*ctx);
-         asio::ip::tcp::resolver resolver{*ctx};
-         const auto endpoint = resolver.resolve(host, service);
-#if !defined(GLZ_USING_BOOST_ASIO)
-         std::error_code ec{};
-#else
-         boost::system::error_code ec{};
-#endif
-         asio::connect(*socket, endpoint, ec);
-         if (ec) {
-            return ec;
-         }
-         return socket->set_option(asio::ip::tcp::no_delay(true), ec);
-      }
+      bool connected() const { return *is_connected; }
 
-      template <class Params>
-      [[nodiscard]] repe::error_t notify(repe::header&& header, Params&& params)
+      [[nodiscard]] error_code init()
       {
-         repe::unique_buffer ubuffer{buffer_pool.get()};
-         auto& buffer = ubuffer.value();
+         *is_connected = false;
+         // create a new socket_pool if we are initilaizing, this is needed because the sockets hold references to the
+         // io_context which is being recreated with init()
+         socket_pool = std::make_shared<glz::socket_pool>();
 
-         header.notify = true;
-         const auto ec = repe::request<Opts>(std::move(header), std::forward<Params>(params), buffer);
-         if (bool(ec)) [[unlikely]] {
-            return {repe::error_e::invalid_params, glz::format_error(ec, buffer)};
+         {
+            std::unique_lock lock{socket_pool->mtx}; // lock the socket_pool when setting up
+            ctx = std::make_shared<asio::io_context>(concurrency);
+            socket_pool->ctx = ctx;
+            socket_pool->host = host;
+            socket_pool->service = service;
+            is_connected = socket_pool->is_connected;
          }
 
-         send_buffer(*socket, buffer);
-         return {};
+         unique_socket socket{socket_pool.get()};
+         if (socket) {
+            return {}; // connection success
+         }
+         else {
+            return error_code::connection_failure;
+         }
       }
 
-      template <class Result>
-      [[nodiscard]] repe::error_t get(repe::header&& header, Result&& result)
+      template <class Header = repe::user_header, class... Params>
+      void call(Header&& header, repe::message& response, Params&&... params)
       {
-         repe::unique_buffer ubuffer{buffer_pool.get()};
-         auto& buffer = ubuffer.value();
-
-         header.notify = false;
-         header.empty = true; // no params
-         const auto ec = repe::request<Opts>(std::move(header), nullptr, buffer);
-         if (bool(ec)) [[unlikely]] {
-            return {repe::error_e::invalid_params, glz::format_error(ec, buffer)};
+         auto request = message_pool->borrow();
+         request->body.clear();
+         if (not connected()) {
+            encode_error(request->error(), response, "call failure: NOT CONNECTED");
+            return;
+         }
+         repe::request<Opts>(std::move(header), *request, std::forward<Params>(params)...);
+         if (bool(request->error())) {
+            encode_error(request->error(), response, "bad request");
+            return;
          }
 
-         send_buffer(*socket, buffer);
-         receive_buffer(*socket, buffer);
+         unique_socket socket{socket_pool.get()};
+         if (not socket) {
+            socket.ptr.reset();
+            (*is_connected) = false;
+            encode_error(error_code::send_error, response, "socket failure");
+            return;
+         }
 
-         return repe::decode_response<Opts>(std::forward<Result>(result), buffer);
-      }
+         send_buffer(*socket, *request);
 
-      template <class Result = glz::raw_json>
-      [[nodiscard]] glz::expected<Result, repe::error_t> get(repe::header&& header)
-      {
-         std::decay_t<Result> result{};
-         const auto error = get<Result>(std::move(header), result);
-         if (error) {
-            return glz::unexpected(error);
+         if (bool(request->error())) {
+            return;
          }
-         else {
-            return {result};
+
+         if (not header.notify) {
+            receive_buffer(*socket, response);
+            if (bool(response.error())) {
+               return;
+            }
          }
       }
 
-      template <class Params>
-      [[nodiscard]] repe::error_t set(repe::header&& header, Params&& params)
+      // The `call` method above is designed to be generic and fully-featured.
+      // The `call` method handles invoking RPC functions and sending data to query endpoints
+      // as well as receiving data back.
+      // The API is designed to reduce copies and gives the user control of how the response is handled.
+      // This is important for chaining calls and efficiently handling memory.
+      // ---
+      // The `send` and `receive` methods provide simpler APIs that throw for cleaner code
+      // and allocate the response in the function call.
+
+      // Send parameters to a target query function or value
+      template <class... Params>
+      void set(const std::string_view query, Params&&... params)
       {
-         repe::unique_buffer ubuffer{buffer_pool.get()};
-         auto& buffer = ubuffer.value();
+         if (not connected()) {
+            throw std::runtime_error("asio_client: NOT CONNECTED");
+         }
+
+         repe::message response{};
+         auto request = message_pool->borrow();
+         request->body.clear();
+         repe::request<Opts>(repe::user_header{.query = query}, *request, std::forward<Params>(params)...);
+         if (bool(request->error())) {
+            throw std::runtime_error("bad request");
+         }
 
-         header.notify = false;
-         const auto ec = repe::request<Opts>(std::move(header), std::forward<Params>(params), buffer);
-         if (bool(ec)) [[unlikely]] {
-            return {repe::error_e::invalid_params, glz::format_error(ec, buffer)};
+         unique_socket socket{socket_pool.get()};
+         if (not socket) {
+            socket.ptr.reset();
+            (*is_connected) = false;
+            throw std::runtime_error("socket failure");
          }
 
-         send_buffer(*socket, buffer);
-         receive_buffer(*socket, buffer);
+         send_buffer(*socket, *request);
+
+         if (bool(request->error())) {
+            throw std::runtime_error(glz::format_error(request->error()));
+         }
 
-         return repe::decode_response<Opts>(buffer);
+         receive_buffer(*socket, response);
+         if (bool(response.error())) {
+            std::string error_message = glz::format_error(response.error());
+            if (response.body.size()) {
+               error_message.append(": ");
+               error_message.append(response.body);
+            }
+            throw std::runtime_error(error_message);
+         }
       }
 
-      template <class Params, class Result>
-      [[nodiscard]] repe::error_t call(repe::header&& header, Params&& params, Result&& result)
+      template <class Output>
+      void get(const std::string_view query, Output& output)
       {
-         repe::unique_buffer ubuffer{buffer_pool.get()};
-         auto& buffer = ubuffer.value();
+         if (not connected()) {
+            throw std::runtime_error("asio_client: NOT CONNECTED");
+         }
 
-         header.notify = false;
-         const auto ec = repe::request<Opts>(std::move(header), std::forward<Params>(params), buffer);
-         if (bool(ec)) [[unlikely]] {
-            return {repe::error_e::invalid_params, glz::format_error(ec, buffer)};
+         repe::message response{};
+         auto request = message_pool->borrow();
+         request->body.clear();
+         repe::request<Opts>(repe::user_header{.query = query}, *request);
+         if (bool(request->error())) {
+            throw std::runtime_error("bad request");
          }
 
-         send_buffer(*socket, buffer);
-         receive_buffer(*socket, buffer);
+         unique_socket socket{socket_pool.get()};
+         if (not socket) {
+            socket.ptr.reset();
+            (*is_connected) = false;
+            throw std::runtime_error("socket failure");
+         }
 
-         return repe::decode_response<Opts>(std::forward<Result>(result), buffer);
-      }
+         send_buffer(*socket, *request);
 
-      [[nodiscard]] repe::error_t call(repe::header&& header)
-      {
-         repe::unique_buffer ubuffer{buffer_pool.get()};
-         auto& buffer = ubuffer.value();
+         if (bool(request->error())) {
+            throw std::runtime_error(glz::format_error(request->error()));
+         }
 
-         header.notify = false;
-         header.empty = true; // because no value provided
-         const auto ec = glz::write_json(std::forward_as_tuple(std::move(header), nullptr), buffer);
-         if (bool(ec)) [[unlikely]] {
-            return {repe::error_e::invalid_params, glz::format_error(ec, buffer)};
+         receive_buffer(*socket, response);
+         if (bool(response.error())) {
+            std::string error_message = glz::format_error(response.error());
+            if (response.body.size()) {
+               error_message.append(": ");
+               error_message.append(response.body);
+            }
+            throw std::runtime_error(error_message);
          }
 
-         send_buffer(*socket, buffer);
-         receive_buffer(*socket, buffer);
+         auto ec = read<Opts>(output, response.body);
+         if (bool(ec)) {
+            throw std::runtime_error(glz::format_error(ec, response.body));
+         }
+      }
 
-         return repe::decode_response<Opts>(buffer);
+      // Allocating version of `get`
+      template <class Output>
+      auto get(const std::string_view query)
+      {
+         Output out{};
+         get(query, out);
+         return out;
       }
 
-      template <class Func>
-      [[nodiscard]] std_func_sig_t<Func> callable(repe::header&& header)
+      template <class Input, class Output>
+      void inout(const std::string_view query, Input&& input, Output& output)
       {
-         using Params = func_params_t<Func>;
-         using Result = func_result_t<Func>;
-         if constexpr (std::same_as<Params, void>) {
-            header.empty = true;
-            return [this, h = std::move(header)]() mutable -> Result {
-               std::decay_t<Result> result{};
-               const auto e = call(repe::header{h}, result);
-               if (e) {
-                  throw std::runtime_error(glz::write_json(e));
-               }
-               return result;
-            };
+         if (not connected()) {
+            throw std::runtime_error("asio_client: NOT CONNECTED");
          }
-         else {
-            header.empty = false;
-            return [this, h = std::move(header)](Params params) mutable -> Result {
-               std::decay_t<Result> result{};
-               const auto e = call(repe::header{h}, params, result);
-               if (e) {
-                  throw std::runtime_error(e.message);
-               }
-               return result;
-            };
+
+         repe::message response{};
+         auto request = message_pool->borrow();
+         request->body.clear();
+         repe::request<Opts>(repe::user_header{.query = query}, *request, std::forward<Input>(input));
+         if (bool(request->error())) {
+            throw std::runtime_error("bad request");
          }
-      }
 
-      template <class Params>
-      [[deprecated("We use a buffer pool now, so this would cause allocations")]] [[nodiscard]] std::string call_raw(
-         repe::header&& header, Params&& params, repe::error_t& error)
-      {
-         std::string buffer{};
+         unique_socket socket{socket_pool.get()};
+         if (not socket) {
+            socket.ptr.reset();
+            (*is_connected) = false;
+            throw std::runtime_error("socket failure");
+         }
+
+         send_buffer(*socket, *request);
 
-         header.notify = false;
-         const auto ec = repe::request<Opts>(std::move(header), std::forward<Params>(params), buffer);
-         if (bool(ec)) [[unlikely]] {
-            error = {repe::error_e::invalid_params, glz::format_error(ec, buffer)};
-            return buffer;
+         if (bool(request->error())) {
+            throw std::runtime_error(glz::format_error(request->error()));
          }
 
-         send_buffer(*socket, buffer);
-         receive_buffer(*socket, buffer);
-         return buffer;
+         receive_buffer(*socket, response);
+         if (bool(response.error())) {
+            std::string error_message = glz::format_error(response.error());
+            if (response.body.size()) {
+               error_message.append(": ");
+               error_message.append(response.body);
+            }
+            throw std::runtime_error(error_message);
+         }
+
+         auto ec = read<Opts>(output, response.body);
+         if (bool(ec)) {
+            throw std::runtime_error(glz::format_error(ec, response.body));
+         }
       }
    };
 
-   template <opts Opts = opts{}>
+   template <auto Opts = opts{}>
    struct asio_server
    {
-      uint16_t port{};
-      uint32_t concurrency{1}; // how many threads to use
+      uint16_t port{}; // 0 will select a random free port
+      uint32_t concurrency{1}; // How many threads to use (a call to .run() is inclusive on the main thread)
+
+      // Register a callback that takes a string error message on server/registry errors.
+      // Note that we use a std::string to support a wide source of errors and use e.what()
+      // IMPORTANT: The code within the callback must be thread safe, as multiple threads could call this
+      // simultaneously.
+      std::function<void(const std::string&)> error_handler{};
+
+      ~asio_server() { stop(); }
 
       struct glaze
       {
@@ -292,13 +546,14 @@ namespace glz
 
       std::shared_ptr<asio::io_context> ctx{};
       std::shared_ptr<asio::signal_set> signals{};
+      std::shared_ptr<std::vector<std::thread>> threads{};
 
-      repe::registry<Opts> registry{};
+      glz::registry<Opts> registry{};
 
       void clear_registry() { registry.clear(); }
 
-      template <const std::string_view& Root = repe::detail::empty_path, class T>
-         requires(glz::detail::glaze_object_t<T> || glz::detail::reflectable<T>)
+      template <const std::string_view& Root = detail::empty_path, class T>
+         requires(glaze_object_t<T> || reflectable<T>)
       void on(T& value)
       {
          registry.template on<Root>(value);
@@ -309,56 +564,97 @@ namespace glz
       void init()
       {
          if (!initialized) {
+            if (concurrency == 0) {
+               throw std::runtime_error("concurrency == 0");
+            }
             ctx = std::make_shared<asio::io_context>(concurrency);
             signals = std::make_shared<asio::signal_set>(*ctx, SIGINT, SIGTERM);
          }
          initialized = true;
       }
 
-      void run()
+      void run(bool run_on_main_thread = true)
       {
          if (!initialized) {
             init();
          }
 
+         // Setup signal handling to stop the server
          signals->async_wait([&](auto, auto) { ctx->stop(); });
 
-         asio::co_spawn(*ctx, listener(), asio::detached);
+         // Create the acceptor synchronously so we know the actual port if set to 0 (select random free)
+         auto executor = ctx->get_executor();
+         asio::ip::tcp::acceptor acceptor(executor, {asio::ip::tcp::v6(), port});
+         port = acceptor.local_endpoint().port();
+
+         // Start the listener coroutine
+         asio::co_spawn(*ctx, listener(std::move(acceptor)), asio::detached);
 
-         ctx->run();
+         // Run the io_context in multiple threads for concurrency
+         threads = std::shared_ptr<std::vector<std::thread>>(new std::vector<std::thread>{}, [](auto* ptr) {
+            // Join all threads before exiting
+            for (auto& thread : *ptr) {
+               if (thread.joinable()) {
+                  thread.join();
+               }
+            }
+         });
+
+         threads->reserve(concurrency - uint32_t(run_on_main_thread));
+         for (uint32_t i = uint32_t(run_on_main_thread); i < concurrency; ++i) {
+            threads->emplace_back([this]() { ctx->run(); });
+         }
+
+         if (run_on_main_thread) {
+            // Run in the main thread as well, which will block
+            ctx->run();
+
+            threads.reset(); // join all threads
+         }
       }
 
+      void run_async() { run(false); }
+
       // stop the server
       void stop()
       {
          if (ctx) {
-            ctx->stop();
+            ctx->stop(); // Stop the server's io_context
          }
       }
 
       asio::awaitable<void> run_instance(asio::ip::tcp::socket socket)
       {
          socket.set_option(asio::ip::tcp::no_delay(true));
-         std::string buffer{};
+
+         // Allocate once and reuse memory
+         repe::message request{};
+         repe::message response{};
 
          try {
             while (true) {
-               co_await co_receive_buffer(socket, buffer);
-               auto response = registry.call(buffer);
-               if (response) {
-                  co_await co_send_buffer(socket, response->value());
+               co_await co_receive_buffer(socket, request);
+               response.header.ec = {}; // clear error code, as we use this field to determine if a new error occured
+               registry.call(request, response);
+               if (not request.header.notify) {
+                  co_await co_send_buffer(socket, response);
                }
             }
          }
          catch (const std::exception& e) {
-            std::fprintf(stderr, "%s\n", e.what());
+            if (error_handler) {
+               error_handler(e.what());
+            }
+            else {
+               std::fprintf(stderr, "glz::asio_server error: %s\n", e.what());
+            }
          }
       }
 
-      asio::awaitable<void> listener()
+      asio::awaitable<void> listener(asio::ip::tcp::acceptor acceptor)
       {
          auto executor = co_await asio::this_coro::executor;
-         asio::ip::tcp::acceptor acceptor(executor, {asio::ip::tcp::v6(), port});
+
          while (true) {
             auto socket = co_await acceptor.async_accept(asio::use_awaitable);
             asio::co_spawn(executor, run_instance(std::move(socket)), asio::detached);
diff --git a/deps/saucer/include/glaze/ext/jsonrpc.hpp b/deps/saucer/include/glaze/ext/jsonrpc.hpp
index 747fa9c..3dff073 100644
--- a/deps/saucer/include/glaze/ext/jsonrpc.hpp
+++ b/deps/saucer/include/glaze/ext/jsonrpc.hpp
@@ -49,7 +49,7 @@ namespace glz::rpc
 namespace glz::rpc
 {
    using id_t = std::variant<glz::json_t::null_t, std::string_view, std::int64_t>;
-   static constexpr std::string_view supported_version{"2.0"};
+   inline constexpr std::string_view supported_version{"2.0"};
 
    struct error final
    {
@@ -158,9 +158,7 @@ namespace glz::rpc
       template <class T>
       concept method_type = requires(T) {
          T::name_v;
-         {
-            std::same_as<decltype(T::name_v), std::string_view>
-         };
+         { std::same_as<decltype(T::name_v), std::string_view> };
          typename T::params_t;
          typename T::result_t;
       };
@@ -178,9 +176,8 @@ namespace glz::rpc
       using result_t = typename Method::result_t;
       using request_t = rpc::request_t<params_t>;
       using response_t = rpc::response_t<result_t>;
-      std::function<expected<result_t, rpc::error>(const params_t&)> callback{[](const auto&) {
-         return glz::unexpected{rpc::error{rpc::error_e::internal, "Not implemented"}};
-      }};
+      std::function<expected<result_t, rpc::error>(const params_t&)> callback{
+         [](const auto&) { return glz::unexpected{rpc::error{rpc::error_e::internal, "Not implemented"}}; }};
    };
 
    template <concepts::method_type Method>
@@ -198,7 +195,7 @@ namespace glz::rpc
    namespace detail
    {
       template <string_literal name, class... Method>
-      inline constexpr void set_callback(glz::tuplet::tuple<Method...>& methods, const auto& callback)
+      inline constexpr void set_callback(glz::tuple<Method...>& methods, const auto& callback)
       {
          constexpr bool method_found = ((Method::name_v == name) || ...);
          static_assert(method_found, "Method not settable in given tuple.");
@@ -257,7 +254,7 @@ namespace glz::rpc
       };
 
       template <class Map, string_literal Name, class... Method>
-      auto get_request_map(glz::tuplet::tuple<Method...>& methods) -> Map&
+      auto get_request_map(glz::tuple<Method...>& methods) -> Map&
       {
          constexpr bool method_found = ((Method::name_v == Name) || ...);
          static_assert(method_found, "Method not declared in client.");
@@ -284,7 +281,7 @@ namespace glz::rpc
    {
       using raw_response_t = response_t<glz::raw_json>;
 
-      glz::tuplet::tuple<server_method_t<Method>...> methods{};
+      glz::tuple<server_method_t<Method>...> methods{};
 
       template <string_literal name>
       constexpr void on(const auto& callback) // std::function<expected<result_t, rpc::error>(params_t const&)>
@@ -359,7 +356,7 @@ namespace glz::rpc
             if (req.method != meth_t::name_v) {
                return false;
             }
-            auto const& params_request{glz::read_json<typename meth_t::request_t>(json_request)};
+            const auto& params_request{glz::read_json<typename meth_t::request_t>(json_request)};
             if (params_request.has_value()) {
                expected<typename meth_t::result_t, rpc::error> result{
                   std::invoke(method.callback, params_request->params)};
@@ -411,7 +408,7 @@ namespace glz::rpc
    template <concepts::method_type... Method>
    struct client
    {
-      glz::tuplet::tuple<client_method_t<Method>...> methods{};
+      glz::tuple<client_method_t<Method>...> methods{};
 
       rpc::error call(std::string_view json_response)
       {
diff --git a/deps/saucer/include/glaze/file/file_ops.hpp b/deps/saucer/include/glaze/file/file_ops.hpp
index 67a0c7b..2554333 100644
--- a/deps/saucer/include/glaze/file/file_ops.hpp
+++ b/deps/saucer/include/glaze/file/file_ops.hpp
@@ -18,7 +18,7 @@
 namespace glz
 {
    template <class T>
-   [[nodiscard]] error_code file_to_buffer(T& buffer, auto* file, const std::string_view path) noexcept
+   [[nodiscard]] error_code file_to_buffer(T& buffer, auto* file, const std::string_view path)
    {
       if (!file) {
          return error_code::file_open_failure;
@@ -45,14 +45,14 @@ namespace glz
    }
 
    template <class T>
-   [[nodiscard]] error_code file_to_buffer(T& buffer, const std::string_view file_name) noexcept
+   [[nodiscard]] error_code file_to_buffer(T& buffer, const std::string_view file_name)
    {
       auto* file = std::fopen(file_name.data(), "rb");
       return file_to_buffer(buffer, file, file_name);
    }
 
    template <class T>
-   std::string file_to_buffer(T&& file_name) noexcept
+   std::string file_to_buffer(T&& file_name)
    {
       std::string buffer{};
       file_to_buffer(buffer, std::forward<T>(file_name));
@@ -60,7 +60,7 @@ namespace glz
    }
 
    inline std::filesystem::path relativize_if_not_absolute(const std::filesystem::path& working_directory,
-                                                           const std::filesystem::path& filepath) noexcept
+                                                           const std::filesystem::path& filepath)
    {
       if (filepath.is_absolute()) {
          return filepath;
diff --git a/deps/saucer/include/glaze/file/hostname_include.hpp b/deps/saucer/include/glaze/file/hostname_include.hpp
index 2d67cee..89de467 100644
--- a/deps/saucer/include/glaze/file/hostname_include.hpp
+++ b/deps/saucer/include/glaze/file/hostname_include.hpp
@@ -47,93 +47,92 @@ namespace glz
       }
    };
 
-   namespace detail
+   inline void replace_first_braces(std::string& original, const std::string& replacement) noexcept
    {
-      inline void replace_first_braces(std::string& original, const std::string& replacement) noexcept
-      {
-         static constexpr std::string_view braces = "{}";
+      static constexpr std::string_view braces = "{}";
 
-         if (size_t pos = original.find(braces); pos != std::string::npos) {
-            original.replace(pos, braces.size(), replacement);
-         }
+      if (size_t pos = original.find(braces); pos != std::string::npos) {
+         original.replace(pos, braces.size(), replacement);
       }
+   }
 
-      inline std::string get_hostname(context& ctx) noexcept
-      {
-         char hostname[256]{};
+   inline std::string get_hostname(context& ctx)
+   {
+      char hostname[256]{};
 
 #ifdef _WIN32
-         WSADATA wsaData;
-         if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0) {
-            ctx.error = error_code::hostname_failure;
-            return {};
-         }
+      WSADATA wsaData;
+      if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0) {
+         ctx.error = error_code::hostname_failure;
+         return {};
+      }
 #endif
 
-         if (gethostname(hostname, sizeof(hostname))) {
-            ctx.error = error_code::hostname_failure;
-            return {};
-         }
+      if (gethostname(hostname, sizeof(hostname))) {
+         ctx.error = error_code::hostname_failure;
+         return {};
+      }
 
 #ifdef _WIN32
-         WSACleanup();
+      WSACleanup();
 #endif
 
-         return {hostname};
-      }
+      return {hostname};
+   }
 
-      template <class T>
-      struct from_json<hostname_includer<T>>
+   template <class T>
+   struct from<JSON, detail::hostname_includer<T>>
+   {
+      template <auto Options>
+      static void op(auto&& value, is_context auto&& ctx, auto&& it, auto&& end)
       {
-         template <auto Options>
-         static void op(auto&& value, is_context auto&& ctx, auto&& it, auto&& end) noexcept
-         {
-            constexpr auto Opts = ws_handled_off<Options>();
-            std::string& buffer = string_buffer();
-            read<json>::op<Opts>(buffer, ctx, it, end);
-            if (bool(ctx.error)) [[unlikely]]
-               return;
-
-            replace_first_braces(buffer, get_hostname(ctx));
-            if (bool(ctx.error)) [[unlikely]]
-               return;
-
-            const auto file_path = relativize_if_not_absolute(std::filesystem::path(ctx.current_file).parent_path(),
-                                                              std::filesystem::path{buffer});
-
-            const auto string_file_path = file_path.string();
-            const auto ec = file_to_buffer(buffer, string_file_path);
-
-            if (bool(ec)) [[unlikely]] {
-               ctx.error = error_code::includer_error;
-               auto& error_msg = error_buffer();
-               error_msg = "file failed to open: " + string_file_path;
-               ctx.includer_error = error_msg;
-               return;
-            }
-
-            const auto current_file = ctx.current_file;
-            ctx.current_file = string_file_path;
-
-            const auto ecode = glz::read<Opts>(value.value, buffer, ctx);
-            if (bool(ctx.error)) [[unlikely]] {
-               ctx.error = error_code::includer_error;
-               auto& error_msg = error_buffer();
-               error_msg = glz::format_error(ecode, buffer);
-               ctx.includer_error = error_msg;
-               return;
-            }
-
-            ctx.current_file = current_file;
+         constexpr auto Opts = ws_handled_off<Options>();
+         std::string buffer{};
+         parse<JSON>::op<Opts>(buffer, ctx, it, end);
+         if (bool(ctx.error)) [[unlikely]]
+            return;
+
+         replace_first_braces(buffer, get_hostname(ctx));
+         if (bool(ctx.error)) [[unlikely]]
+            return;
+
+         const auto file_path = relativize_if_not_absolute(std::filesystem::path(ctx.current_file).parent_path(),
+                                                           std::filesystem::path{buffer});
+
+         const auto string_file_path = file_path.string();
+         const auto ec = file_to_buffer(buffer, string_file_path);
+
+         if (bool(ec)) [[unlikely]] {
+            ctx.error = error_code::includer_error;
+            auto& error_msg = error_buffer();
+            error_msg = "file failed to open: " + string_file_path;
+            ctx.includer_error = error_msg;
+            return;
          }
-      };
 
-      template <class T>
-      struct to_json<hostname_includer<T>>
-      {
-         template <auto Opts>
-         GLZ_ALWAYS_INLINE static void op(auto&&...) noexcept
-         {}
-      };
-   }
+         const auto current_file = ctx.current_file;
+         ctx.current_file = string_file_path;
+
+         std::string nested_buffer = buffer;
+         static constexpr auto NestedOpts = opt_true<disable_padding_on<Opts>(), &opts::null_terminated>;
+         const auto ecode = glz::read<NestedOpts>(value.value, nested_buffer, ctx);
+         if (bool(ctx.error)) [[unlikely]] {
+            ctx.error = error_code::includer_error;
+            auto& error_msg = error_buffer();
+            error_msg = glz::format_error(ecode, nested_buffer);
+            ctx.includer_error = error_msg;
+            return;
+         }
+
+         ctx.current_file = current_file;
+      }
+   };
+
+   template <class T>
+   struct to<JSON, detail::hostname_includer<T>>
+   {
+      template <auto Opts>
+      static void op(auto&&...) noexcept
+      {}
+   };
 }
diff --git a/deps/saucer/include/glaze/file/raw_or_file.hpp b/deps/saucer/include/glaze/file/raw_or_file.hpp
index 82e7066..b8bf2eb 100644
--- a/deps/saucer/include/glaze/file/raw_or_file.hpp
+++ b/deps/saucer/include/glaze/file/raw_or_file.hpp
@@ -17,71 +17,68 @@ namespace glz
       std::string str = R"("")";
    };
 
-   namespace detail
+   template <>
+   struct from<JSON, raw_or_file>
    {
-      template <>
-      struct from_json<raw_or_file>
+      template <auto Options>
+      static void op(auto&& value, is_context auto&& ctx, auto&& it, auto&& end)
       {
-         template <auto Options>
-         static void op(auto&& value, is_context auto&& ctx, auto&& it, auto&& end) noexcept
-         {
-            constexpr auto Opts = ws_handled_off<Options>();
-            auto& v = value;
-            // check if we are decoding a string, which could be a file path
-            if (*it == '"') {
-               read<json>::op<Opts>(v.str, ctx, it, end);
-               if (bool(ctx.error)) [[unlikely]]
-                  return;
-
-               namespace fs = std::filesystem;
-               const auto path = relativize_if_not_absolute(fs::path(ctx.current_file).parent_path(), fs::path{v.str});
+         constexpr auto Opts = ws_handled_off<Options>();
+         auto& v = value;
+         // check if we are decoding a string, which could be a file path
+         if (*it == '"') {
+            parse<JSON>::op<Opts>(v.str, ctx, it, end);
+            if (bool(ctx.error)) [[unlikely]]
+               return;
 
-               if (fs::exists(path) && fs::is_regular_file(path)) {
-                  const auto string_path = path.string();
-                  const auto ec = file_to_buffer(v.str, string_path);
+            namespace fs = std::filesystem;
+            const auto path = relativize_if_not_absolute(fs::path(ctx.current_file).parent_path(), fs::path{v.str});
 
-                  if (bool(ec)) [[unlikely]] {
-                     ctx.error = error_code::includer_error;
-                     auto& error_msg = error_buffer();
-                     error_msg = "file failed to open: " + string_path;
-                     ctx.includer_error = error_msg;
-                     return;
-                  }
+            if (fs::exists(path) && fs::is_regular_file(path)) {
+               const auto string_path = path.string();
+               const auto ec = file_to_buffer(v.str, string_path);
 
-                  const auto ecode = validate_jsonc(v.str);
-                  if (ecode) [[unlikely]] {
-                     ctx.error = error_code::includer_error;
-                     auto& error_msg = error_buffer();
-                     error_msg = glz::format_error(ecode, v.str);
-                     ctx.includer_error = error_msg;
-                     return;
-                  }
+               if (bool(ec)) [[unlikely]] {
+                  ctx.error = error_code::includer_error;
+                  auto& error_msg = error_buffer();
+                  error_msg = "file failed to open: " + string_path;
+                  ctx.includer_error = error_msg;
+                  return;
                }
-               else {
-                  // The file path doesn't exist, so we want a string with quotes
-                  // But, we skipped the quotes when first reading
-                  // So, now we add back the quotes
-                  v.str = "\"" + v.str + "\"";
+
+               const auto ecode = validate_jsonc(v.str);
+               if (ecode) [[unlikely]] {
+                  ctx.error = error_code::includer_error;
+                  auto& error_msg = error_buffer();
+                  error_msg = glz::format_error(ecode, v.str);
+                  ctx.includer_error = error_msg;
+                  return;
                }
             }
             else {
-               auto it_start = it;
-               skip_value<Opts>(ctx, it, end);
-               if (bool(ctx.error)) [[unlikely]]
-                  return;
-               value.str = {it_start, static_cast<size_t>(it - it_start)};
+               // The file path doesn't exist, so we want a string with quotes
+               // But, we skipped the quotes when first reading
+               // So, now we add back the quotes
+               v.str = "\"" + v.str + "\"";
             }
          }
-      };
+         else {
+            auto it_start = it;
+            skip_value<JSON>::op<Opts>(ctx, it, end);
+            if (bool(ctx.error)) [[unlikely]]
+               return;
+            value.str = {it_start, static_cast<size_t>(it - it_start)};
+         }
+      }
+   };
 
-      template <>
-      struct to_json<raw_or_file>
+   template <>
+   struct to<JSON, raw_or_file>
+   {
+      template <auto Opts>
+      GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&&, auto&& b, auto&& ix)
       {
-         template <auto Opts>
-         GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&&, auto&& b, auto&& ix) noexcept
-         {
-            dump_maybe_empty(value.str, b, ix);
-         }
-      };
-   }
+         dump_maybe_empty(value.str, b, ix);
+      }
+   };
 }
diff --git a/deps/saucer/include/glaze/file/read_directory.hpp b/deps/saucer/include/glaze/file/read_directory.hpp
new file mode 100644
index 0000000..195fbd7
--- /dev/null
+++ b/deps/saucer/include/glaze/file/read_directory.hpp
@@ -0,0 +1,56 @@
+// Glaze Library
+// For the license information refer to glaze.hpp
+
+#pragma once
+
+#include <filesystem>
+
+#include "glaze/core/read.hpp"
+#include "glaze/file/file_ops.hpp"
+
+namespace glz
+{
+   namespace detail
+   {
+      // TODO: When Apple Clang supports hashing on std::filesystem::path with precompiled headers, we can remove this
+      // std::hash<std::filesystem::path> not in the C++20 standard by default
+      struct fs_path_hash
+      {
+         [[nodiscard]] auto operator()(const std::filesystem::path& path) const noexcept
+         {
+            return std::filesystem::hash_value(path);
+         }
+      };
+   }
+
+   // files should be a map of std::filesystem::path to std::string buffers
+   [[nodiscard]] inline error_ctx directory_to_buffers(auto& files, const sv directory_path,
+                                                       const sv target_extension = ".json")
+   {
+      for (const auto& entry : std::filesystem::directory_iterator(directory_path)) {
+         if (entry.is_regular_file() && (target_extension.empty() || (entry.path().extension() == target_extension))) {
+            if (auto ec = file_to_buffer(files[entry.path()], entry.path().string()); bool(ec)) {
+               return {ec};
+            }
+         }
+      }
+      return {};
+   }
+
+   template <auto Opts = opts{}, readable_map_t T>
+   [[nodiscard]] error_ctx read_directory(T& value, const sv directory_path, const sv target_extension = ".json")
+   {
+      std::unordered_map<std::filesystem::path, std::string, detail::fs_path_hash> files{};
+      if (auto ec = directory_to_buffers(files, directory_path, target_extension)) {
+         return ec;
+      }
+
+      for (auto& [path, content] : files) {
+         if (auto ec = read<Opts>(value[path], content)) {
+            return ec;
+         }
+      }
+
+      return {};
+   }
+}
diff --git a/deps/saucer/include/glaze/file/write_directory.hpp b/deps/saucer/include/glaze/file/write_directory.hpp
new file mode 100644
index 0000000..7950357
--- /dev/null
+++ b/deps/saucer/include/glaze/file/write_directory.hpp
@@ -0,0 +1,56 @@
+// Glaze Library
+// For the license information refer to glaze.hpp
+
+#pragma once
+
+#include <filesystem>
+
+#include "glaze/core/write.hpp"
+#include "glaze/file/file_ops.hpp"
+
+namespace glz
+{
+   [[nodiscard]] inline error_ctx buffers_to_directory(
+      const std::unordered_map<std::filesystem::path, std::string>& buffers, const sv directory)
+   {
+      namespace fs = std::filesystem;
+      if (not fs::exists(directory)) {
+         fs::create_directory(directory);
+      }
+
+      for (auto& [path, content] : buffers) {
+         return {buffer_to_file(content, path.string())};
+      }
+
+      return {};
+   }
+
+   template <auto Opts = opts{}, writable_map_t T>
+   [[nodiscard]] error_ctx write_directory(T&& value, const sv directory_path)
+   {
+      namespace fs = std::filesystem;
+      if (not fs::exists(directory_path)) {
+         fs::create_directory(directory_path);
+      }
+
+      for (auto& [path, content] : value) {
+         using Path = std::decay_t<decltype(path)>;
+         std::string buffer{};
+         if constexpr (std::same_as<std::filesystem::path, Path>) {
+            if (auto ec = glz::write_json(content, buffer)) {
+               return ec;
+            }
+            if (auto ec = buffer_to_file(buffer, path.string()); bool(ec)) {
+               return {ec};
+            }
+         }
+         else {
+            if (auto ec = buffer_to_file(content, path); bool(ec)) {
+               return {ec};
+            }
+         }
+      }
+
+      return {};
+   }
+}
diff --git a/deps/saucer/include/glaze/format/format_to.hpp b/deps/saucer/include/glaze/format/format_to.hpp
new file mode 100644
index 0000000..991489b
--- /dev/null
+++ b/deps/saucer/include/glaze/format/format_to.hpp
@@ -0,0 +1,23 @@
+// Glaze Library
+// For the license information refer to glaze.hpp
+
+#pragma once
+
+#include "glaze/core/write.hpp"
+#include "glaze/util/dtoa.hpp"
+#include "glaze/util/itoa.hpp"
+
+namespace glz
+{
+   template <num_t T>
+   void format_to(std::string& buffer, T&& value)
+   {
+      auto ix = buffer.size();
+      buffer.resize((std::max)(buffer.size() * 2, ix + 64));
+
+      const auto start = buffer.data() + ix;
+      const auto end = glz::to_chars(start, std::forward<T>(value));
+      ix += size_t(end - start);
+      buffer.resize(ix);
+   }
+}
diff --git a/deps/saucer/include/glaze/glaze.hpp b/deps/saucer/include/glaze/glaze.hpp
index 4a30740..8bc2dee 100644
--- a/deps/saucer/include/glaze/glaze.hpp
+++ b/deps/saucer/include/glaze/glaze.hpp
@@ -32,9 +32,13 @@
 
 #pragma once
 
-#include "glaze/binary.hpp"
-#include "glaze/binary/beve_to_json.hpp"
+#include "glaze/base64/base64.hpp"
+#include "glaze/beve.hpp"
+#include "glaze/beve/beve_to_json.hpp"
 #include "glaze/csv.hpp"
 #include "glaze/file/file_ops.hpp"
+#include "glaze/file/read_directory.hpp"
+#include "glaze/file/write_directory.hpp"
 #include "glaze/json.hpp"
 #include "glaze/record/recorder.hpp"
+#include "glaze/stencil/stencil.hpp"
diff --git a/deps/saucer/include/glaze/glaze_exceptions.hpp b/deps/saucer/include/glaze/glaze_exceptions.hpp
index c0dc725..3fd9687 100644
--- a/deps/saucer/include/glaze/glaze_exceptions.hpp
+++ b/deps/saucer/include/glaze/glaze_exceptions.hpp
@@ -13,12 +13,12 @@
 
 namespace glz::ex
 {
-   template <opts Opts>
+   template <auto Opts>
    void read(auto& value, auto&& buffer)
    {
       auto ec = glz::read<Opts>(value, buffer);
       if (ec) {
-         if constexpr (Opts.format == json) {
+         if constexpr (Opts.format == JSON) {
             throw std::runtime_error("read error: " + glz::format_error(ec, buffer));
          }
          else {
@@ -27,13 +27,13 @@ namespace glz::ex
       }
    }
 
-   template <opts Opts, class T, output_buffer Buffer>
+   template <auto Opts, class T, output_buffer Buffer>
    void write(T&& value, Buffer& buffer) noexcept
    {
       glz::write<Opts>(std::forward<T>(value), buffer);
    }
 
-   template <opts Opts, class T, raw_buffer Buffer>
+   template <auto Opts, class T, raw_buffer Buffer>
    size_t write(T&& value, Buffer&& buffer) noexcept
    {
       return glz::write<Opts>(std::forward<T>(value), std::forward<Buffer>(buffer));
diff --git a/deps/saucer/include/glaze/json.hpp b/deps/saucer/include/glaze/json.hpp
index b3b3963..50a5109 100644
--- a/deps/saucer/include/glaze/json.hpp
+++ b/deps/saucer/include/glaze/json.hpp
@@ -3,10 +3,13 @@
 
 #pragma once
 
-#include "glaze/json/custom.hpp"
+#include "glaze/core/manage.hpp"
+#include "glaze/json/escape_unicode.hpp"
 #include "glaze/json/invoke.hpp"
+#include "glaze/json/jmespath.hpp"
+#include "glaze/json/json_concepts.hpp"
 #include "glaze/json/json_ptr.hpp"
-#include "glaze/json/manage.hpp"
+#include "glaze/json/json_t.hpp"
 #include "glaze/json/max_write_precision.hpp"
 #include "glaze/json/minify.hpp"
 #include "glaze/json/ndjson.hpp"
@@ -17,3 +20,4 @@
 #include "glaze/json/schema.hpp"
 #include "glaze/json/wrappers.hpp"
 #include "glaze/json/write.hpp"
+#include "glaze/thread/atomic.hpp"
diff --git a/deps/saucer/include/glaze/json/escape_unicode.hpp b/deps/saucer/include/glaze/json/escape_unicode.hpp
new file mode 100644
index 0000000..d5d8966
--- /dev/null
+++ b/deps/saucer/include/glaze/json/escape_unicode.hpp
@@ -0,0 +1,257 @@
+// Glaze Library
+// For the license information refer to glaze.hpp
+
+#pragma once
+
+#include <cstdint>
+#include <string>
+
+#include "glaze/util/string_literal.hpp"
+
+// JSON does not require escaped unicode keys to match with unescaped UTF-8
+// In order to match with escaped unicode you can register your fields with
+// the escaped unicode value.
+// glz::escape_unicode<"😀"> will generate a compile time escaped unicode version
+// of your key.
+
+namespace glz::detail
+{
+   // Helper function to append a Unicode escape sequence to the output string.
+   inline constexpr void append_unicode_escape(std::string& output, uint16_t code_unit)
+   {
+      output += '\\';
+      output += 'u';
+      for (int shift = 12; shift >= 0; shift -= 4) {
+         uint8_t digit = (code_unit >> shift) & 0xF;
+         output += (digit < 10) ? ('0' + digit) : ('A' + (digit - 10));
+      }
+   }
+
+   // Function to calculate the length of the escaped JSON string.
+   inline constexpr size_t escaped_length(const std::string_view input)
+   {
+      size_t length = 0;
+      size_t i = 0;
+      size_t len = input.size();
+
+      while (i < len) {
+         unsigned char c = static_cast<unsigned char>(input[i++]);
+
+         if (c <= 0x7F) {
+            // ASCII character
+            switch (c) {
+            case '\"':
+            case '\\':
+            case '\b':
+            case '\f':
+            case '\n':
+            case '\r':
+            case '\t':
+               length += 2; // Escaped as two characters
+               break;
+            default:
+               if (c <= 0x1F) {
+                  length += 6; // Control character, escaped as \u00XX
+               }
+               else {
+                  length += 1; // Regular character
+               }
+               break;
+            }
+         }
+         else {
+            // Multibyte UTF-8 character
+            uint32_t codepoint = 0;
+            int bytes = 0;
+
+            if ((c & 0xE0) == 0xC0) {
+               // 2-byte sequence
+               codepoint = c & 0x1F;
+               bytes = 1;
+            }
+            else if ((c & 0xF0) == 0xE0) {
+               // 3-byte sequence
+               codepoint = c & 0x0F;
+               bytes = 2;
+            }
+            else if ((c & 0xF8) == 0xF0) {
+               // 4-byte sequence
+               codepoint = c & 0x07;
+               bytes = 3;
+            }
+            else {
+               // Invalid UTF-8 start byte
+               codepoint = 0xFFFD;
+               bytes = 0;
+            }
+
+            bool invalid_sequence = false;
+
+            for (int j = 0; j < bytes; ++j) {
+               if (i == len) {
+                  invalid_sequence = true;
+                  break;
+               }
+               unsigned char c2 = static_cast<unsigned char>(input[i]);
+               if ((c2 & 0xC0) != 0x80) {
+                  invalid_sequence = true;
+                  break;
+               }
+               codepoint = (codepoint << 6) | (c2 & 0x3F);
+               ++i;
+            }
+
+            if (invalid_sequence) {
+               // Invalid UTF-8 sequence, replace with U+FFFD
+               codepoint = 0xFFFD;
+            }
+
+            if (codepoint <= 0xFFFF) {
+               length += 6; // Escaped as \uXXXX
+            }
+            else {
+               length += 12; // Surrogate pair, escaped as \uXXXX\uXXXX
+            }
+         }
+      }
+
+      return length;
+   }
+
+   // Main function to escape the JSON string.
+   inline constexpr std::string escape_json_string(const std::string_view input, const size_t output_length)
+   {
+      std::string output;
+      output.reserve(output_length);
+
+      size_t i = 0;
+      size_t len = input.size();
+
+      while (i < len) {
+         unsigned char c = static_cast<unsigned char>(input[i++]);
+
+         if (c <= 0x7F) {
+            // ASCII character
+            switch (c) {
+            case '\"':
+               output += "\\\"";
+               break;
+            case '\\':
+               output += "\\\\";
+               break;
+            case '\b':
+               output += "\\b";
+               break;
+            case '\f':
+               output += "\\f";
+               break;
+            case '\n':
+               output += "\\n";
+               break;
+            case '\r':
+               output += "\\r";
+               break;
+            case '\t':
+               output += "\\t";
+               break;
+            default:
+               if (c <= 0x1F) {
+                  // Control character, escape using \u00XX
+                  output += "\\u00";
+                  uint8_t high_nibble = (c >> 4) & 0xF;
+                  uint8_t low_nibble = c & 0xF;
+                  output += (high_nibble < 10) ? ('0' + high_nibble) : ('A' + high_nibble - 10);
+                  output += (low_nibble < 10) ? ('0' + low_nibble) : ('A' + low_nibble - 10);
+               }
+               else {
+                  output += c;
+               }
+               break;
+            }
+         }
+         else {
+            // Multibyte UTF-8 character
+            uint32_t codepoint = 0;
+            int bytes = 0;
+
+            if ((c & 0xE0) == 0xC0) {
+               // 2-byte sequence
+               codepoint = c & 0x1F;
+               bytes = 1;
+            }
+            else if ((c & 0xF0) == 0xE0) {
+               // 3-byte sequence
+               codepoint = c & 0x0F;
+               bytes = 2;
+            }
+            else if ((c & 0xF8) == 0xF0) {
+               // 4-byte sequence
+               codepoint = c & 0x07;
+               bytes = 3;
+            }
+            else {
+               // Invalid UTF-8 start byte, replace with U+FFFD
+               codepoint = 0xFFFD;
+               bytes = 0;
+            }
+
+            bool invalid_sequence = false;
+
+            for (int j = 0; j < bytes; ++j) {
+               if (i == len) {
+                  invalid_sequence = true;
+                  break;
+               }
+               unsigned char c2 = static_cast<unsigned char>(input[i]);
+               if ((c2 & 0xC0) != 0x80) {
+                  invalid_sequence = true;
+                  break;
+               }
+               codepoint = (codepoint << 6) | (c2 & 0x3F);
+               ++i;
+            }
+
+            if (invalid_sequence) {
+               // Invalid UTF-8 sequence, replace with U+FFFD
+               codepoint = 0xFFFD;
+            }
+
+            if (codepoint <= 0xFFFF) {
+               // BMP character
+               append_unicode_escape(output, static_cast<uint16_t>(codepoint));
+            }
+            else {
+               // Supplementary character (needs surrogate pair)
+               codepoint -= 0x10000;
+               uint16_t high_surrogate = uint16_t(0xD800 + (codepoint >> 10));
+               uint16_t low_surrogate = uint16_t(0xDC00 + (codepoint & 0x3FF));
+               append_unicode_escape(output, high_surrogate);
+               append_unicode_escape(output, low_surrogate);
+            }
+         }
+      }
+
+      return output;
+   }
+}
+
+namespace glz
+{
+   template <string_literal Str>
+   inline constexpr auto escape_unicode = []() constexpr -> std::string_view {
+      constexpr auto escaped = []() constexpr {
+         constexpr auto len = detail::escaped_length(Str.sv());
+         std::array<char, len + 1> result; // + 1 for null character
+         const auto escaped = detail::escape_json_string(Str.sv(), len);
+         for (size_t i = 0; i < len; ++i) {
+            result[i] = escaped[i];
+         }
+         result[len] = '\0';
+         return result;
+      }();
+
+      // make_static here required for GCC 12, in the future just make escaped static
+      auto& arr = detail::make_static<escaped>::value;
+      return {arr.data(), arr.size() - 1};
+   }();
+}
diff --git a/deps/saucer/include/glaze/json/invoke.hpp b/deps/saucer/include/glaze/json/invoke.hpp
index bb905f2..cd1ebdd 100644
--- a/deps/saucer/include/glaze/json/invoke.hpp
+++ b/deps/saucer/include/glaze/json/invoke.hpp
@@ -30,110 +30,108 @@ namespace glz
       mem_fun ptr;
    };
 
-   namespace detail
+   template <class T>
+   struct from<JSON, invoke_t<T>>
    {
-      template <class T>
-      struct from_json<invoke_t<T>>
+      template <auto Opts>
+      static void op(auto&& value, is_context auto&& ctx, auto&& it, auto&& end)
       {
-         template <auto Opts>
-         GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, auto&& it, auto&& end) noexcept
-         {
-            using V = std::decay_t<decltype(value.val)>;
-
-            if constexpr (std::is_member_function_pointer_v<T>) {
-               using M = typename std::decay_t<decltype(value)>::mem_fun;
-               using Ret = typename return_type<M>::type;
-
-               if constexpr (std::is_void_v<Ret>) {
-                  using Tuple = typename inputs_as_tuple<M>::type;
-                  if constexpr (glz::tuple_size_v<Tuple> == 0) {
-                     skip_array<Opts>(ctx, it, end);
-                     if (bool(ctx.error)) [[unlikely]]
-                        return;
-                     (value.val.*value.ptr)();
-                  }
-                  else {
-                     Tuple inputs{};
-                     read<json>::op<Opts>(inputs, ctx, it, end);
-                     if (bool(ctx.error)) [[unlikely]]
-                        return;
-                     std::apply(
-                        [&](auto&&... args) { return (value.val.*value.ptr)(std::forward<decltype(args)>(args)...); },
-                        inputs);
-                  }
+         using V = std::decay_t<decltype(value.val)>;
+
+         if constexpr (std::is_member_function_pointer_v<T>) {
+            using M = typename std::decay_t<decltype(value)>::mem_fun;
+            using Ret = typename return_type<M>::type;
+
+            if constexpr (std::is_void_v<Ret>) {
+               using Tuple = typename inputs_as_tuple<M>::type;
+               if constexpr (glz::tuple_size_v<Tuple> == 0) {
+                  skip_array<Opts>(ctx, it, end);
+                  if (bool(ctx.error)) [[unlikely]]
+                     return;
+                  (value.val.*value.ptr)();
                }
                else {
-                  static_assert(false_v<T>, "function must have void return");
+                  Tuple inputs{};
+                  parse<JSON>::op<Opts>(inputs, ctx, it, end);
+                  if (bool(ctx.error)) [[unlikely]]
+                     return;
+                  std::apply(
+                     [&](auto&&... args) { return (value.val.*value.ptr)(std::forward<decltype(args)>(args)...); },
+                     inputs);
                }
             }
-            else if constexpr (is_specialization_v<V, std::function>) {
-               using Ret = typename function_traits<V>::result_type;
-
-               if constexpr (std::is_void_v<Ret>) {
-                  using Tuple = typename function_traits<V>::arguments;
-                  if constexpr (glz::tuple_size_v<Tuple> == 0) {
-                     skip_array<Opts>(ctx, it, end);
-                     if (bool(ctx.error)) [[unlikely]]
-                        return;
-                     value.val();
-                  }
-                  else {
-                     Tuple inputs{};
-                     read<json>::op<Opts>(inputs, ctx, it, end);
-                     if (bool(ctx.error)) [[unlikely]]
-                        return;
-                     std::apply(value.val, inputs);
-                  }
+            else {
+               static_assert(false_v<T>, "function must have void return");
+            }
+         }
+         else if constexpr (is_specialization_v<V, std::function>) {
+            using Ret = typename function_traits<V>::result_type;
+
+            if constexpr (std::is_void_v<Ret>) {
+               using Tuple = typename function_traits<V>::arguments;
+               if constexpr (glz::tuple_size_v<Tuple> == 0) {
+                  skip_array<Opts>(ctx, it, end);
+                  if (bool(ctx.error)) [[unlikely]]
+                     return;
+                  value.val();
                }
                else {
-                  static_assert(false_v<T>, "std::function must have void return");
+                  Tuple inputs{};
+                  parse<JSON>::op<Opts>(inputs, ctx, it, end);
+                  if (bool(ctx.error)) [[unlikely]]
+                     return;
+                  std::apply(value.val, inputs);
                }
             }
             else {
-               static_assert(false_v<T>, "type must be invocable");
+               static_assert(false_v<T>, "std::function must have void return");
             }
          }
-      };
+         else {
+            static_assert(false_v<T>, "type must be invocable");
+         }
+      }
+   };
 
-      template <class T>
-      struct to_json<invoke_t<T>>
+   template <class T>
+   struct to<JSON, invoke_t<T>>
+   {
+      template <auto Opts>
+      static void op(auto&& value, is_context auto&& ctx, auto&&... args)
       {
-         template <auto Opts>
-         GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, auto&&... args) noexcept
-         {
-            using V = std::decay_t<decltype(value.val)>;
-            dump<'['>(args...);
-            if constexpr (is_specialization_v<V, std::function>) {
-               using Ret = typename function_traits<V>::result_type;
-
-               if constexpr (std::is_void_v<Ret>) {
-                  using Tuple = typename function_traits<V>::arguments;
-                  Tuple inputs{};
-                  write<json>::op<Opts>(inputs, ctx, args...);
-               }
-               else {
-                  static_assert(false_v<T>, "std::function must have void return");
-               }
+         using V = std::decay_t<decltype(value.val)>;
+         dump<'['>(args...);
+         if constexpr (is_specialization_v<V, std::function>) {
+            using Ret = typename function_traits<V>::result_type;
+
+            if constexpr (std::is_void_v<Ret>) {
+               using Tuple = typename function_traits<V>::arguments;
+               Tuple inputs{};
+               using Inputs = std::remove_cvref_t<decltype(inputs)>;
+               to<JSON, Inputs>::template op<Opts>(inputs, ctx, args...);
+            }
+            else {
+               static_assert(false_v<T>, "std::function must have void return");
             }
-            dump<']'>(args...);
          }
-      };
+         dump<']'>(args...);
+      }
+   };
 
-      template <auto MemPtr>
-      inline constexpr decltype(auto) invoke_impl() noexcept
-      {
-         using V = decltype(MemPtr);
-         if constexpr (std::is_member_function_pointer_v<V>) {
-            return [](auto&& val) { return invoke_t<std::decay_t<V>>{val, MemPtr}; };
-         }
-         else {
-            return [](auto&& val) { return invoke_t<std::decay_t<decltype(val.*MemPtr)>>{val.*MemPtr}; };
-         }
+   template <auto MemPtr>
+   inline constexpr decltype(auto) invoke_impl()
+   {
+      using V = decltype(MemPtr);
+      if constexpr (std::is_member_function_pointer_v<V>) {
+         return [](auto&& val) { return invoke_t<std::decay_t<V>>{val, MemPtr}; };
+      }
+      else {
+         return [](auto&& val) { return invoke_t<std::decay_t<decltype(val.*MemPtr)>>{val.*MemPtr}; };
       }
    }
 
    template <auto MemPtr>
-   constexpr auto invoke = detail::invoke_impl<MemPtr>();
+   constexpr auto invoke = invoke_impl<MemPtr>();
 }
 
 namespace glz
@@ -166,70 +164,68 @@ namespace glz
       T::glaze;
    };
 
-   namespace detail
+   template <is_invoke_update T>
+   struct from<JSON, T>
    {
-      template <is_invoke_update T>
-      struct from_json<T>
+      template <auto Opts>
+      static void op(auto&& value, is_context auto&& ctx, auto&& it, auto&& end)
       {
-         template <auto Opts>
-         GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, auto&& it, auto&& end) noexcept
-         {
-            using V = std::decay_t<decltype(value.func)>;
-
-            using Tuple = typename function_traits<V>::arguments;
-            if constexpr (glz::tuple_size_v<Tuple> == 0) {
-               auto start = it;
-               skip_array<Opts>(ctx, it, end);
-               if (bool(ctx.error)) [[unlikely]]
-                  return;
-               const sv input = {start, size_t(it - start)};
-               if (value.initialized) {
-                  if (input != value.prev) {
-                     value.func();
-                  }
+         using V = std::decay_t<decltype(value.func)>;
+
+         using Tuple = typename function_traits<V>::arguments;
+         if constexpr (glz::tuple_size_v<Tuple> == 0) {
+            auto start = it;
+            skip_array<Opts>(ctx, it, end);
+            if (bool(ctx.error)) [[unlikely]]
+               return;
+            const sv input = {start, size_t(it - start)};
+            if (value.initialized) {
+               if (input != value.prev) {
+                  value.func();
                }
-               else {
-                  value.initialized = true;
-               }
-               value.prev = input;
             }
             else {
-               auto start = it;
-               skip_array<Opts>(ctx, it, end);
-               if (bool(ctx.error)) [[unlikely]]
-                  return;
-               const sv input = {start, size_t(it - start)};
-               if (value.initialized) {
-                  if (input != value.prev) {
-                     Tuple inputs{};
-                     it = start;
-                     read<json>::op<Opts>(inputs, ctx, it, end);
-                     if (bool(ctx.error)) [[unlikely]]
-                        return;
-                     std::apply(value.func, inputs);
-                  }
-               }
-               else {
-                  value.initialized = true;
+               value.initialized = true;
+            }
+            value.prev = input;
+         }
+         else {
+            auto start = it;
+            skip_array<Opts>(ctx, it, end);
+            if (bool(ctx.error)) [[unlikely]]
+               return;
+            const sv input = {start, size_t(it - start)};
+            if (value.initialized) {
+               if (input != value.prev) {
+                  Tuple inputs{};
+                  it = start;
+                  parse<JSON>::op<Opts>(inputs, ctx, it, end);
+                  if (bool(ctx.error)) [[unlikely]]
+                     return;
+                  std::apply(value.func, inputs);
                }
-               value.prev = input;
             }
+            else {
+               value.initialized = true;
+            }
+            value.prev = input;
          }
-      };
+      }
+   };
 
-      template <is_invoke_update T>
-      struct to_json<T>
+   template <is_invoke_update T>
+   struct to<JSON, T>
+   {
+      template <auto Opts>
+      static void op(auto&& value, is_context auto&& ctx, auto&&... args)
       {
-         template <auto Opts>
-         GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, auto&&... args) noexcept
-         {
-            using V = std::decay_t<decltype(value.val)>;
-            dump<'['>(args...);
-            using Tuple = typename function_traits<V>::arguments;
-            Tuple inputs{};
-            write<json>::op<Opts>(inputs, ctx, args...);
-            dump<']'>(args...);
-         }
-      };
-   }
+         using V = std::decay_t<decltype(value.val)>;
+         dump<'['>(args...);
+         using Tuple = typename function_traits<V>::arguments;
+         Tuple inputs{};
+         using Inputs = std::remove_cvref_t<decltype(inputs)>;
+         to<JSON, Inputs>::template op<Opts>(inputs, ctx, args...);
+         dump<']'>(args...);
+      }
+   };
 }
diff --git a/deps/saucer/include/glaze/json/jmespath.hpp b/deps/saucer/include/glaze/json/jmespath.hpp
new file mode 100644
index 0000000..f7c06ba
--- /dev/null
+++ b/deps/saucer/include/glaze/json/jmespath.hpp
@@ -0,0 +1,1121 @@
+// Glaze Library
+// For the license information refer to glaze.hpp
+
+#pragma once
+
+#include <algorithm>
+#include <charconv>
+#include <optional>
+
+#include "glaze/core/seek.hpp"
+#include "glaze/json/read.hpp"
+#include "glaze/json/skip.hpp"
+#include "glaze/util/parse.hpp"
+#include "glaze/util/string_literal.hpp"
+
+namespace glz
+{
+   namespace jmespath
+   {
+      enum struct tokenization_error {
+         none, // No error
+         unbalanced_brackets, // Mismatched '[' and ']'
+         unbalanced_parentheses, // Mismatched '(' and ')'
+         unclosed_string, // String literal not properly closed
+         invalid_escape_sequence, // Invalid escape sequence in string
+         unexpected_delimiter, // Unexpected character encountered (e.g., consecutive delimiters)
+      };
+
+      struct tokenization_result
+      {
+         std::string_view first;
+         std::string_view second;
+         tokenization_error error;
+      };
+
+      /**
+       * @brief Trims leading whitespace characters from a string_view.
+       *
+       * @param s The input string_view to trim.
+       * @return A string_view with leading whitespace removed.
+       */
+      inline constexpr std::string_view trim_left(std::string_view s)
+      {
+         size_t start = 0;
+         while (start < s.size() && (s[start] == ' ' || s[start] == '\t' || s[start] == '\n' || s[start] == '\r')) {
+            start++;
+         }
+         return s.substr(start);
+      }
+
+      /**
+       * @brief Splits a JMESPath expression into the first token and the remaining path with error handling.
+       *
+       * @param s The JMESPath expression to tokenize.
+       * @return tokenization_result containing:
+       *         - first: The first token of the expression.
+       *         - second: The remaining expression after the first token.
+       *         - error: tokenization_error indicating if an error occurred.
+       */
+      inline constexpr tokenization_result tokenize_jmes_path(std::string_view s)
+      {
+         if (s.empty()) {
+            return {"", "", tokenization_error::none};
+         }
+
+         size_t pos = 0;
+         size_t len = s.size();
+         int bracket_level = 0;
+         int parenthesis_level = 0;
+         bool in_string = false;
+         char string_delim = '\0';
+
+         while (pos < len) {
+            char current = s[pos];
+
+            if (in_string) {
+               if (current == string_delim) {
+                  // Check for escaped delimiter
+                  size_t backslashes = 0;
+                  size_t temp = pos;
+                  while (temp > 0 && s[--temp] == '\\') {
+                     backslashes++;
+                  }
+                  if (backslashes % 2 == 0) {
+                     in_string = false;
+                  }
+               }
+               else if (current == '\\') {
+                  // Validate escape sequence
+                  if (pos + 1 >= len) {
+                     return {"", "", tokenization_error::invalid_escape_sequence};
+                  }
+                  char next_char = s[pos + 1];
+                  // Simple validation: allow known escape characters
+                  if (next_char != '"' && next_char != '\'' && next_char != '\\' && next_char != '/' &&
+                      next_char != 'b' && next_char != 'f' && next_char != 'n' && next_char != 'r' &&
+                      next_char != 't' && next_char != 'u') {
+                     return {"", "", tokenization_error::invalid_escape_sequence};
+                  }
+               }
+               pos++;
+               continue;
+            }
+
+            switch (current) {
+            case '"':
+            case '\'':
+               in_string = true;
+               string_delim = current;
+               pos++;
+               break;
+            case '[':
+               bracket_level++;
+               pos++;
+               break;
+            case ']':
+               if (bracket_level > 0) {
+                  bracket_level--;
+               }
+               else {
+                  return {"", "", tokenization_error::unbalanced_brackets};
+               }
+               pos++;
+               break;
+            case '(':
+               parenthesis_level++;
+               pos++;
+               break;
+            case ')':
+               if (parenthesis_level > 0) {
+                  parenthesis_level--;
+               }
+               else {
+                  return {"", "", tokenization_error::unbalanced_parentheses};
+               }
+               pos++;
+               break;
+            case '.':
+            case '|':
+               if (bracket_level == 0 && parenthesis_level == 0) {
+                  // Split here
+                  return {s.substr(0, pos), s.substr(pos, len - pos), tokenization_error::none};
+               }
+               pos++;
+               break;
+            default:
+               pos++;
+               break;
+            }
+         }
+
+         if (in_string) {
+            return {"", "", tokenization_error::unclosed_string};
+         }
+
+         if (bracket_level != 0) {
+            return {"", "", tokenization_error::unbalanced_brackets};
+         }
+
+         if (parenthesis_level != 0) {
+            return {"", "", tokenization_error::unbalanced_parentheses};
+         }
+
+         // If no delimiter found, return the whole string as first token
+         return {s, "", tokenization_error::none};
+      }
+
+      inline constexpr tokenization_error finalize_tokens(std::vector<std::string_view>& tokens)
+      {
+         std::vector<std::string_view> final_tokens;
+         final_tokens.reserve(tokens.size()); // at least
+
+         for (auto token : tokens) {
+            size_t start = 0;
+            while (start < token.size()) {
+               // Find the next '['
+               auto open = token.find('[', start);
+               if (open == std::string_view::npos) {
+                  // No more bracketed segments
+                  if (start < token.size()) {
+                     // Add remaining part (if not empty)
+                     final_tokens.push_back(token.substr(start));
+                  }
+                  break; // move to next token
+               }
+               else {
+                  // If there's a key part before the bracket, add it
+                  if (open > start) {
+                     final_tokens.push_back(token.substr(start, open - start));
+                  }
+                  // Now find the closing bracket ']'
+                  auto close = token.find(']', open + 1);
+                  if (close == std::string_view::npos) {
+                     // Mismatched bracket
+                     return tokenization_error::unbalanced_brackets;
+                  }
+                  // Extract the bracketed token: e.g. [0]
+                  final_tokens.push_back(token.substr(open, close - open + 1));
+                  start = close + 1; // continue after the ']'
+               }
+            }
+         }
+
+         tokens = std::move(final_tokens);
+         return tokenization_error::none;
+      }
+
+      /**
+       * @brief Recursively tokenizes a full JMESPath expression into all its tokens with error handling.
+       *
+       * @param expression The complete JMESPath expression to tokenize.
+       * @param tokens A vector to store all tokens in the order they appear.
+       * @param error An output parameter to capture any tokenization errors.
+       * @return true if tokenization succeeded without errors, false otherwise.
+       */
+      inline constexpr jmespath::tokenization_error tokenize_full_jmespath(std::string_view expression,
+                                                                           std::vector<std::string_view>& tokens)
+      {
+         tokens.clear();
+         auto remaining = expression;
+
+         while (!remaining.empty()) {
+            tokenization_result result = tokenize_jmes_path(remaining);
+            if (result.error != tokenization_error::none) {
+               return result.error;
+            }
+
+            if (result.first.empty()) {
+               return tokenization_error::unexpected_delimiter;
+            }
+
+            tokens.emplace_back(result.first);
+
+            if (!result.second.empty()) {
+               char delimiter = result.second.front();
+               if (delimiter == '.' || delimiter == '|') {
+                  remaining = result.second.substr(1);
+                  remaining = trim_left(remaining);
+                  if (!remaining.empty() && (remaining.front() == '.' || remaining.front() == '|')) {
+                     return tokenization_error::unexpected_delimiter;
+                  }
+               }
+               else {
+                  return tokenization_error::unexpected_delimiter;
+               }
+            }
+            else {
+               break;
+            }
+         }
+
+         // New step: finalize the tokens by splitting multiple bracket accesses
+         auto err = finalize_tokens(tokens);
+         if (err != jmespath::tokenization_error::none) {
+            return err;
+         }
+
+         return tokenization_error::none;
+      }
+
+      template <const std::string_view& expression>
+      consteval auto tokenize_as_array()
+      {
+         constexpr auto N = [] {
+            std::vector<std::string_view> tokens;
+            auto err = tokenize_full_jmespath(expression, tokens);
+            if (err != tokenization_error::none) {
+               std::abort();
+            }
+            return tokens.size();
+         }();
+
+         std::vector<std::string_view> tokens;
+         auto err = tokenize_full_jmespath(expression, tokens);
+         if (err != tokenization_error::none) {
+            std::abort();
+         }
+
+         std::array<std::string_view, N> arr{};
+         for (std::size_t i = 0; i < N; ++i) {
+            arr[i] = tokens[i];
+         }
+         return arr; // Vector destroyed here, leaving only the array.
+      }
+
+      struct ArrayParseResult
+      {
+         bool is_array_access = false; // True if "key[...]"
+         bool error = false; // True if parsing encountered an error
+         std::string_view key; // The part before the first '['
+         std::optional<int32_t> start; // For a single index or slice start
+         std::optional<int32_t> end; // For slice end
+         std::optional<int32_t> step; // For slice step
+         size_t colon_count = 0; // Number of ':' characters found inside the brackets
+      };
+
+      inline constexpr std::optional<int> parse_int(std::string_view s)
+      {
+         if (s.empty()) {
+            return std::nullopt;
+         }
+         int value;
+         auto result = detail::from_chars(s.data(), s.data() + s.size(), value);
+         if (result.ec == std::errc()) {
+            return value;
+         }
+         return std::nullopt;
+      }
+
+      // Parse a token that may have array indexing or slicing.
+      inline constexpr ArrayParseResult parse_jmespath_token(std::string_view token)
+      {
+         ArrayParseResult result;
+
+         // Find the first '['
+         auto open_pos = token.find('[');
+         if (open_pos == std::string_view::npos) {
+            // No array access, just a key.
+            result.key = token;
+            return result;
+         }
+
+         auto close_pos = token.rfind(']');
+         if (close_pos == std::string_view::npos || close_pos < open_pos) {
+            // Mismatched brackets -> error
+            result.key = token.substr(0, open_pos);
+            result.is_array_access = true;
+            result.error = true;
+            return result;
+         }
+
+         result.is_array_access = true;
+         result.key = token.substr(0, open_pos);
+         auto inside = token.substr(open_pos + 1, close_pos - (open_pos + 1));
+         if (inside.empty()) {
+            // Empty inside "[]" is invalid
+            result.error = true;
+            return result;
+         }
+
+         // Count colons to determine if it's a slice
+         size_t colon_count = 0;
+         for (char c : inside) {
+            if (c == ':') {
+               colon_count++;
+            }
+         }
+         result.colon_count = colon_count;
+
+         // Helper lambda to parse slice parts
+         auto parse_slice = [&](std::string_view inside) {
+            std::string_view parts[3];
+            {
+               size_t start_idx = 0;
+               int idx = 0;
+               for (size_t i = 0; i <= inside.size(); ++i) {
+                  if (i == inside.size() || inside[i] == ':') {
+                     if (idx < 3) {
+                        parts[idx] = inside.substr(start_idx, i - start_idx);
+                        idx++;
+                     }
+                     start_idx = i + 1;
+                  }
+               }
+            }
+
+            // Parse start
+            if (!parts[0].empty()) {
+               auto val = parse_int(parts[0]);
+               if (!val.has_value()) {
+                  result.error = true;
+               }
+               else {
+                  result.start = val;
+               }
+            }
+
+            // Parse end
+            if (!parts[1].empty()) {
+               auto val = parse_int(parts[1]);
+               if (!val.has_value()) {
+                  result.error = true;
+               }
+               else {
+                  result.end = val;
+               }
+            }
+
+            // Parse step
+            if (colon_count == 2 && !parts[2].empty()) {
+               auto val = parse_int(parts[2]);
+               if (!val.has_value()) {
+                  result.error = true;
+               }
+               else {
+                  result.step = val;
+               }
+            }
+         };
+
+         if (colon_count == 0) {
+            // single index
+            auto val = parse_int(inside);
+            if (!val.has_value()) {
+               result.error = true;
+            }
+            else {
+               result.start = val;
+            }
+         }
+         else if (colon_count == 1 || colon_count == 2) {
+            // slice
+            parse_slice(inside);
+         }
+         else {
+            // More than 2 colons is invalid
+            result.error = true;
+         }
+
+         return result;
+      }
+   }
+
+   namespace detail
+   {
+      template <auto Opts = opts{}, class T>
+         requires(Opts.format == JSON && not readable_array_t<T>)
+      inline void handle_slice(const jmespath::ArrayParseResult&, T&&, context& ctx, auto&&, auto&&)
+      {
+         ctx.error = error_code::syntax_error;
+      }
+
+      template <auto Opts = opts{}, class T>
+         requires(Opts.format == JSON && readable_array_t<T>)
+      inline void handle_slice(const jmespath::ArrayParseResult& decomposed_key, T&& value, context& ctx, auto&& it,
+                               auto&& end)
+      {
+         if (skip_ws<Opts>(ctx, it, end)) {
+            return;
+         }
+
+         // Determine slice parameters
+         int32_t step_idx = decomposed_key.step.value_or(1);
+         bool has_negative_index = (decomposed_key.start.value_or(0) < 0) || (decomposed_key.end.value_or(0) < 0);
+
+         // If we have negative indices or step != 1, fall back to the original method (read all then slice)
+         if (step_idx != 1 || has_negative_index) {
+            // Original fallback behavior:
+            // Read entire array into value first
+            value.clear();
+            if (*it == ']') {
+               // empty array
+               ++it; // consume ']'
+            }
+            else {
+               while (true) {
+                  parse<Opts.format>::template op<Opts>(value.emplace_back(), ctx, it, end);
+                  if (bool(ctx.error)) [[unlikely]]
+                     return;
+
+                  if (skip_ws<Opts>(ctx, it, end)) {
+                     return;
+                  }
+                  if (*it == ']') {
+                     ++it;
+                     break;
+                  }
+                  if (*it != ',') {
+                     ctx.error = error_code::parse_error;
+                     return;
+                  }
+                  ++it;
+                  if (skip_ws<Opts>(ctx, it, end)) {
+                     return;
+                  }
+               }
+            }
+
+            // Now do the slicing
+            const int32_t size = static_cast<int32_t>(value.size());
+            auto wrap_index = [&](int32_t idx) {
+               if (idx < 0) idx += size;
+               return std::clamp(idx, int32_t{0}, size);
+            };
+
+            const int32_t start_idx = wrap_index(decomposed_key.start.value_or(0));
+            const int32_t end_idx = wrap_index(decomposed_key.end.value_or(size));
+
+            if (step_idx == 1) {
+               if (start_idx < end_idx) {
+                  if (start_idx > 0) {
+                     value.erase(value.begin(), value.begin() + start_idx);
+                  }
+                  if (static_cast<size_t>(end_idx - start_idx) < value.size()) {
+                     value.erase(value.begin() + (end_idx - start_idx), value.end());
+                  }
+               }
+               else {
+                  value.clear();
+               }
+            }
+            else {
+               // For steps != 1 (or negative steps), the fallback path was already chosen.
+               // Just apply the same logic as before.
+               std::size_t dest = 0;
+               if (step_idx > 0) {
+                  for (int32_t i = start_idx; i < end_idx; i += step_idx) {
+                     value[dest++] = std::move(value[i]);
+                  }
+               }
+               else {
+                  for (int32_t i = start_idx; i > end_idx; i += step_idx) {
+                     value[dest++] = std::move(value[i]);
+                  }
+               }
+               value.resize(dest);
+            }
+
+            return;
+         }
+
+         // If we reach here, step == 1 and no negative indices, so we can do partial reading.
+         value.clear();
+         const int32_t start_idx = decomposed_key.start.value_or(0);
+         const int32_t end_idx = decomposed_key.end.value_or((std::numeric_limits<int32_t>::max)());
+
+         // If empty array
+         if (*it == ']') {
+            ++it; // consume ']'
+            return;
+         }
+
+         // We'll read elements and track their index
+         int32_t current_index = 0;
+         while (true) {
+            if (skip_ws<Opts>(ctx, it, end)) {
+               return;
+            }
+
+            // Decide whether we read or skip this element
+            if (current_index < start_idx) {
+               // Skip this element
+               skip_value<JSON>::op<Opts>(ctx, it, end);
+               if (bool(ctx.error)) [[unlikely]]
+                  return;
+            }
+            else if (current_index >= start_idx && current_index < end_idx) {
+               // Read this element into value
+               parse<Opts.format>::template op<Opts>(value.emplace_back(), ctx, it, end);
+               if (bool(ctx.error)) [[unlikely]]
+                  return;
+            }
+            else {
+               // current_index >= end_idx, we can skip reading into value
+               skip_value<JSON>::op<Opts>(ctx, it, end);
+               if (bool(ctx.error)) [[unlikely]]
+                  return;
+            }
+
+            if (skip_ws<Opts>(ctx, it, end)) {
+               return;
+            }
+            if (*it == ']') {
+               ++it; // finished reading array
+               break;
+            }
+            if (*it != ',') {
+               ctx.error = error_code::parse_error;
+               return;
+            }
+            ++it; // consume ','
+            if (skip_ws<Opts>(ctx, it, end)) {
+               return;
+            }
+
+            ++current_index;
+         }
+      }
+   }
+
+   // Read into a C++ type given a path denoted by a JMESPath query
+   template <string_literal Path, auto Options = opts{}, class T, contiguous Buffer>
+      requires(Options.format == JSON)
+   [[nodiscard]] inline error_ctx read_jmespath(T&& value, Buffer&& buffer)
+   {
+      static constexpr auto S = chars<Path>;
+      static constexpr auto tokens = jmespath::tokenize_as_array<S>();
+      static constexpr auto N = tokens.size();
+
+      constexpr bool use_padded = resizable<Buffer> && non_const_buffer<Buffer> && !check_disable_padding(Options);
+
+      static constexpr auto Opts = use_padded ? is_padded_on<Options>() : is_padded_off<Options>();
+
+      if constexpr (use_padded) {
+         // Pad the buffer for SWAR
+         buffer.resize(buffer.size() + padding_bytes);
+      }
+      auto p = read_iterators<Opts>(buffer);
+      auto it = p.first;
+      auto end = p.second;
+      auto start = it;
+
+      context ctx{};
+
+      if constexpr (N == 0) {
+         parse<Opts.format>::template op<Opts>(value, ctx, it, end);
+      }
+      else {
+         using namespace glz::detail;
+
+         skip_ws<Opts>(ctx, it, end);
+
+         for_each<N>([&]<auto I>() {
+            if (bool(ctx.error)) [[unlikely]] {
+               return;
+            }
+
+            static constexpr auto decomposed_key = jmespath::parse_jmespath_token(tokens[I]);
+            static constexpr auto key = decomposed_key.key;
+
+            if constexpr (decomposed_key.is_array_access) {
+               // If we have a key, that means we're looking into an object like: key[0:5]
+               if constexpr (key.empty()) {
+                  if (skip_ws<Opts>(ctx, it, end)) {
+                     return;
+                  }
+                  // We expect the JSON at this level to be an array
+                  if (match_invalid_end<'[', Opts>(ctx, it, end)) {
+                     return;
+                  }
+
+                  // If this is a slice (colon_count > 0)
+                  if constexpr (decomposed_key.colon_count > 0) {
+                     detail::handle_slice<Opts>(decomposed_key, value, ctx, it, end);
+                  }
+                  else {
+                     // SINGLE INDEX SCENARIO (no slice, just an index)
+                     if constexpr (decomposed_key.start.has_value()) {
+                        constexpr auto n = decomposed_key.start.value();
+
+                        if constexpr (I == (N - 1)) {
+                           // Skip until we reach the target element n
+                           for (int32_t i = 0; i < n; ++i) {
+                              skip_value<JSON>::op<Opts>(ctx, it, end);
+                              if (bool(ctx.error)) [[unlikely]]
+                                 return;
+
+                              if (*it != ',') {
+                                 ctx.error = error_code::array_element_not_found;
+                                 return;
+                              }
+                              ++it;
+                              if (skip_ws<Opts>(ctx, it, end)) {
+                                 return;
+                              }
+                           }
+
+                           // Now read the element at index n
+                           parse<Opts.format>::template op<Opts>(value, ctx, it, end);
+                        }
+                        else {
+                           // Not the last token. We must still parse the element at index n so the next indexing can
+                           // proceed.
+                           for (int32_t i = 0; i < n; ++i) {
+                              skip_value<JSON>::op<Opts>(ctx, it, end);
+                              if (bool(ctx.error)) [[unlikely]]
+                                 return;
+
+                              if (*it != ',') {
+                                 ctx.error = error_code::array_element_not_found;
+                                 return;
+                              }
+                              ++it;
+                              if (skip_ws<Opts>(ctx, it, end)) {
+                                 return;
+                              }
+                           }
+                        }
+                     }
+                     else {
+                        ctx.error = error_code::array_element_not_found;
+                        return;
+                     }
+                  }
+
+                  // After handling the array access, we're done for this token
+                  return;
+               }
+               else {
+                  // Object scenario with a key, like: key[0:5]
+                  if (match_invalid_end<'{', Opts>(ctx, it, end)) {
+                     return;
+                  }
+
+                  while (true) {
+                     if (skip_ws<Opts>(ctx, it, end)) {
+                        return;
+                     }
+                     if (match<'"'>(ctx, it)) {
+                        return;
+                     }
+
+                     auto* start = it;
+                     skip_string_view<Opts>(ctx, it, end);
+                     if (bool(ctx.error)) [[unlikely]]
+                        return;
+                     const sv k = {start, size_t(it - start)};
+                     ++it;
+
+                     if (key.size() == k.size() && comparitor<key>(k.data())) {
+                        if (skip_ws<Opts>(ctx, it, end)) {
+                           return;
+                        }
+                        if (match_invalid_end<':', Opts>(ctx, it, end)) {
+                           return;
+                        }
+                        if (skip_ws<Opts>(ctx, it, end)) {
+                           return;
+                        }
+                        if (match_invalid_end<'[', Opts>(ctx, it, end)) {
+                           return;
+                        }
+
+                        // Distinguish single index vs slice using colon_count
+                        if constexpr (decomposed_key.colon_count > 0) {
+                           detail::handle_slice<Opts, decomposed_key>(value, ctx, it, end);
+                        }
+                        else {
+                           // SINGLE INDEX SCENARIO (colon_count == 0)
+                           if constexpr (decomposed_key.start.has_value()) {
+                              // Skip until we reach the target element
+                              constexpr auto n = decomposed_key.start.value();
+                              for (int32_t i = 0; i < n; ++i) {
+                                 skip_value<JSON>::op<Opts>(ctx, it, end);
+                                 if (bool(ctx.error)) [[unlikely]]
+                                    return;
+
+                                 if (*it != ',') {
+                                    ctx.error = error_code::array_element_not_found;
+                                    return;
+                                 }
+                                 ++it;
+                                 if (skip_ws<Opts>(ctx, it, end)) {
+                                    return;
+                                 }
+                              }
+
+                              if (skip_ws<Opts>(ctx, it, end)) {
+                                 return;
+                              }
+
+                              if constexpr (I == (N - 1)) {
+                                 parse<Opts.format>::template op<Opts>(value, ctx, it, end);
+                              }
+                              return;
+                           }
+                           else {
+                              ctx.error = error_code::array_element_not_found;
+                              return;
+                           }
+                        }
+                     }
+                     else {
+                        skip_value<JSON>::op<Opts>(ctx, it, end);
+                        if (bool(ctx.error)) [[unlikely]] {
+                           return;
+                        }
+                        if (*it != ',') {
+                           ctx.error = error_code::key_not_found;
+                           return;
+                        }
+                        ++it;
+                     }
+                  }
+               }
+            }
+            else {
+               // If it's not array access, we are dealing with an object key
+               if (match_invalid_end<'{', Opts>(ctx, it, end)) {
+                  return;
+               }
+
+               while (it < end) {
+                  if (skip_ws<Opts>(ctx, it, end)) {
+                     return;
+                  }
+                  if (match<'"'>(ctx, it)) {
+                     return;
+                  }
+
+                  auto* start = it;
+                  skip_string_view<Opts>(ctx, it, end);
+                  if (bool(ctx.error)) [[unlikely]]
+                     return;
+                  const sv k = {start, size_t(it - start)};
+                  ++it;
+
+                  if (key.size() == k.size() && comparitor<key>(k.data())) {
+                     if (skip_ws<Opts>(ctx, it, end)) {
+                        return;
+                     }
+                     if (match_invalid_end<':', Opts>(ctx, it, end)) {
+                        return;
+                     }
+                     if (skip_ws<Opts>(ctx, it, end)) {
+                        return;
+                     }
+
+                     if constexpr (I == (N - 1)) {
+                        parse<Opts.format>::template op<Opts>(value, ctx, it, end);
+                     }
+                     return;
+                  }
+                  else {
+                     skip_value<JSON>::op<Opts>(ctx, it, end);
+                     if (bool(ctx.error)) [[unlikely]] {
+                        return;
+                     }
+                     if (*it != ',') {
+                        ctx.error = error_code::key_not_found;
+                        return;
+                     }
+                     ++it;
+                  }
+               }
+            }
+         });
+      }
+
+      if constexpr (use_padded) {
+         // Restore the original buffer state
+         buffer.resize(buffer.size() - padding_bytes);
+      }
+
+      return {ctx.error, ctx.custom_error_message, size_t(it - start), ctx.includer_error};
+   }
+
+   // A "compiled" jmespath expression, which can be pre-computed for efficient traversal
+   struct jmespath_expression
+   {
+      std::string_view path{};
+      jmespath::tokenization_error error{};
+      std::vector<std::string_view> tokens{}; // evaluated tokens
+
+      jmespath_expression(const std::string_view input_path) noexcept : path(input_path)
+      {
+         error = jmespath::tokenize_full_jmespath(path, tokens);
+      }
+
+      template <size_t N>
+      jmespath_expression(const char (&input_path)[N]) noexcept : path(input_path)
+      {
+         error = jmespath::tokenize_full_jmespath(path, tokens);
+      }
+      jmespath_expression(const jmespath_expression&) noexcept = default;
+      jmespath_expression(jmespath_expression&&) noexcept = default;
+      jmespath_expression& operator=(const jmespath_expression&) noexcept = default;
+      jmespath_expression& operator=(jmespath_expression&&) noexcept = default;
+   };
+
+   // Read into a C++ type given a path denoted by a JMESPath query
+   // This version supports a runtime path
+   template <auto Options = opts{}, class T, contiguous Buffer>
+      requires(Options.format == JSON)
+   [[nodiscard]] inline error_ctx read_jmespath(const jmespath_expression& expression, T&& value, Buffer&& buffer)
+   {
+      if (bool(expression.error)) {
+         return {error_code::syntax_error, "JMESPath invalid expression"};
+      }
+
+      const auto& tokens = expression.tokens;
+      const auto N = tokens.size();
+
+      constexpr bool use_padded = resizable<Buffer> && non_const_buffer<Buffer> && !check_disable_padding(Options);
+      static constexpr auto Opts = use_padded ? is_padded_on<Options>() : is_padded_off<Options>();
+
+      if constexpr (use_padded) {
+         // Pad the buffer for SWAR
+         buffer.resize(buffer.size() + padding_bytes);
+      }
+      auto p = read_iterators<Opts>(buffer);
+      auto it = p.first;
+      auto end = p.second;
+      auto start = it;
+
+      context ctx{};
+
+      if (N == 0) {
+         parse<Opts.format>::template op<Opts>(value, ctx, it, end);
+      }
+      else {
+         using namespace glz::detail;
+
+         skip_ws<Opts>(ctx, it, end);
+
+         for (size_t I = 0; I < N; ++I) {
+            if (bool(ctx.error)) [[unlikely]] {
+               break;
+            }
+
+            [&] {
+               const auto decomposed_key = jmespath::parse_jmespath_token(tokens[I]);
+               const auto& key = decomposed_key.key;
+
+               if (decomposed_key.is_array_access) {
+                  if (key.empty()) {
+                     // Top-level array scenario
+                     if (skip_ws<Opts>(ctx, it, end)) {
+                        return;
+                     }
+                     if (match_invalid_end<'[', Opts>(ctx, it, end)) {
+                        return;
+                     }
+
+                     if (decomposed_key.colon_count > 0) {
+                        // Slice scenario
+                        detail::handle_slice(decomposed_key, value, ctx, it, end);
+                        return;
+                     }
+                     else {
+                        // Single index scenario
+                        if (decomposed_key.start.has_value()) {
+                           const int32_t n = decomposed_key.start.value();
+
+                           if (I == (N - 1)) {
+                              // Skip until we reach the target element n
+                              for (int32_t i = 0; i < n; ++i) {
+                                 skip_value<JSON>::op<Opts>(ctx, it, end);
+                                 if (bool(ctx.error)) [[unlikely]]
+                                    return;
+
+                                 if (*it != ',') {
+                                    ctx.error = error_code::array_element_not_found;
+                                    return;
+                                 }
+                                 ++it;
+                                 if (skip_ws<Opts>(ctx, it, end)) {
+                                    return;
+                                 }
+                              }
+
+                              // Now read the element at index n
+                              parse<Opts.format>::template op<Opts>(value, ctx, it, end);
+                           }
+                           else {
+                              // Not the last token. We must still parse the element at index n so the next indexing can
+                              // proceed.
+                              for (int32_t i = 0; i < n; ++i) {
+                                 skip_value<JSON>::op<Opts>(ctx, it, end);
+                                 if (bool(ctx.error)) [[unlikely]]
+                                    return;
+
+                                 if (*it != ',') {
+                                    ctx.error = error_code::array_element_not_found;
+                                    return;
+                                 }
+                                 ++it;
+                                 if (skip_ws<Opts>(ctx, it, end)) {
+                                    return;
+                                 }
+                              }
+                           }
+                        }
+                        else {
+                           ctx.error = error_code::array_element_not_found;
+                           return;
+                        }
+                        return;
+                     }
+                  }
+                  else {
+                     // Object scenario: key[...]
+                     if (match_invalid_end<'{', Opts>(ctx, it, end)) {
+                        return;
+                     }
+
+                     while (true) {
+                        if (skip_ws<Opts>(ctx, it, end)) {
+                           return;
+                        }
+                        if (match<'"'>(ctx, it)) {
+                           return;
+                        }
+
+                        auto* start_pos = it;
+                        skip_string_view<Opts>(ctx, it, end);
+                        if (bool(ctx.error)) [[unlikely]]
+                           return;
+                        const sv k = {start_pos, size_t(it - start_pos)};
+                        ++it;
+
+                        if (key.size() == k.size() && memcmp(key.data(), k.data(), key.size()) == 0) {
+                           if (skip_ws<Opts>(ctx, it, end)) {
+                              return;
+                           }
+                           if (match_invalid_end<':', Opts>(ctx, it, end)) {
+                              return;
+                           }
+                           if (skip_ws<Opts>(ctx, it, end)) {
+                              return;
+                           }
+                           if (match_invalid_end<'[', Opts>(ctx, it, end)) {
+                              return;
+                           }
+
+                           if (decomposed_key.colon_count > 0) {
+                              // Slice scenario
+                              detail::handle_slice(decomposed_key, value, ctx, it, end);
+                              return;
+                           }
+                           else {
+                              // Single index scenario
+                              if (decomposed_key.start.has_value()) {
+                                 int32_t n = decomposed_key.start.value();
+                                 for (int32_t i = 0; i < n; ++i) {
+                                    skip_value<JSON>::op<Opts>(ctx, it, end);
+                                    if (bool(ctx.error)) [[unlikely]]
+                                       return;
+
+                                    if (*it != ',') {
+                                       ctx.error = error_code::array_element_not_found;
+                                       return;
+                                    }
+                                    ++it;
+                                    if (skip_ws<Opts>(ctx, it, end)) {
+                                       return;
+                                    }
+                                 }
+
+                                 if (skip_ws<Opts>(ctx, it, end)) {
+                                    return;
+                                 }
+
+                                 if (I == (N - 1)) {
+                                    parse<Opts.format>::template op<Opts>(value, ctx, it, end);
+                                 }
+                                 return;
+                              }
+                              else {
+                                 ctx.error = error_code::array_element_not_found;
+                                 return;
+                              }
+                           }
+                        }
+                        else {
+                           skip_value<JSON>::op<Opts>(ctx, it, end);
+                           if (bool(ctx.error)) [[unlikely]] {
+                              return;
+                           }
+                           if (*it != ',') {
+                              ctx.error = error_code::key_not_found;
+                              return;
+                           }
+                           ++it;
+                        }
+                     }
+                  }
+               }
+               else {
+                  // Non-array access: key-only navigation
+                  if (match_invalid_end<'{', Opts>(ctx, it, end)) {
+                     return;
+                  }
+
+                  while (it < end) {
+                     if (skip_ws<Opts>(ctx, it, end)) {
+                        return;
+                     }
+                     if (match<'"'>(ctx, it)) {
+                        return;
+                     }
+
+                     auto* start_pos = it;
+                     skip_string_view<Opts>(ctx, it, end);
+                     if (bool(ctx.error)) [[unlikely]]
+                        return;
+                     const sv k = {start_pos, size_t(it - start_pos)};
+                     ++it;
+
+                     if (key.size() == k.size() && memcmp(key.data(), k.data(), key.size()) == 0) {
+                        if (skip_ws<Opts>(ctx, it, end)) {
+                           return;
+                        }
+                        if (match_invalid_end<':', Opts>(ctx, it, end)) {
+                           return;
+                        }
+                        if (skip_ws<Opts>(ctx, it, end)) {
+                           return;
+                        }
+
+                        if (I == (N - 1)) {
+                           parse<Opts.format>::template op<Opts>(value, ctx, it, end);
+                        }
+                        return;
+                     }
+                     else {
+                        skip_value<JSON>::op<Opts>(ctx, it, end);
+                        if (bool(ctx.error)) [[unlikely]] {
+                           return;
+                        }
+                        if (*it != ',') {
+                           ctx.error = error_code::key_not_found;
+                           return;
+                        }
+                        ++it;
+                     }
+                  }
+               }
+            }();
+         }
+      }
+
+      if constexpr (use_padded) {
+         // Restore the original buffer state
+         buffer.resize(buffer.size() - padding_bytes);
+      }
+
+      return {ctx.error, ctx.custom_error_message, size_t(it - start), ctx.includer_error};
+   }
+
+}
diff --git a/deps/saucer/include/glaze/json/json_concepts.hpp b/deps/saucer/include/glaze/json/json_concepts.hpp
new file mode 100644
index 0000000..454420e
--- /dev/null
+++ b/deps/saucer/include/glaze/json/json_concepts.hpp
@@ -0,0 +1,30 @@
+// Glaze Library
+// For the license information refer to glaze.hpp
+
+#pragma once
+
+#include "glaze/core/common.hpp"
+
+namespace glz
+{
+   template <class T>
+   concept json_object = glaze_object_t<T> || reflectable<T> || writable_map_t<T> || readable_map_t<T>;
+
+   template <class T>
+   concept json_array = array_t<T>;
+
+   template <class T>
+   concept json_string = str_t<T>;
+
+   template <class T>
+   concept json_boolean = boolean_like<T>;
+
+   template <class T>
+   concept json_number = num_t<T>;
+
+   template <class T>
+   concept json_integer = int_t<T>;
+
+   template <class T>
+   concept json_null = null_t<T>;
+}
diff --git a/deps/saucer/include/glaze/json/json_format.hpp b/deps/saucer/include/glaze/json/json_format.hpp
index d6b5655..13a3656 100644
--- a/deps/saucer/include/glaze/json/json_format.hpp
+++ b/deps/saucer/include/glaze/json/json_format.hpp
@@ -25,7 +25,7 @@ namespace glz::detail
       Comment = '/'
    };
 
-   constexpr std::array<json_type, 256> json_types = [] {
+   inline constexpr std::array<json_type, 256> json_types = [] {
       std::array<json_type, 256> t{};
       using enum json_type;
       t['"'] = String;
@@ -65,8 +65,8 @@ namespace glz::detail
       }
    };
 
-   template <opts Opts>
-      requires(Opts.is_padded)
+   template <auto Opts>
+      requires(check_is_padded(Opts))
    sv read_json_string(auto&& it, auto&& end) noexcept
    {
       auto start = it;
@@ -96,8 +96,8 @@ namespace glz::detail
       return {};
    }
 
-   template <opts Opts>
-      requires(!Opts.is_padded)
+   template <auto Opts>
+      requires(!check_is_padded(Opts))
    sv read_json_string(auto&& it, auto&& end) noexcept
    {
       auto start = it;
@@ -178,11 +178,19 @@ namespace glz::detail
       return {};
    }
 
-   inline sv read_json_number(auto&& it) noexcept
+   template <bool null_terminated>
+   GLZ_ALWAYS_INLINE sv read_json_number(auto&& it, auto&& end) noexcept
    {
       auto start = it;
-      while (numeric_table[*it]) {
-         ++it;
+      if constexpr (null_terminated) {
+         while (numeric_table[uint8_t(*it)]) {
+            ++it;
+         }
+      }
+      else {
+         while ((it < end) && numeric_table[uint8_t(*it)]) {
+            ++it;
+         }
       }
       return {start, size_t(it - start)};
    }
diff --git a/deps/saucer/include/glaze/json/json_ptr.hpp b/deps/saucer/include/glaze/json/json_ptr.hpp
index a78af5d..60b2b49 100644
--- a/deps/saucer/include/glaze/json/json_ptr.hpp
+++ b/deps/saucer/include/glaze/json/json_ptr.hpp
@@ -20,28 +20,33 @@ namespace glz
       return key.find_first_not_of("0123456789") == std::string_view::npos;
    }
 
-   template <string_literal Str, auto Opts = opts{}>
+   template <string_literal JsonPointer, auto Opts = opts{}>
    [[nodiscard]] inline auto get_view_json(contiguous auto&& buffer)
    {
-      static constexpr auto s = chars<Str>;
-
-      static constexpr auto tokens = split_json_ptr<s>();
+      static constexpr auto S = chars<JsonPointer>;
+      static constexpr auto tokens = split_json_ptr<S>();
       static constexpr auto N = tokens.size();
 
       context ctx{};
-      auto p = read_iterators<Opts>(ctx, buffer);
+      auto p = read_iterators<Opts>(buffer);
 
       auto it = p.first;
       auto end = p.second;
 
-      // using span_t = std::span<std::remove_pointer_t<std::remove_reference_t<decltype(it)>>>;
-      using span_t = std::span<const char>; // TODO: should be more generic, but currently broken with mingw
+      // Don't automatically const qualify the buffer so we can write to the view,
+      // which allows us to write to a JSON Pointer location
+      using span_t =
+         std::span<std::conditional_t<std::is_const_v<std::remove_pointer_t<decltype(it)>>, const char, char>>;
       using result_t = expected<span_t, error_ctx>;
 
       auto start = it;
 
+      if (buffer.empty()) [[unlikely]] {
+         ctx.error = error_code::no_read_input;
+      }
+
       if (bool(ctx.error)) [[unlikely]] {
-         return result_t{unexpected(error_ctx{ctx.error, 0})};
+         return result_t{unexpected(error_ctx{ctx.error})};
       }
 
       if constexpr (N == 0) {
@@ -54,26 +59,41 @@ namespace glz
 
          result_t ret;
 
-         for_each<N>([&](auto I) {
+         for_each<N>([&]<size_t I>() {
             if (bool(ctx.error)) [[unlikely]] {
                return;
             }
 
-            static constexpr auto key = std::get<I>(tokens);
+            static constexpr auto key = tokens[I];
             if constexpr (maybe_numeric_key(key)) {
                switch (*it) {
                case '{': {
                   ++it;
                   while (true) {
-                     GLZ_SKIP_WS;
-                     const auto k = parse_key(ctx, it, end);
-                     if (bool(ctx.error)) [[unlikely]] {
+                     if (skip_ws<Opts>(ctx, it, end)) {
                         return;
                      }
-                     if (cx_string_cmp<key>(k)) {
-                        GLZ_SKIP_WS;
-                        GLZ_MATCH_COLON;
-                        GLZ_SKIP_WS;
+                     if (match<'"'>(ctx, it)) {
+                        return;
+                     }
+
+                     auto* start = it;
+                     skip_string_view<Opts>(ctx, it, end);
+                     if (bool(ctx.error)) [[unlikely]]
+                        return;
+                     const sv k = {start, size_t(it - start)};
+                     ++it;
+
+                     if (key.size() == k.size() && comparitor<key>(k.data())) {
+                        if (skip_ws<Opts>(ctx, it, end)) {
+                           return;
+                        }
+                        if (match_invalid_end<':', Opts>(ctx, it, end)) {
+                           return;
+                        }
+                        if (skip_ws<Opts>(ctx, it, end)) {
+                           return;
+                        }
 
                         if constexpr (I == (N - 1)) {
                            ret = parse_value<Opts>(ctx, it, end);
@@ -81,7 +101,7 @@ namespace glz
                         return;
                      }
                      else {
-                        skip_value<Opts>(ctx, it, end);
+                        skip_value<JSON>::op<Opts>(ctx, it, end);
                         if (bool(ctx.error)) [[unlikely]] {
                            return;
                         }
@@ -98,8 +118,8 @@ namespace glz
                   // Could optimize by counting commas
                   static constexpr auto n = stoui(key);
                   if constexpr (n) {
-                     for_each<n.value()>([&](auto) {
-                        skip_value<Opts>(ctx, it, end);
+                     for_each<n.value()>([&]<size_t>() {
+                        skip_value<JSON>::op<Opts>(ctx, it, end);
                         if (bool(ctx.error)) [[unlikely]] {
                            return;
                         }
@@ -110,7 +130,9 @@ namespace glz
                         ++it;
                      });
 
-                     GLZ_SKIP_WS;
+                     if (skip_ws<Opts>(ctx, it, end)) {
+                        return;
+                     }
 
                      if constexpr (I == (N - 1)) {
                         ret = parse_value<Opts>(ctx, it, end);
@@ -125,19 +147,35 @@ namespace glz
                }
             }
             else {
-               GLZ_MATCH_OPEN_BRACE;
+               if (match_invalid_end<'{', Opts>(ctx, it, end)) {
+                  return;
+               }
 
                while (it < end) {
-                  GLZ_SKIP_WS;
-                  const auto k = parse_key(ctx, it, end);
-                  if (bool(ctx.error)) [[unlikely]] {
+                  if (skip_ws<Opts>(ctx, it, end)) {
+                     return;
+                  }
+                  if (match<'"'>(ctx, it)) {
                      return;
                   }
 
-                  if (cx_string_cmp<key>(k)) {
-                     GLZ_SKIP_WS;
-                     GLZ_MATCH_COLON;
-                     GLZ_SKIP_WS;
+                  auto* start = it;
+                  skip_string_view<Opts>(ctx, it, end);
+                  if (bool(ctx.error)) [[unlikely]]
+                     return;
+                  const sv k = {start, size_t(it - start)};
+                  ++it;
+
+                  if (key.size() == k.size() && comparitor<key>(k.data())) {
+                     if (skip_ws<Opts>(ctx, it, end)) {
+                        return;
+                     }
+                     if (match_invalid_end<':', Opts>(ctx, it, end)) {
+                        return;
+                     }
+                     if (skip_ws<Opts>(ctx, it, end)) {
+                        return;
+                     }
 
                      if constexpr (I == (N - 1)) {
                         ret = parse_value<Opts>(ctx, it, end);
@@ -145,7 +183,7 @@ namespace glz
                      return;
                   }
                   else {
-                     skip_value<Opts>(ctx, it, end);
+                     skip_value<JSON>::op<Opts>(ctx, it, end);
                      if (bool(ctx.error)) [[unlikely]] {
                         return;
                      }
@@ -160,7 +198,7 @@ namespace glz
          });
 
          if (bool(ctx.error)) [[unlikely]] {
-            return result_t{unexpected(error_ctx{ctx.error, size_t(it - start)})};
+            return result_t{unexpected(error_ctx{ctx.error, "", size_t(it - start)})};
          }
 
          return ret;
@@ -186,4 +224,22 @@ namespace glz
       }
       return unexpected(s.error());
    }
+
+   // Write raw text to a JSON value denoted by a JSON Pointer
+   template <string_literal Path, auto Opts = opts{}>
+   [[nodiscard]] inline error_ctx write_at(const std::string_view value, contiguous auto&& buffer)
+   {
+      auto view = glz::get_view_json<Path, Opts>(buffer);
+      if (view) {
+         // erase the current value
+         const size_t location = size_t(view->data() - buffer.data());
+         buffer.erase(location, view->size());
+         // insert the new value
+         buffer.insert(location, value);
+         return {};
+      }
+      else {
+         return view.error();
+      }
+   }
 }
diff --git a/deps/saucer/include/glaze/json/json_t.hpp b/deps/saucer/include/glaze/json/json_t.hpp
index 088d7ad..7ef2eeb 100644
--- a/deps/saucer/include/glaze/json/json_t.hpp
+++ b/deps/saucer/include/glaze/json/json_t.hpp
@@ -3,12 +3,37 @@
 
 #pragma once
 
+#ifndef GLZ_THROW_OR_ABORT
+#if __cpp_exceptions
+#define GLZ_THROW_OR_ABORT(EXC) (throw(EXC))
+#define GLZ_NOEXCEPT noexcept(false)
+#else
+#define GLZ_THROW_OR_ABORT(EXC) (std::abort())
+#define GLZ_NOEXCEPT noexcept(true)
+#endif
+#endif
+
+#if __cpp_exceptions
+#include <stdexcept>
+#endif
+
+namespace glz
+{
+   inline void glaze_error([[maybe_unused]] const char* msg) GLZ_NOEXCEPT
+   {
+      GLZ_THROW_OR_ABORT(std::runtime_error(msg));
+   }
+}
+
 #include <cstddef>
 #include <map>
 #include <variant>
 #include <vector>
 
-#include "glaze/core/meta.hpp"
+#include "glaze/api/std/string.hpp"
+#include "glaze/api/std/variant.hpp"
+#include "glaze/json/read.hpp"
+#include "glaze/json/write.hpp"
 #include "glaze/util/expected.hpp"
 
 #ifdef _MSC_VER
@@ -22,12 +47,25 @@ namespace glz
    // Generic json type.
    struct json_t
    {
+      virtual ~json_t() {}
+
       using array_t = std::vector<json_t>;
       using object_t = std::map<std::string, json_t, std::less<>>;
       using null_t = std::nullptr_t;
       using val_t = std::variant<null_t, double, std::string, bool, array_t, object_t>;
       val_t data{};
 
+      /**
+       * @brief Converts the JSON data to a string representation.
+       * @return An `expected` containing a JSON string if successful, or an error context.
+       */
+      expected<std::string, error_ctx> dump() const { return write_json(data); }
+
+      /**
+       * @brief Gets the value as the specified type.
+       * @tparam T The type to get the value as.
+       * @return Reference to the value of the specified type.
+       */
       template <class T>
       [[nodiscard]] T& get()
       {
@@ -52,6 +90,29 @@ namespace glz
          return std::get_if<T>(&data);
       }
 
+      template <class T>
+      [[nodiscard]] T as() const
+      {
+         // Prefer get becuase it returns a reference
+         return get<T>();
+      }
+
+      template <class T>
+         requires(requires { static_cast<T>(std::declval<double>()); })
+      [[nodiscard]] T as() const
+      {
+         // Can be used for int and the like
+         return static_cast<T>(get<double>());
+      }
+
+      template <class T>
+         requires std::convertible_to<std::string, T>
+      [[nodiscard]] T as() const
+      {
+         // Can be used for string_view and the like
+         return get<std::string>();
+      }
+
       template <class T>
       [[nodiscard]] bool holds() const noexcept
       {
@@ -85,6 +146,62 @@ namespace glz
          return iter->second;
       }
 
+      json_t& operator=(const std::nullptr_t value)
+      {
+         data = value;
+         return *this;
+      }
+
+      json_t& operator=(const double value)
+      {
+         data = value;
+         return *this;
+      }
+
+      // for integers
+      template <int_t T>
+      json_t& operator=(const T value)
+      {
+         data = static_cast<double>(value);
+         return *this;
+      }
+
+      json_t& operator=(const std::string& value)
+      {
+         data = value;
+         return *this;
+      }
+
+      json_t& operator=(const std::string_view value)
+      {
+         data = std::string(value);
+         return *this;
+      }
+
+      json_t& operator=(const char* value)
+      {
+         data = std::string(value);
+         return *this;
+      }
+
+      json_t& operator=(const bool value)
+      {
+         data = value;
+         return *this;
+      }
+
+      json_t& operator=(const array_t& value)
+      {
+         data = value;
+         return *this;
+      }
+
+      json_t& operator=(const object_t& value)
+      {
+         data = value;
+         return *this;
+      }
+
       [[nodiscard]] json_t& at(std::convertible_to<std::string_view> auto&& key) { return operator[](key); }
 
       [[nodiscard]] const json_t& at(std::convertible_to<std::string_view> auto&& key) const { return operator[](key); }
@@ -114,32 +231,29 @@ namespace glz
       json_t& operator=(json_t&&) = default;
 
       template <class T>
-         requires std::convertible_to<T, val_t> && (!std::same_as<json_t, std::decay_t<T>>)
+         requires std::convertible_to<T, val_t> && (!std::derived_from<std::decay_t<T>, json_t>)
       json_t(T&& val)
       {
          data = val;
       }
 
       template <class T>
-         requires std::convertible_to<T, double> && (!std::same_as<json_t, std::decay_t<T>>) &&
+         requires std::convertible_to<T, double> && (!std::derived_from<std::decay_t<T>, json_t>) &&
                   (!std::convertible_to<T, val_t>)
       json_t(T&& val)
       {
          data = static_cast<double>(val);
       }
 
+      json_t(const std::string_view value) { data = std::string(value); }
+
       json_t(std::initializer_list<std::pair<const char*, json_t>>&& obj)
       {
-         // TODO try to see if there is a beter way to do this initialization withought copying the json_t
-         // std::string in std::initializer_list<std::pair<const std::string, json_t>> would match with {"literal",
-         // "other_literal"} So we cant use std::string or std::string view. Luckily const char * will not match with
-         // {"literal", "other_literal"} but then we have to copy the data from the initializer list data =
-         // object_t(obj); // This is what we would use if std::initializer_list<std::pair<const std::string, json_t>>
-         // worked
          data.emplace<object_t>();
          auto& data_obj = std::get<object_t>(data);
          for (auto&& pair : obj) {
-            data_obj.emplace(pair.first, std::move(pair.second));
+            // std::initializer_list holds const values that cannot be moved
+            data_obj.emplace(pair.first, pair.second);
          }
       }
 
@@ -150,29 +264,6 @@ namespace glz
          data.emplace<array_t>(std::move(arr));
       }
 
-      template <class T>
-      [[nodiscard]] T as() const
-      {
-         // Prefer get becuase it returns a reference
-         return get<T>();
-      }
-
-      template <class T>
-         requires std::convertible_to<double, T>
-      [[nodiscard]] T as() const
-      {
-         // Can be used for int and the like
-         return static_cast<T>(get<double>());
-      }
-
-      template <class T>
-         requires std::convertible_to<std::string, T>
-      [[nodiscard]] T as() const
-      {
-         // Can be used for string_view and the like
-         return get<std::string>();
-      }
-
       [[nodiscard]] bool is_array() const noexcept { return holds<json_t::array_t>(); }
 
       [[nodiscard]] bool is_object() const noexcept { return holds<json_t::object_t>(); }
@@ -185,20 +276,20 @@ namespace glz
 
       [[nodiscard]] bool is_null() const noexcept { return holds<std::nullptr_t>(); }
 
-      [[nodiscard]] array_t& get_array() noexcept { return get<array_t>(); }
-      [[nodiscard]] const array_t& get_array() const noexcept { return get<array_t>(); }
+      [[nodiscard]] array_t& get_array() { return get<array_t>(); }
+      [[nodiscard]] const array_t& get_array() const { return get<array_t>(); }
 
-      [[nodiscard]] object_t& get_object() noexcept { return get<object_t>(); }
-      [[nodiscard]] const object_t& get_object() const noexcept { return get<object_t>(); }
+      [[nodiscard]] object_t& get_object() { return get<object_t>(); }
+      [[nodiscard]] const object_t& get_object() const { return get<object_t>(); }
 
-      [[nodiscard]] double& get_number() noexcept { return get<double>(); }
-      [[nodiscard]] const double& get_number() const noexcept { return get<double>(); }
+      [[nodiscard]] double& get_number() { return get<double>(); }
+      [[nodiscard]] const double& get_number() const { return get<double>(); }
 
-      [[nodiscard]] std::string& get_string() noexcept { return get<std::string>(); }
-      [[nodiscard]] const std::string& get_string() const noexcept { return get<std::string>(); }
+      [[nodiscard]] std::string& get_string() { return get<std::string>(); }
+      [[nodiscard]] const std::string& get_string() const { return get<std::string>(); }
 
-      [[nodiscard]] bool& get_boolean() noexcept { return get<bool>(); }
-      [[nodiscard]] const bool& get_boolean() const noexcept { return get<bool>(); }
+      [[nodiscard]] bool& get_boolean() { return get<bool>(); }
+      [[nodiscard]] const bool& get_boolean() const { return get<bool>(); }
 
       // empty() returns true if the value is an empty JSON object, array, or string, or a null value
       // otherwise returns false
@@ -239,17 +330,17 @@ namespace glz
       }
    };
 
-   [[nodiscard]] inline bool is_array(const json_t& value) { return value.is_array(); }
+   [[nodiscard]] inline bool is_array(const json_t& value) noexcept { return value.is_array(); }
 
-   [[nodiscard]] inline bool is_object(const json_t& value) { return value.is_object(); }
+   [[nodiscard]] inline bool is_object(const json_t& value) noexcept { return value.is_object(); }
 
-   [[nodiscard]] inline bool is_number(const json_t& value) { return value.is_number(); }
+   [[nodiscard]] inline bool is_number(const json_t& value) noexcept { return value.is_number(); }
 
-   [[nodiscard]] inline bool is_string(const json_t& value) { return value.is_string(); }
+   [[nodiscard]] inline bool is_string(const json_t& value) noexcept { return value.is_string(); }
 
-   [[nodiscard]] inline bool is_boolean(const json_t& value) { return value.is_boolean(); }
+   [[nodiscard]] inline bool is_boolean(const json_t& value) noexcept { return value.is_boolean(); }
 
-   [[nodiscard]] inline bool is_null(const json_t& value) { return value.is_null(); }
+   [[nodiscard]] inline bool is_null(const json_t& value) noexcept { return value.is_null(); }
 }
 
 template <>
@@ -260,7 +351,119 @@ struct glz::meta<glz::json_t>
    static constexpr auto value = &T::data;
 };
 
+namespace glz
+{
+   // These functions allow a json_t value to be read/written to a C++ struct
+
+   template <auto Opts, class T>
+      requires read_supported<T, Opts.format>
+   [[nodiscard]] error_ctx read(T& value, const json_t& source)
+   {
+      auto buffer = source.dump();
+      if (buffer) {
+         context ctx{};
+         return read<Opts>(value, *buffer, ctx);
+      }
+      else {
+         return buffer.error();
+      }
+   }
+
+   template <read_supported<JSON> T>
+   [[nodiscard]] error_ctx read_json(T& value, const json_t& source)
+   {
+      auto buffer = source.dump();
+      if (buffer) {
+         return read_json(value, *buffer);
+      }
+      else {
+         return buffer.error();
+      }
+   }
+
+   template <read_supported<JSON> T>
+   [[nodiscard]] expected<T, error_ctx> read_json(const json_t& source)
+   {
+      auto buffer = source.dump();
+      if (buffer) {
+         return read_json<T>(*buffer);
+      }
+      else {
+         return unexpected(buffer.error());
+      }
+   }
+}
+
 #ifdef _MSC_VER
 // restore disabled warning
 #pragma warning(pop)
 #endif
+
+#include "glaze/core/seek.hpp"
+
+namespace glz
+{
+   // Specialization for glz::json_t
+   template <>
+   struct seek_op<glz::json_t>
+   {
+      template <class F>
+      static bool op(F&& func, auto&& value, sv json_ptr)
+      {
+         if (json_ptr.empty()) {
+            // At target - call func with the actual variant data, not the json_t wrapper
+            std::visit([&func](auto&& variant_value) { func(variant_value); }, value.data);
+            return true;
+         }
+
+         if (json_ptr[0] != '/' || json_ptr.size() < 2) return false;
+
+         // Handle object access
+         if (value.is_object()) {
+            auto& obj = value.get_object();
+
+            // Parse the key (with JSON Pointer escaping)
+            std::string key;
+            size_t i = 1;
+            for (; i < json_ptr.size(); ++i) {
+               auto c = json_ptr[i];
+               if (c == '/')
+                  break;
+               else if (c == '~') {
+                  if (++i == json_ptr.size()) return false;
+                  c = json_ptr[i];
+                  if (c == '0')
+                     c = '~';
+                  else if (c == '1')
+                     c = '/';
+                  else
+                     return false;
+               }
+               key.push_back(c);
+            }
+
+            auto it = obj.find(key);
+            if (it == obj.end()) return false;
+
+            sv remaining_ptr = json_ptr.substr(i);
+            return seek(std::forward<F>(func), it->second, remaining_ptr);
+         }
+         // Handle array access
+         else if (value.is_array()) {
+            auto& arr = value.get_array();
+
+            // Parse the index
+            size_t index{};
+            auto [p, ec] = std::from_chars(&json_ptr[1], json_ptr.data() + json_ptr.size(), index);
+            if (ec != std::errc{}) return false;
+
+            if (index >= arr.size()) return false;
+
+            sv remaining_ptr = json_ptr.substr(p - json_ptr.data());
+            return seek(std::forward<F>(func), arr[index], remaining_ptr);
+         }
+
+         return false;
+      }
+   };
+}
diff --git a/deps/saucer/include/glaze/json/manage.hpp b/deps/saucer/include/glaze/json/manage.hpp
deleted file mode 100644
index 978d173..0000000
--- a/deps/saucer/include/glaze/json/manage.hpp
+++ /dev/null
@@ -1,129 +0,0 @@
-// Glaze Library
-// For the license information refer to glaze.hpp
-
-#pragma once
-
-#include "glaze/json/json_ptr.hpp"
-#include "glaze/json/read.hpp"
-#include "glaze/json/write.hpp"
-
-namespace glz
-{
-   namespace detail
-   {
-      // manage_t invokes a function call before reading and after writing from a value
-      template <class T, class Member, class From, class To>
-      struct manage_t
-      {
-         static constexpr auto glaze_reflect = false;
-         using from_t = From;
-         using to_t = To;
-         T& val;
-         Member member;
-         From from;
-         To to;
-      };
-
-      template <class T, class Member, class From, class To>
-      manage_t(T&, Member, From, To) -> manage_t<T, Member, From, To>;
-
-      template <class T>
-         requires(is_specialization_v<T, manage_t>)
-      struct from_json<T>
-      {
-         template <auto Opts>
-         GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, auto&& it, auto&& end) noexcept
-         {
-            using V = std::decay_t<decltype(value)>;
-            using From = typename V::from_t;
-
-            read<json>::op<Opts>(get_member(value.val, value.member), ctx, it, end);
-
-            if constexpr (std::is_member_pointer_v<From>) {
-               if constexpr (std::is_member_function_pointer_v<From>) {
-                  if (!(value.val.*(value.from))()) {
-                     ctx.error = error_code::syntax_error;
-                     return;
-                  }
-               }
-               else if constexpr (std::is_member_object_pointer_v<From>) {
-                  auto& from = value.val.*(value.from);
-                  using Func = std::decay_t<decltype(from)>;
-                  if constexpr (std::is_invocable_r_v<bool, Func>) {
-                     if (!value.from()) {
-                        ctx.error = error_code::syntax_error;
-                        return;
-                     }
-                  }
-                  else {
-                     static_assert(false_v<T>, "function must have no arguments with a bool return");
-                  }
-               }
-               else {
-                  static_assert(false_v<T>, "invalid type");
-               }
-            }
-            else {
-               if (!value.from(value.val)) {
-                  ctx.error = error_code::syntax_error;
-                  return;
-               }
-            }
-         }
-      };
-
-      template <class T>
-         requires(is_specialization_v<T, manage_t>)
-      struct to_json<T>
-      {
-         template <auto Opts>
-         GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, auto&&... args) noexcept
-         {
-            using V = std::decay_t<decltype(value)>;
-            using To = typename V::to_t;
-
-            if constexpr (std::is_member_pointer_v<To>) {
-               if constexpr (std::is_member_function_pointer_v<To>) {
-                  if (!(value.val.*(value.to))()) {
-                     ctx.error = error_code::syntax_error;
-                     return;
-                  }
-               }
-               else if constexpr (std::is_member_object_pointer_v<To>) {
-                  auto& to = value.val.*(value.to);
-                  using Func = std::decay_t<decltype(to)>;
-                  if constexpr (std::is_invocable_r_v<bool, Func>) {
-                     if (!value.to()) {
-                        ctx.error = error_code::syntax_error;
-                        return;
-                     }
-                  }
-                  else {
-                     static_assert(false_v<T>, "function must have no arguments with a bool return");
-                  }
-               }
-               else {
-                  static_assert(false_v<T>, "invalid type");
-               }
-            }
-            else {
-               if (!value.to(value.val)) {
-                  ctx.error = error_code::syntax_error;
-                  return;
-               }
-            }
-
-            write<json>::op<Opts>(get_member(value.val, value.member), ctx, args...);
-         }
-      };
-
-      template <auto Member, auto From, auto To>
-      inline constexpr decltype(auto) manage_impl() noexcept
-      {
-         return [](auto&& v) { return manage_t{v, Member, From, To}; };
-      }
-   }
-
-   template <auto Member, auto From, auto To>
-   constexpr auto manage = detail::manage_impl<Member, From, To>();
-}
diff --git a/deps/saucer/include/glaze/json/max_write_precision.hpp b/deps/saucer/include/glaze/json/max_write_precision.hpp
index 1dcde90..e67b2da 100644
--- a/deps/saucer/include/glaze/json/max_write_precision.hpp
+++ b/deps/saucer/include/glaze/json/max_write_precision.hpp
@@ -57,67 +57,66 @@ namespace glz
       static constexpr auto value{[](auto& s) -> auto& { return s.val; }}; // reading just uses the value directly
    };
 
-   namespace detail
+   template <class T>
+   struct to<JSON, write_float32_t<T>>
    {
-      template <class T>
-      struct to_json<write_float32_t<T>>
-      {
-         template <auto Opts>
-         GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, auto&&... args) noexcept
-         {
-            write<json>::op<set_opt<Opts, &opts::float_max_write_precision>(float_precision::float32)>(value.val, ctx,
-                                                                                                       args...);
-         }
-      };
-
-      template <class T>
-      struct to_json<write_float64_t<T>>
-      {
-         template <auto Opts>
-         GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, auto&&... args) noexcept
-         {
-            write<json>::op<set_opt<Opts, &opts::float_max_write_precision>(float_precision::float64)>(value.val, ctx,
-                                                                                                       args...);
-         }
-      };
-
-      template <class T>
-      struct to_json<write_float_full_t<T>>
+      template <auto Opts>
+      GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, auto&&... args) noexcept
       {
-         template <auto Opts>
-         GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, auto&&... args) noexcept
-         {
-            write<json>::op<set_opt<Opts, &opts::float_max_write_precision>(float_precision::full)>(value.val, ctx,
-                                                                                                    args...);
-         }
-      };
-
-      template <auto MemPtr>
-      inline constexpr decltype(auto) write_float32_t_impl() noexcept
-      {
-         return [](auto&& val) { return write_float32_t<std::remove_reference_t<decltype(val.*MemPtr)>>{val.*MemPtr}; };
+         static constexpr auto O = set_opt<Opts, &decltype(Opts)::float_max_write_precision>(float_precision::float32);
+         using Value = core_t<decltype(value.val)>;
+         to<JSON, Value>::template op<O>(value.val, ctx, args...);
       }
+   };
 
-      template <auto MemPtr>
-      inline constexpr decltype(auto) write_float64_impl() noexcept
+   template <class T>
+   struct to<JSON, write_float64_t<T>>
+   {
+      template <auto Opts>
+      GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, auto&&... args) noexcept
       {
-         return [](auto&& val) { return write_float64_t<std::remove_reference_t<decltype(val.*MemPtr)>>{val.*MemPtr}; };
+         static constexpr auto O = set_opt<Opts, &decltype(Opts)::float_max_write_precision>(float_precision::float64);
+         using Value = core_t<decltype(value.val)>;
+         to<JSON, Value>::template op<O>(value.val, ctx, args...);
       }
+   };
 
-      template <auto MemPtr>
-      inline constexpr decltype(auto) write_float_full_impl() noexcept
+   template <class T>
+   struct to<JSON, write_float_full_t<T>>
+   {
+      template <auto Opts>
+      GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, auto&&... args) noexcept
       {
-         return
-            [](auto&& val) { return write_float_full_t<std::remove_reference_t<decltype(val.*MemPtr)>>{val.*MemPtr}; };
+         static constexpr auto O = set_opt<Opts, &decltype(Opts)::float_max_write_precision>(float_precision::full);
+         using Value = core_t<decltype(value.val)>;
+         to<JSON, Value>::template op<O>(value.val, ctx, args...);
       }
+   };
+
+   template <auto MemPtr>
+   inline constexpr decltype(auto) write_float32_t_impl() noexcept
+   {
+      return [](auto&& val) { return write_float32_t<std::remove_reference_t<decltype(val.*MemPtr)>>{val.*MemPtr}; };
+   }
+
+   template <auto MemPtr>
+   inline constexpr decltype(auto) write_float64_impl() noexcept
+   {
+      return [](auto&& val) { return write_float64_t<std::remove_reference_t<decltype(val.*MemPtr)>>{val.*MemPtr}; };
+   }
+
+   template <auto MemPtr>
+   inline constexpr decltype(auto) write_float_full_impl() noexcept
+   {
+      return [](auto&& val) { return write_float_full_t<std::remove_reference_t<decltype(val.*MemPtr)>>{val.*MemPtr}; };
    }
 
    template <auto MemPtr>
-   constexpr auto write_float32 = detail::write_float32_t_impl<MemPtr>();
+   constexpr auto write_float32 = write_float32_t_impl<MemPtr>();
 
    template <auto MemPtr>
-   constexpr auto write_float64 = detail::write_float64_impl<MemPtr>();
+   constexpr auto write_float64 = write_float64_impl<MemPtr>();
 
    template <auto MemPtr>
-   constexpr auto write_float_full = detail::write_float_full_impl<MemPtr>();
+   constexpr auto write_float_full = write_float_full_impl<MemPtr>();
 }
diff --git a/deps/saucer/include/glaze/json/minify.hpp b/deps/saucer/include/glaze/json/minify.hpp
index f60a39f..0267235 100644
--- a/deps/saucer/include/glaze/json/minify.hpp
+++ b/deps/saucer/include/glaze/json/minify.hpp
@@ -12,7 +12,7 @@ namespace glz
    namespace detail
    {
       // We can use unchecked dumping to the output because we know minifying will not make the output any larger
-      template <opts Opts>
+      template <auto Opts>
       inline void minify_json(is_context auto&& ctx, auto&& it, auto&& end, auto&& b, auto&& ix) noexcept
       {
          using enum json_type;
@@ -26,87 +26,108 @@ namespace glz
                skip_matching_ws(ws_start, it, ws_size);
             }
 
-            while (whitespace_table[*it]) {
-               ++it;
+            if constexpr (Opts.null_terminated) {
+               while (whitespace_table[uint8_t(*it)]) {
+                  ++it;
+               }
+            }
+            else {
+               while ((it < end) && whitespace_table[uint8_t(*it)]) {
+                  ++it;
+               }
             }
             ws_start = new_ws_start;
             ws_size = size_t(it - new_ws_start);
          };
 
          auto skip_whitespace = [&] {
-            while (whitespace_table[*it]) {
-               ++it;
+            if constexpr (Opts.null_terminated) {
+               while (whitespace_table[uint8_t(*it)]) {
+                  ++it;
+               }
+            }
+            else {
+               while ((it < end) && whitespace_table[uint8_t(*it)]) {
+                  ++it;
+               }
             }
          };
 
          skip_whitespace();
 
-         while (true) {
-            switch (json_types[size_t(*it)]) {
+         while ([&]() -> bool {
+            if constexpr (Opts.null_terminated) {
+               return true;
+            }
+            else {
+               return it < end;
+            }
+         }()) {
+            switch (json_types[uint8_t(*it)]) {
             case String: {
                const auto value = read_json_string<Opts>(it, end);
-               dump_unchecked(value, b, ix); // we couldn't have gotten here without a quote
+               dump_maybe_empty<false>(value, b, ix);
                skip_whitespace();
                break;
             }
             case Comma: {
-               dump_unchecked<','>(b, ix);
+               dump<',', false>(b, ix);
                ++it;
                skip_expected_whitespace();
                break;
             }
             case Number: {
-               const auto value = read_json_number(it);
-               dump_unchecked(value, b, ix); // we couldn't have gotten here without one valid character
+               const auto value = read_json_number<Opts.null_terminated>(it, end);
+               dump<false>(value, b, ix); // we couldn't have gotten here without one valid character
                skip_whitespace();
                break;
             }
             case Colon: {
-               dump_unchecked<':'>(b, ix);
+               dump<':', false>(b, ix);
                ++it;
                skip_whitespace();
                break;
             }
             case Array_Start: {
-               dump_unchecked<'['>(b, ix);
+               dump<'[', false>(b, ix);
                ++it;
                skip_expected_whitespace();
                break;
             }
             case Array_End: {
-               dump_unchecked<']'>(b, ix);
+               dump<']', false>(b, ix);
                ++it;
                skip_whitespace();
                break;
             }
             case Null: {
-               dump_unchecked<"null">(b, ix);
+               dump<"null", false>(b, ix);
                it += 4;
                skip_whitespace();
                break;
             }
             case Bool: {
                if (*it == 't') {
-                  dump_unchecked<"true">(b, ix);
+                  dump<"true", false>(b, ix);
                   it += 4;
                   skip_whitespace();
                   break;
                }
                else {
-                  dump_unchecked<"false">(b, ix);
+                  dump<"false", false>(b, ix);
                   it += 5;
                   skip_whitespace();
                   break;
                }
             }
             case Object_Start: {
-               dump_unchecked<'{'>(b, ix);
+               dump<'{', false>(b, ix);
                ++it;
                skip_expected_whitespace();
                break;
             }
             case Object_End: {
-               dump_unchecked<'}'>(b, ix);
+               dump<'}', false>(b, ix);
                ++it;
                skip_whitespace();
                break;
@@ -115,7 +136,7 @@ namespace glz
                if constexpr (Opts.comments) {
                   const auto value = read_jsonc_comment(it, end);
                   if (value.size()) [[likely]] {
-                     dump_unchecked(value, b, ix);
+                     dump<false>(value, b, ix);
                   }
                   skip_whitespace();
                   break;
@@ -124,34 +145,44 @@ namespace glz
                   [[fallthrough]];
                }
             }
-               [[unlikely]] default:
-               {
-                  ctx.error = error_code::syntax_error;
-                  return;
-               }
+            [[unlikely]] default: {
+               ctx.error = error_code::syntax_error;
+               return;
+            }
             }
          }
       }
 
-      template <opts Opts, contiguous In, output_buffer Out>
-      inline void minify_json(is_context auto&& ctx, In&& in, Out&& out) noexcept
+      template <auto Opts, class In, output_buffer Out>
+         requires(contiguous<In> && resizable<In>)
+      inline void minify_json(is_context auto&& ctx, In&& in, Out&& out)
       {
          if (in.empty()) {
             return;
          }
+         in.resize(in.size() + padding_bytes);
 
          if constexpr (resizable<Out>) {
             out.resize(in.size() + padding_bytes);
          }
          size_t ix = 0;
-         auto [it, end] = read_iterators<Opts>(ctx, in);
+         auto [it, end] = read_iterators<Opts, true>(in);
          if (bool(ctx.error)) [[unlikely]] {
             return;
          }
-         minify_json<opt_true<Opts, &opts::is_padded>>(ctx, it, end, out, ix);
+
+         static constexpr auto O = is_padded_on<Opts>();
+         if constexpr (string_t<In>) {
+            minify_json<opt_true<O, &opts::null_terminated>>(ctx, it, end, out, ix);
+         }
+         else {
+            minify_json<opt_false<O, &opts::null_terminated>>(ctx, it, end, out, ix);
+         }
+
          if constexpr (resizable<Out>) {
             out.resize(ix);
          }
+         in.resize(in.size() - padding_bytes);
       }
    }
 
@@ -159,15 +190,15 @@ namespace glz
    // should not happen since we minify auto-generated JSON.
    // The detail version can be used if error context is needed
 
-   template <opts Opts = opts{}>
-   inline void minify_json(const auto& in, auto& out) noexcept
+   template <auto Opts = opts{}>
+   inline void minify_json(resizable auto& in, auto& out)
    {
       context ctx{};
       detail::minify_json<Opts>(ctx, in, out);
    }
 
-   template <opts Opts = opts{}>
-   inline std::string minify_json(const auto& in) noexcept
+   template <auto Opts = opts{}>
+   inline std::string minify_json(resizable auto& in)
    {
       context ctx{};
       std::string out{};
@@ -175,15 +206,15 @@ namespace glz
       return out;
    }
 
-   template <opts Opts = opts{}>
-   inline void minify_jsonc(const auto& in, auto& out) noexcept
+   template <auto Opts = opts{}>
+   inline void minify_jsonc(const auto& in, auto& out)
    {
       context ctx{};
       detail::minify_json<opt_true<Opts, &opts::comments>>(ctx, in, out);
    }
 
-   template <opts Opts = opts{}>
-   inline std::string minify_jsonc(const auto& in) noexcept
+   template <auto Opts = opts{}>
+   inline std::string minify_jsonc(resizable auto& in)
    {
       context ctx{};
       std::string out{};
diff --git a/deps/saucer/include/glaze/json/ndjson.hpp b/deps/saucer/include/glaze/json/ndjson.hpp
index 6d2cbe1..185ca44 100644
--- a/deps/saucer/include/glaze/json/ndjson.hpp
+++ b/deps/saucer/include/glaze/json/ndjson.hpp
@@ -8,275 +8,273 @@
 
 namespace glz
 {
-   namespace detail
+   template <>
+   struct parse<NDJSON>
    {
-      template <>
-      struct read<ndjson>
+      template <auto Opts, class T, is_context Ctx, class It0, class It1>
+      static void op(T&& value, Ctx&& ctx, It0&& it, It1&& end)
       {
-         template <auto Opts, class T, is_context Ctx, class It0, class It1>
-         static void op(T&& value, Ctx&& ctx, It0&& it, It1&& end)
-         {
-            from_ndjson<std::remove_reference_t<T>>::template op<Opts>(std::forward<T>(value), std::forward<Ctx>(ctx),
-                                                                       std::forward<It0>(it), std::forward<It1>(end));
-         }
-      };
+         from<NDJSON, std::remove_reference_t<T>>::template op<Opts>(std::forward<T>(value), std::forward<Ctx>(ctx),
+                                                                     std::forward<It0>(it), std::forward<It1>(end));
+      }
+   };
 
-      template <class T>
-         requires readable_array_t<T> && (emplace_backable<T> || !resizable<T>)
-      struct from_ndjson<T>
+   template <>
+   struct serialize<NDJSON>
+   {
+      template <auto Opts, class T, is_context Ctx, class B, class IX>
+      static void op(T&& value, Ctx&& ctx, B&& b, IX&& ix)
       {
-         template <auto Opts>
-         static void op(auto& value, is_context auto&& ctx, auto&& it, auto&& end)
-         {
-            if (bool(ctx.error)) [[unlikely]] {
-               return;
-            }
+         to<NDJSON, std::decay_t<T>>::template op<Opts>(std::forward<T>(value), std::forward<Ctx>(ctx),
+                                                        std::forward<B>(b), std::forward<IX>(ix));
+      }
+   };
 
-            if (it == end) {
-               if constexpr (resizable<T>) {
-                  value.clear();
+   template <class T>
+      requires readable_array_t<T> && (emplace_backable<T> || !resizable<T>)
+   struct from<NDJSON, T>
+   {
+      template <auto Opts>
+      static void op(auto& value, is_context auto&& ctx, auto&& it, auto&& end)
+      {
+         if (bool(ctx.error)) [[unlikely]] {
+            return;
+         }
 
-                  if constexpr (Opts.shrink_to_fit) {
-                     value.shrink_to_fit();
-                  }
+         if (it == end) {
+            if constexpr (resizable<T>) {
+               value.clear();
+
+               if constexpr (check_shrink_to_fit(Opts)) {
+                  value.shrink_to_fit();
                }
             }
+         }
 
-            const auto n = value.size();
+         const auto n = value.size();
 
-            auto value_it = value.begin();
+         auto value_it = value.begin();
 
-            auto read_new_lines = [&] {
-               while (*it == '\r') {
-                  ++it;
-                  if (*it == '\n') {
-                     ++it;
-                  }
-                  else {
-                     ctx.error = error_code::syntax_error; // Expected '\n' after '\r'
-                     return;
-                  }
-               }
-               while (*it == '\n') {
+         auto read_new_lines = [&] {
+            while (*it == '\r') {
+               ++it;
+               if (*it == '\n') {
                   ++it;
                }
-            };
-
-            for (size_t i = 0; i < n; ++i) {
-               read<json>::op<Opts>(*value_it++, ctx, it, end);
-               if (it == end) {
-                  if constexpr (erasable<T>) {
-                     value.erase(value_it,
-                                 value.end()); // use erase rather than resize for non-default constructible elements
-
-                     if constexpr (Opts.shrink_to_fit) {
-                        value.shrink_to_fit();
-                     }
-                  }
+               else {
+                  ctx.error = error_code::syntax_error; // Expected '\n' after '\r'
                   return;
                }
-
-               read_new_lines();
             }
+            while (*it == '\n') {
+               ++it;
+            }
+         };
 
-            // growing
-            if constexpr (emplace_backable<T>) {
-               while (it < end) {
-                  read<json>::op<Opts>(value.emplace_back(), ctx, it, end);
-                  if (bool(ctx.error)) {
-                     return;
-                  }
+         for (size_t i = 0; i < n; ++i) {
+            parse<JSON>::op<Opts>(*value_it++, ctx, it, end);
+            if (it == end) {
+               if constexpr (erasable<T>) {
+                  value.erase(value_it,
+                              value.end()); // use erase rather than resize for non-default constructible elements
 
-                  read_new_lines();
+                  if constexpr (check_shrink_to_fit(Opts)) {
+                     value.shrink_to_fit();
+                  }
                }
-            }
-            else {
-               ctx.error = error_code::exceeded_static_array_size;
-            }
-         }
-      };
-
-      template <class T>
-         requires glaze_array_t<T> || tuple_t<T> || is_std_tuple<T>
-      struct from_ndjson<T>
-      {
-         template <auto Opts>
-         static void op(auto& value, is_context auto&& ctx, auto&& it, auto&& end)
-         {
-            if (bool(ctx.error)) [[unlikely]] {
                return;
             }
 
-            static constexpr auto N = []() constexpr {
-               if constexpr (glaze_array_t<T>) {
-                  return glz::tuple_size_v<meta_t<T>>;
-               }
-               else {
-                  return glz::tuple_size_v<T>;
-               }
-            }();
-
-            auto read_new_lines = [&] {
-               while (*it == '\r') {
-                  ++it;
-                  if (*it == '\n') {
-                     ++it;
-                  }
-                  else {
-                     ctx.error = error_code::syntax_error; // Expected '\n' after '\r'
-                     return;
-                  }
-               }
-               while (*it == '\n') {
-                  ++it;
-               }
-            };
+            read_new_lines();
+         }
 
-            for_each<N>([&](auto I) {
-               if (it == end) {
+         // growing
+         if constexpr (emplace_backable<T>) {
+            while (it < end) {
+               parse<JSON>::op<Opts>(value.emplace_back(), ctx, it, end);
+               if (bool(ctx.error)) {
                   return;
                }
-               if constexpr (I != 0) {
-                  read_new_lines();
-               }
-               if constexpr (is_std_tuple<T>) {
-                  read<json>::op<Opts>(std::get<I>(value), ctx, it, end);
-               }
-               else if constexpr (glaze_array_t<T>) {
-                  read<json>::op<Opts>(get_member(value, glz::get<I>(meta_v<T>)), ctx, it, end);
-               }
-               else {
-                  read<json>::op<Opts>(glz::get<I>(value), ctx, it, end);
-               }
-            });
+
+               read_new_lines();
+            }
          }
-      };
+         else {
+            ctx.error = error_code::exceeded_static_array_size;
+         }
+      }
+   };
 
-      template <>
-      struct write<ndjson>
+   template <class T>
+      requires glaze_array_t<T> || tuple_t<T> || is_std_tuple<T>
+   struct from<NDJSON, T>
+   {
+      template <auto Opts>
+      static void op(auto& value, is_context auto&& ctx, auto&& it, auto&& end)
       {
-         template <auto Opts, class T, is_context Ctx, class B, class IX>
-         static void op(T&& value, Ctx&& ctx, B&& b, IX&& ix)
-         {
-            to_ndjson<std::decay_t<T>>::template op<Opts>(std::forward<T>(value), std::forward<Ctx>(ctx),
-                                                          std::forward<B>(b), std::forward<IX>(ix));
+         if (bool(ctx.error)) [[unlikely]] {
+            return;
          }
-      };
 
-      template <writable_array_t T>
-      struct to_ndjson<T>
-      {
-         template <auto Opts, class... Args>
-         static void op(auto&& value, is_context auto&& ctx, Args&&... args) noexcept
-         {
-            const auto is_empty = [&]() -> bool {
-               if constexpr (has_size<T>) {
-                  return value.size() ? false : true;
+         static constexpr auto N = []() constexpr {
+            if constexpr (glaze_array_t<T>) {
+               return reflect<T>::size;
+            }
+            else {
+               return glz::tuple_size_v<T>;
+            }
+         }();
+
+         auto read_new_lines = [&] {
+            while (*it == '\r') {
+               ++it;
+               if (*it == '\n') {
+                  ++it;
                }
                else {
-                  return value.empty();
+                  ctx.error = error_code::syntax_error; // Expected '\n' after '\r'
+                  return;
                }
-            }();
-
-            if (!is_empty) {
-               auto it = value.begin();
-               write<json>::op<Opts>(*it, ctx, std::forward<Args>(args)...);
+            }
+            while (*it == '\n') {
                ++it;
-               const auto end = value.end();
-               for (; it != end; ++it) {
-                  dump<'\n'>(std::forward<Args>(args)...);
-                  write<json>::op<Opts>(*it, ctx, std::forward<Args>(args)...);
-               }
+            }
+         };
+
+         for_each<N>([&]<auto I>() {
+            if (it == end) {
+               return;
+            }
+            if constexpr (I != 0) {
+               read_new_lines();
+            }
+            if constexpr (is_std_tuple<T>) {
+               parse<JSON>::op<Opts>(std::get<I>(value), ctx, it, end);
+            }
+            else if constexpr (glaze_array_t<T>) {
+               parse<JSON>::op<Opts>(get_member(value, glz::get<I>(meta_v<T>)), ctx, it, end);
+            }
+            else {
+               parse<JSON>::op<Opts>(glz::get<I>(value), ctx, it, end);
+            }
+         });
+      }
+   };
+
+   template <writable_array_t T>
+   struct to<NDJSON, T>
+   {
+      template <auto Opts, class... Args>
+      static void op(auto&& value, is_context auto&& ctx, auto&& b, auto&& ix)
+      {
+         const auto is_empty = [&]() -> bool {
+            if constexpr (has_size<T>) {
+               return value.size() ? false : true;
+            }
+            else {
+               return value.empty();
+            }
+         }();
+
+         if (!is_empty) {
+            auto it = value.begin();
+            using Value = core_t<decltype(*it)>;
+            to<JSON, Value>::template op<Opts>(*it, ctx, b, ix);
+            ++it;
+            const auto end = value.end();
+            for (; it != end; ++it) {
+               dump<'\n'>(b, ix);
+               to<JSON, Value>::template op<Opts>(*it, ctx, b, ix);
             }
          }
-      };
+      }
+   };
 
-      template <class T>
-         requires glaze_array_t<T> || tuple_t<T>
-      struct to_ndjson<T>
+   template <class T>
+      requires glaze_array_t<T> || tuple_t<T>
+   struct to<NDJSON, T>
+   {
+      template <auto Opts, class... Args>
+      static void op(auto&& value, is_context auto&& ctx, Args&&... args)
       {
-         template <auto Opts, class... Args>
-         static void op(auto&& value, is_context auto&& ctx, Args&&... args) noexcept
-         {
-            static constexpr auto N = []() constexpr {
-               if constexpr (glaze_array_t<std::decay_t<T>>) {
-                  return glz::tuple_size_v<meta_t<std::decay_t<T>>>;
-               }
-               else {
-                  return glz::tuple_size_v<std::decay_t<T>>;
-               }
-            }();
+         static constexpr auto N = []() constexpr {
+            if constexpr (glaze_array_t<std::decay_t<T>>) {
+               return glz::tuple_size_v<meta_t<std::decay_t<T>>>;
+            }
+            else {
+               return glz::tuple_size_v<std::decay_t<T>>;
+            }
+         }();
 
-            using V = std::decay_t<T>;
-            for_each<N>([&](auto I) {
-               if constexpr (glaze_array_t<V>) {
-                  write<json>::op<Opts>(get_member(value, glz::get<I>(meta_v<T>)), ctx, std::forward<Args>(args)...);
-               }
-               else {
-                  write<json>::op<Opts>(glz::get<I>(value), ctx, std::forward<Args>(args)...);
-               }
-               constexpr bool needs_new_line = I < N - 1;
-               if constexpr (needs_new_line) {
-                  dump<'\n'>(std::forward<Args>(args)...);
-               }
-            });
-         }
-      };
+         using V = std::decay_t<T>;
+         for_each<N>([&]<auto I>() {
+            if constexpr (glaze_array_t<V>) {
+               serialize<JSON>::op<Opts>(get_member(value, glz::get<I>(meta_v<T>)), ctx, args...);
+            }
+            else {
+               serialize<JSON>::op<Opts>(glz::get<I>(value), ctx, args...);
+            }
+            constexpr bool needs_new_line = I < N - 1;
+            if constexpr (needs_new_line) {
+               dump<'\n'>(args...);
+            }
+         });
+      }
+   };
 
-      template <class T>
-         requires is_std_tuple<std::decay_t<T>>
-      struct to_ndjson<T>
+   template <class T>
+      requires is_std_tuple<std::decay_t<T>>
+   struct to<NDJSON, T>
+   {
+      template <auto Opts, class... Args>
+      static void op(auto&& value, is_context auto&& ctx, Args&&... args)
       {
-         template <auto Opts, class... Args>
-         static void op(auto&& value, is_context auto&& ctx, Args&&... args) noexcept
-         {
-            static constexpr auto N = []() constexpr {
-               if constexpr (glaze_array_t<std::decay_t<T>>) {
-                  return glz::tuple_size_v<meta_t<std::decay_t<T>>>;
-               }
-               else {
-                  return glz::tuple_size_v<std::decay_t<T>>;
-               }
-            }();
+         static constexpr auto N = []() constexpr {
+            if constexpr (glaze_array_t<std::decay_t<T>>) {
+               return glz::tuple_size_v<meta_t<std::decay_t<T>>>;
+            }
+            else {
+               return glz::tuple_size_v<std::decay_t<T>>;
+            }
+         }();
 
-            using V = std::decay_t<T>;
-            for_each<N>([&](auto I) {
-               if constexpr (glaze_array_t<V>) {
-                  write<json>::op<Opts>(value.*std::get<I>(meta_v<V>), ctx, std::forward<Args>(args)...);
-               }
-               else {
-                  write<json>::op<Opts>(std::get<I>(value), ctx, std::forward<Args>(args)...);
-               }
-               constexpr bool needs_new_line = I < N - 1;
-               if constexpr (needs_new_line) {
-                  dump<'\n'>(std::forward<Args>(args)...);
-               }
-            });
-         }
-      };
-   } // namespace detail
+         using V = std::decay_t<T>;
+         for_each<N>([&]<auto I>() {
+            if constexpr (glaze_array_t<V>) {
+               serialize<JSON>::op<Opts>(value.*std::get<I>(meta_v<V>), ctx, std::forward<Args>(args)...);
+            }
+            else {
+               serialize<JSON>::op<Opts>(std::get<I>(value), ctx, std::forward<Args>(args)...);
+            }
+            constexpr bool needs_new_line = I < N - 1;
+            if constexpr (needs_new_line) {
+               dump<'\n'>(std::forward<Args>(args)...);
+            }
+         });
+      }
+   };
 
-   template <read_ndjson_supported T, class Buffer>
-   [[nodiscard]] auto read_ndjson(T& value, Buffer&& buffer) noexcept
+   template <read_supported<NDJSON> T, class Buffer>
+   [[nodiscard]] auto read_ndjson(T& value, Buffer&& buffer)
    {
       context ctx{};
-      return read<opts{.format = ndjson}>(value, std::forward<Buffer>(buffer), ctx);
+      return read<opts{.format = NDJSON}>(value, std::forward<Buffer>(buffer), ctx);
    }
 
-   template <read_ndjson_supported T, class Buffer>
+   template <read_supported<NDJSON> T, class Buffer>
    [[nodiscard]] expected<T, error_ctx> read_ndjson(Buffer&& buffer)
    {
       T value{};
       context ctx{};
-      const auto ec = read<opts{.format = ndjson}>(value, std::forward<Buffer>(buffer), ctx);
+      const auto ec = read<opts{.format = NDJSON}>(value, std::forward<Buffer>(buffer), ctx);
       if (ec == error_code::none) {
          return value;
       }
       return unexpected(ec);
    }
 
-   template <auto Opts = opts{.format = ndjson}, read_ndjson_supported T>
-   [[nodiscard]] error_ctx read_file_ndjson(T& value, const sv file_name) noexcept
+   template <auto Opts = opts{.format = NDJSON}, read_supported<NDJSON> T>
+   [[nodiscard]] error_ctx read_file_ndjson(T& value, const sv file_name)
    {
       context ctx{};
       ctx.current_file = file_name;
@@ -292,22 +290,22 @@ namespace glz
       return read<Opts>(value, buffer, ctx);
    }
 
-   template <write_ndjson_supported T, class Buffer>
-   [[nodiscard]] error_ctx write_ndjson(T&& value, Buffer&& buffer) noexcept
+   template <write_supported<NDJSON> T, class Buffer>
+   [[nodiscard]] error_ctx write_ndjson(T&& value, Buffer&& buffer)
    {
-      return write<opts{.format = ndjson}>(std::forward<T>(value), std::forward<Buffer>(buffer));
+      return write<opts{.format = NDJSON}>(std::forward<T>(value), std::forward<Buffer>(buffer));
    }
 
-   template <write_ndjson_supported T>
-   [[nodiscard]] expected<std::string, error_ctx> write_ndjson(T&& value) noexcept
+   template <write_supported<NDJSON> T>
+   [[nodiscard]] expected<std::string, error_ctx> write_ndjson(T&& value)
    {
-      return write<opts{.format = ndjson}>(std::forward<T>(value));
+      return write<opts{.format = NDJSON}>(std::forward<T>(value));
    }
 
-   template <write_ndjson_supported T>
-   [[nodiscard]] error_ctx write_file_ndjson(T&& value, const std::string& file_name, auto&& buffer) noexcept
+   template <write_supported<NDJSON> T>
+   [[nodiscard]] error_ctx write_file_ndjson(T&& value, const std::string& file_name, auto&& buffer)
    {
-      write<opts{.format = ndjson}>(std::forward<T>(value), buffer);
+      write<opts{.format = NDJSON}>(std::forward<T>(value), buffer);
       return {buffer_to_file(buffer, file_name)};
    }
 }
diff --git a/deps/saucer/include/glaze/json/prettify.hpp b/deps/saucer/include/glaze/json/prettify.hpp
index 1582fde..be2436d 100644
--- a/deps/saucer/include/glaze/json/prettify.hpp
+++ b/deps/saucer/include/glaze/json/prettify.hpp
@@ -11,8 +11,8 @@ namespace glz
 {
    namespace detail
    {
-      template <opts Opts>
-      inline void prettify_json(is_context auto&& ctx, auto&& it, auto&& end, auto&& b, auto&& ix) noexcept
+      template <auto Opts>
+      inline void prettify_json(is_context auto&& ctx, auto&& it, auto&& end, auto&& b, auto&& ix)
       {
          constexpr bool use_tabs = Opts.indentation_char == '\t';
          constexpr auto indent_width = Opts.indentation_width;
@@ -23,10 +23,10 @@ namespace glz
          int64_t indent{};
 
          while (it < end) {
-            switch (json_types[size_t(*it)]) {
+            switch (json_types[uint8_t(*it)]) {
             case String: {
                const auto value = read_json_string<Opts>(it, end);
-               dump_not_empty(value, b, ix);
+               dump_maybe_empty(value, b, ix);
                break;
             }
             case Comma: {
@@ -51,7 +51,7 @@ namespace glz
                break;
             }
             case Number: {
-               const auto value = read_json_number(it);
+               const auto value = read_json_number<Opts.null_terminated>(it, end);
                dump_not_empty(value, b, ix);
                break;
             }
@@ -69,13 +69,24 @@ namespace glz
                dump<'['>(b, ix);
                ++it;
                ++indent;
-               state[indent] = Array_Start;
                if (size_t(indent) >= state.size()) [[unlikely]] {
                   state.resize(state.size() * 2);
+                  if (state.size() >= max_recursive_depth_limit) [[unlikely]] {
+                     ctx.error = error_code::exceeded_max_recursive_depth;
+                     return;
+                  }
                }
+               state[indent] = Array_Start;
                if constexpr (Opts.new_lines_in_arrays) {
-                  if (*it != ']') {
-                     append_new_line<use_tabs, indent_width>(b, ix, indent);
+                  if constexpr (not Opts.null_terminated) {
+                     if (it != end && *it != ']') {
+                        append_new_line<use_tabs, indent_width>(b, ix, indent);
+                     }
+                  }
+                  else {
+                     if (*it != ']') {
+                        append_new_line<use_tabs, indent_width>(b, ix, indent);
+                     }
                   }
                }
                break;
@@ -116,12 +127,23 @@ namespace glz
                dump<'{'>(b, ix);
                ++it;
                ++indent;
-               state[indent] = Object_Start;
                if (size_t(indent) >= state.size()) [[unlikely]] {
                   state.resize(state.size() * 2);
+                  if (state.size() >= max_recursive_depth_limit) [[unlikely]] {
+                     ctx.error = error_code::exceeded_max_recursive_depth;
+                     return;
+                  }
                }
-               if (*it != '}') {
-                  append_new_line<use_tabs, indent_width>(b, ix, indent);
+               state[indent] = Object_Start;
+               if constexpr (not Opts.null_terminated) {
+                  if (it != end && *it != '}') [[unlikely]] {
+                     append_new_line<use_tabs, indent_width>(b, ix, indent);
+                  }
+               }
+               else {
+                  if (*it != '}') {
+                     append_new_line<use_tabs, indent_width>(b, ix, indent);
+                  }
                }
                break;
             }
@@ -148,17 +170,16 @@ namespace glz
                   [[fallthrough]];
                }
             }
-               [[unlikely]] default:
-               {
-                  ctx.error = error_code::syntax_error;
-                  return;
-               }
+            [[unlikely]] default: {
+               ctx.error = error_code::syntax_error;
+               return;
+            }
             }
          }
       }
 
-      template <opts Opts, contiguous In, output_buffer Out>
-      inline void prettify_json(is_context auto&& ctx, In&& in, Out&& out) noexcept
+      template <auto Opts, contiguous In, output_buffer Out>
+      inline void prettify_json(is_context auto&& ctx, In&& in, Out&& out)
       {
          if constexpr (resizable<Out>) {
             if (in.empty()) {
@@ -168,11 +189,18 @@ namespace glz
             out.resize(in.size() * 2);
          }
          size_t ix = 0;
-         auto [it, end] = read_iterators<Opts>(ctx, in);
+         auto [it, end] = read_iterators<Opts>(in);
          if (bool(ctx.error)) [[unlikely]] {
             return;
          }
-         prettify_json<Opts>(ctx, it, end, out, ix);
+
+         if constexpr (string_t<In>) {
+            prettify_json<opt_true<Opts, &opts::null_terminated>>(ctx, it, end, out, ix);
+         }
+         else {
+            prettify_json<opt_false<Opts, &opts::null_terminated>>(ctx, it, end, out, ix);
+         }
+
          if constexpr (resizable<Out>) {
             out.resize(ix);
          }
@@ -183,8 +211,8 @@ namespace glz
    // should not happen since we prettify auto-generated JSON.
    // The detail version can be used if error context is needed
 
-   template <opts Opts = opts{}>
-   inline void prettify_json(const auto& in, auto& out) noexcept
+   template <auto Opts = opts{}>
+   inline void prettify_json(const auto& in, auto& out)
    {
       context ctx{};
       detail::prettify_json<Opts>(ctx, in, out);
@@ -193,8 +221,8 @@ namespace glz
    /// <summary>
    /// allocating version of prettify
    /// </summary>
-   template <opts Opts = opts{}>
-   inline std::string prettify_json(const auto& in) noexcept
+   template <auto Opts = opts{}>
+   inline std::string prettify_json(const auto& in)
    {
       context ctx{};
       std::string out{};
@@ -202,8 +230,8 @@ namespace glz
       return out;
    }
 
-   template <opts Opts = opts{}>
-   inline void prettify_jsonc(const auto& in, auto& out) noexcept
+   template <auto Opts = opts{}>
+   inline void prettify_jsonc(const auto& in, auto& out)
    {
       context ctx{};
       detail::prettify_json<opt_true<Opts, &opts::comments>>(ctx, in, out);
@@ -212,8 +240,8 @@ namespace glz
    /// <summary>
    /// allocating version of prettify
    /// </summary>
-   template <opts Opts = opts{}>
-   inline std::string prettify_jsonc(const auto& in) noexcept
+   template <auto Opts = opts{}>
+   inline std::string prettify_jsonc(const auto& in)
    {
       context ctx{};
       std::string out{};
diff --git a/deps/saucer/include/glaze/json/ptr.hpp b/deps/saucer/include/glaze/json/ptr.hpp
index eac21b5..6e7d742 100644
--- a/deps/saucer/include/glaze/json/ptr.hpp
+++ b/deps/saucer/include/glaze/json/ptr.hpp
@@ -4,8 +4,6 @@
 #pragma once
 
 #include "glaze/core/ptr.hpp"
-#include "glaze/json/read.hpp"
-#include "glaze/json/write.hpp"
 
 namespace glz
 {
diff --git a/deps/saucer/include/glaze/json/raw_string.hpp b/deps/saucer/include/glaze/json/raw_string.hpp
index 3426d5d..5669d0b 100644
--- a/deps/saucer/include/glaze/json/raw_string.hpp
+++ b/deps/saucer/include/glaze/json/raw_string.hpp
@@ -25,64 +25,63 @@ namespace glz
       T& val;
    };
 
-   namespace detail
+   template <class T>
+   struct from<JSON, raw_string_t<T>>
    {
-      template <class T>
-      struct from_json<raw_string_t<T>>
-      {
-         template <auto Opts>
-         GLZ_ALWAYS_INLINE static void op(auto&& value, auto&&... args) noexcept
-         {
-            read<json>::op<opt_true<Opts, &opts::raw_string>>(value.val, args...);
-         }
-      };
-
-      template <class T>
-      struct to_json<raw_string_t<T>>
+      template <auto Opts>
+      GLZ_ALWAYS_INLINE static void op(auto&& value, auto&&... args)
       {
-         template <auto Opts>
-         GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, auto&&... args) noexcept
-         {
-            write<json>::op<opt_true<Opts, &opts::raw_string>>(value.val, ctx, args...);
-         }
-      };
-
-      template <class T>
-      struct from_json<escaped_t<T>>
-      {
-         template <auto Opts>
-         GLZ_ALWAYS_INLINE static void op(auto&& value, auto&&... args) noexcept
-         {
-            read<json>::op<opt_false<Opts, &opts::raw_string>>(value.val, args...);
-         }
-      };
+         parse<JSON>::op<opt_true<Opts, &opts::raw_string>>(value.val, args...);
+      }
+   };
 
-      template <class T>
-      struct to_json<escaped_t<T>>
+   template <class T>
+   struct to<JSON, raw_string_t<T>>
+   {
+      template <auto Opts>
+      GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, auto&&... args)
       {
-         template <auto Opts>
-         GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, auto&&... args) noexcept
-         {
-            write<json>::op<opt_false<Opts, &opts::raw_string>>(value.val, ctx, args...);
-         }
-      };
+         using val_t = std::remove_cvref_t<decltype(value.val)>;
+         to<JSON, val_t>::template op<opt_true<Opts, &opts::raw_string>>(value.val, ctx, args...);
+      }
+   };
 
-      template <auto MemPtr>
-      GLZ_ALWAYS_INLINE constexpr decltype(auto) raw_string_impl() noexcept
+   template <class T>
+   struct from<JSON, escaped_t<T>>
+   {
+      template <auto Opts>
+      GLZ_ALWAYS_INLINE static void op(auto&& value, auto&&... args)
       {
-         return [](auto&& val) { return raw_string_t<std::remove_reference_t<decltype(val.*MemPtr)>>{val.*MemPtr}; };
+         parse<JSON>::op<opt_false<Opts, &opts::raw_string>>(value.val, args...);
       }
+   };
 
-      template <auto MemPtr>
-      GLZ_ALWAYS_INLINE constexpr decltype(auto) escaped_impl() noexcept
+   template <class T>
+   struct to<JSON, escaped_t<T>>
+   {
+      template <auto Opts>
+      GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, auto&&... args)
       {
-         return [](auto&& val) { return escaped_t<std::remove_reference_t<decltype(val.*MemPtr)>>{val.*MemPtr}; };
+         using val_t = std::remove_cvref_t<decltype(value.val)>;
+         to<JSON, val_t>::template op<opt_false<Opts, &opts::raw_string>>(value.val, ctx, args...);
       }
+   };
+
+   template <auto MemPtr>
+   GLZ_ALWAYS_INLINE constexpr decltype(auto) raw_string_impl() noexcept
+   {
+      return [](auto&& val) { return raw_string_t<std::remove_reference_t<decltype(val.*MemPtr)>>{val.*MemPtr}; };
+   }
+
+   template <auto MemPtr>
+   GLZ_ALWAYS_INLINE constexpr decltype(auto) escaped_impl() noexcept
+   {
+      return [](auto&& val) { return escaped_t<std::remove_reference_t<decltype(val.*MemPtr)>>{val.*MemPtr}; };
    }
 
    template <auto MemPtr>
-   constexpr auto raw_string = detail::raw_string_impl<MemPtr>();
+   constexpr auto raw_string = raw_string_impl<MemPtr>();
 
    template <auto MemPtr>
-   constexpr auto escaped = detail::escaped_impl<MemPtr>();
+   constexpr auto escaped = escaped_impl<MemPtr>();
 }
diff --git a/deps/saucer/include/glaze/json/read.hpp b/deps/saucer/include/glaze/json/read.hpp
index d13ef99..dcb542f 100644
--- a/deps/saucer/include/glaze/json/read.hpp
+++ b/deps/saucer/include/glaze/json/read.hpp
@@ -14,684 +14,1005 @@
 #include "glaze/core/common.hpp"
 #include "glaze/core/opts.hpp"
 #include "glaze/core/read.hpp"
+#include "glaze/core/reflect.hpp"
 #include "glaze/file/file_ops.hpp"
-#include "glaze/json/json_t.hpp"
+#include "glaze/json/json_concepts.hpp"
 #include "glaze/json/skip.hpp"
-#include "glaze/reflection/reflect.hpp"
 #include "glaze/util/for_each.hpp"
-#include "glaze/util/strod.hpp"
+#include "glaze/util/glaze_fast_float.hpp"
 #include "glaze/util/type_traits.hpp"
 #include "glaze/util/variant.hpp"
 
+#ifdef _MSC_VER
+// Turn off MSVC warning for unreachable code due to constexpr branching
+#pragma warning(push)
+#pragma warning(disable : 4702)
+#endif
+
 namespace glz
 {
-
    // forward declare from json/wrappers.hpp to avoid circular include
    template <class T>
    struct quoted_t;
 
-   namespace detail
+   template <>
+   struct parse<JSON>
    {
-      // Unless we can mutate the input buffer we need somewhere to store escaped strings for key lookup, etc.
-      // We don't put this in the context because we don't want to continually reallocate.
-      GLZ_ALWAYS_INLINE std::string& string_buffer() noexcept
-      {
-         static thread_local std::string buffer(256, '\0');
-         return buffer;
-      }
-
-      // The string_buffer() often gets resized, but we want our decode buffer to
-      // only ever grow on resizing. So, we make it its own buffer.
-      GLZ_ALWAYS_INLINE std::string& string_decode_buffer() noexcept
-      {
-         static thread_local std::string buffer(512, '\0');
-         return buffer;
-      }
-
-      // We use an error buffer to avoid multiple allocations in the case that errors occur multiple times.
-      GLZ_ALWAYS_INLINE std::string& error_buffer() noexcept
+      template <auto Opts, class T, is_context Ctx, class It0, class It1>
+      GLZ_ALWAYS_INLINE static void op(T&& value, Ctx&& ctx, It0&& it, It1&& end)
       {
-         static thread_local std::string buffer(256, '\0');
-         return buffer;
+         if constexpr (const_value_v<T>) {
+            if constexpr (Opts.error_on_const_read) {
+               ctx.error = error_code::attempt_const_read;
+            }
+            else {
+               // do not read anything into the const value
+               skip_value<JSON>::op<Opts>(std::forward<Ctx>(ctx), std::forward<It0>(it), std::forward<It1>(end));
+            }
+         }
+         else {
+            using V = std::remove_cvref_t<T>;
+            from<JSON, V>::template op<Opts>(std::forward<T>(value), std::forward<Ctx>(ctx), std::forward<It0>(it),
+                                             std::forward<It1>(end));
+         }
       }
 
-      template <>
-      struct read<json>
+      // This unknown key handler should not be given unescaped keys, that is for the user to handle.
+      template <auto Opts, class T, is_context Ctx, class It0, class It1>
+      static void handle_unknown(const sv& key, T&& value, Ctx&& ctx, It0&& it, It1&& end)
       {
-         template <auto Opts, class T, is_context Ctx, class It0, class It1>
-         GLZ_ALWAYS_INLINE static void op(T&& value, Ctx&& ctx, It0&& it, It1&& end) noexcept
-         {
-            if constexpr (std::is_const_v<std::remove_reference_t<T>>) {
-               if constexpr (Opts.error_on_const_read) {
-                  ctx.error = error_code::attempt_const_read;
+         using ValueType = std::decay_t<decltype(value)>;
+         if constexpr (has_unknown_reader<ValueType>) {
+            constexpr auto& reader = meta_unknown_read_v<ValueType>;
+            using ReaderType = meta_unknown_read_t<ValueType>;
+            if constexpr (std::is_member_object_pointer_v<ReaderType>) {
+               using MemberType = typename member_value<ReaderType>::type;
+               if constexpr (map_subscriptable<MemberType>) {
+                  parse<JSON>::op<Opts>((value.*reader)[key], ctx, it, end);
                }
                else {
-                  // do not read anything into the const value
-                  skip_value<Opts>(std::forward<Ctx>(ctx), std::forward<It0>(it), std::forward<It1>(end));
+                  static_assert(false_v<T>, "target must have subscript operator");
                }
             }
-            else {
-               using V = std::remove_cvref_t<T>;
-               from_json<V>::template op<Opts>(std::forward<T>(value), std::forward<Ctx>(ctx), std::forward<It0>(it),
-                                               std::forward<It1>(end));
-            }
-         }
-
-         // This unknown key handler should not be given unescaped keys, that is for the user to handle.
-         template <auto Opts, class T, is_context Ctx, class It0, class It1>
-         GLZ_ALWAYS_INLINE static void handle_unknown(const sv& key, T&& value, Ctx&& ctx, It0&& it, It1&& end) noexcept
-         {
-            using ValueType = std::decay_t<decltype(value)>;
-            if constexpr (detail::has_unknown_reader<ValueType>) {
-               constexpr auto& reader = meta_unknown_read_v<ValueType>;
-               using ReaderType = meta_unknown_read_t<ValueType>;
-               if constexpr (std::is_member_object_pointer_v<ReaderType>) {
-                  using MemberType = typename member_value<ReaderType>::type;
-                  if constexpr (detail::map_subscriptable<MemberType>) {
-                     read<json>::op<Opts>((value.*reader)[key], ctx, it, end);
-                  }
-                  else {
-                     static_assert(false_v<T>, "target must have subscript operator");
-                  }
-               }
-               else if constexpr (std::is_member_function_pointer_v<ReaderType>) {
-                  using ReturnType = typename return_type<ReaderType>::type;
-                  if constexpr (std::is_void_v<ReturnType>) {
-                     using TupleType = typename inputs_as_tuple<ReaderType>::type;
-                     if constexpr (glz::tuple_size_v<TupleType> == 2) {
-                        std::decay_t<glz::tuple_element_t<1, TupleType>> input{};
-                        read<json>::op<Opts>(input, ctx, it, end);
-                        if (bool(ctx.error)) [[unlikely]]
-                           return;
-                        (value.*reader)(key, input);
-                     }
-                     else {
-                        static_assert(false_v<T>, "method must have 2 args");
-                     }
+            else if constexpr (std::is_member_function_pointer_v<ReaderType>) {
+               using ReturnType = typename return_type<ReaderType>::type;
+               if constexpr (std::is_void_v<ReturnType>) {
+                  using TupleType = typename inputs_as_tuple<ReaderType>::type;
+                  if constexpr (glz::tuple_size_v<TupleType> == 2) {
+                     std::decay_t<glz::tuple_element_t<1, TupleType>> input{};
+                     parse<JSON>::op<Opts>(input, ctx, it, end);
+                     if (bool(ctx.error)) [[unlikely]]
+                        return;
+                     (value.*reader)(key, input);
                   }
                   else {
-                     static_assert(false_v<T>, "method must have void return");
+                     static_assert(false_v<T>, "method must have 2 args");
                   }
                }
                else {
-                  static_assert(false_v<T>, "unknown_read type not handled");
+                  static_assert(false_v<T>, "method must have void return");
                }
             }
             else {
-               skip_value<Opts>(ctx, it, end);
+               static_assert(false_v<T>, "unknown_read type not handled");
             }
          }
-      };
+         else {
+            skip_value<JSON>::op<Opts>(ctx, it, end);
+         }
+      }
+   };
+
+   // Unless we can mutate the input buffer we need somewhere to store escaped strings for key lookup, etc.
+   // We don't put this in the context because we don't want to continually reallocate.
+   // IMPORTANT: Do not call use this when nested calls may be made that need additional buffers on the same thread.
+   inline std::string& string_buffer() noexcept
+   {
+      static thread_local std::string buffer(256, '\0');
+      return buffer;
+   }
 
-      template <class T>
-         requires(glaze_value_t<T> && !custom_read<T>)
-      struct from_json<T>
+   // We use an error buffer to avoid multiple allocations in the case that errors occur multiple times.
+   inline std::string& error_buffer() noexcept
+   {
+      static thread_local std::string buffer(256, '\0');
+      return buffer;
+   }
+
+   template <class T>
+      requires(glaze_value_t<T> && !custom_read<T>)
+   struct from<JSON, T>
+   {
+      template <auto Opts, class Value, is_context Ctx, class It0, class It1>
+      GLZ_ALWAYS_INLINE static void op(Value&& value, Ctx&& ctx, It0&& it, It1&& end)
       {
-         template <auto Opts, class Value, is_context Ctx, class It0, class It1>
-         GLZ_ALWAYS_INLINE static void op(Value&& value, Ctx&& ctx, It0&& it, It1&& end) noexcept
-         {
-            using V = std::decay_t<decltype(get_member(std::declval<Value>(), meta_wrapper_v<T>))>;
-            from_json<V>::template op<Opts>(get_member(std::forward<Value>(value), meta_wrapper_v<T>),
-                                            std::forward<Ctx>(ctx), std::forward<It0>(it), std::forward<It1>(end));
+         using V = std::decay_t<decltype(get_member(std::declval<Value>(), meta_wrapper_v<T>))>;
+         from<JSON, V>::template op<Opts>(get_member(std::forward<Value>(value), meta_wrapper_v<T>),
+                                          std::forward<Ctx>(ctx), std::forward<It0>(it), std::forward<It1>(end));
+      }
+   };
+
+   template <auto Opts>
+   GLZ_ALWAYS_INLINE bool parse_ws_colon(is_context auto& ctx, auto&& it, auto&& end) noexcept
+   {
+      if (skip_ws<Opts>(ctx, it, end)) {
+         return true;
+      }
+      if (match_invalid_end<':', Opts>(ctx, it, end)) {
+         return true;
+      }
+      if (skip_ws<Opts>(ctx, it, end)) {
+         return true;
+      }
+      return false;
+   }
+
+   template <auto Opts, class T, size_t I, class Value, class... SelectedIndex>
+      requires(glaze_object_t<T> || reflectable<T>)
+   void decode_index(Value&& value, is_context auto&& ctx, auto&& it, auto&& end, SelectedIndex&&... selected_index)
+   {
+      static constexpr auto Key = get<I>(reflect<T>::keys);
+      static constexpr auto KeyWithEndQuote = join_v<Key, chars<"\"">>;
+      static constexpr auto Length = KeyWithEndQuote.size();
+
+      if (((it + Length) < end) && comparitor<KeyWithEndQuote>(it)) [[likely]] {
+         it += Length;
+         if constexpr (not Opts.null_terminated) {
+            if (it == end) [[unlikely]] {
+               ctx.error = error_code::unexpected_end;
+               return;
+            }
          }
-      };
 
-      template <is_member_function_pointer T>
-      struct from_json<T>
-      {
-         template <auto Opts>
-         GLZ_ALWAYS_INLINE static void op(auto&&, is_context auto&& ctx, auto&&...) noexcept
-         {
-            ctx.error = error_code::attempt_member_func_read;
+         if (skip_ws<Opts>(ctx, it, end)) {
+            return;
+         }
+         if (match_invalid_end<':', Opts>(ctx, it, end)) {
+            return;
+         }
+         if (skip_ws<Opts>(ctx, it, end)) {
+            return;
          }
-      };
 
-      template <is_includer T>
-      struct from_json<T>
-      {
-         template <auto Opts, class... Args>
-         GLZ_ALWAYS_INLINE static void op(auto&&, is_context auto&& ctx, auto&& it, auto&& end) noexcept
-         {
-            if constexpr (!Opts.ws_handled) {
-               GLZ_SKIP_WS;
+         // Check for operation-specific skipping
+         if constexpr (meta_has_skip<std::remove_cvref_t<T>>) {
+            if constexpr (meta<std::remove_cvref_t<T>>::skip(Key, {glz::operation::parse})) {
+               skip_value<JSON>::op<Opts>(ctx, it, end);
+               if (bool(ctx.error)) [[unlikely]]
+                  return; // Propagate error from skip_value
+               if constexpr (Opts.error_on_missing_keys || Opts.partial_read) {
+                  ((selected_index = I), ...); // Mark as handled even if skipped
+               }
+               return;
             }
-
-            match<R"("")", Opts>(ctx, it, end);
          }
-      };
 
-      template <is_bitset T>
-      struct from_json<T>
-      {
-         template <auto Opts>
-         GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, auto&& it, auto&& end) noexcept
-         {
-            GLZ_MATCH_QUOTE;
+         using V = refl_t<T, I>;
 
-            const auto n = value.size();
-            for (size_t i = 1; it < end; ++i, ++it) {
-               if (*it == '"') {
-                  ++it;
+         if constexpr (const_value_v<V>) {
+            if constexpr (Opts.error_on_const_read) {
+               ctx.error = error_code::attempt_const_read;
+            }
+            else {
+               // do not read anything into the const value
+               skip_value<JSON>::op<Opts>(ctx, it, end);
+            }
+         }
+         else {
+            if constexpr (glaze_object_t<T>) {
+               from<JSON, std::remove_cvref_t<V>>::template op<ws_handled<Opts>()>(
+                  get_member(value, get<I>(reflect<T>::values)), ctx, it, end);
+            }
+            else {
+               from<JSON, std::remove_cvref_t<V>>::template op<ws_handled<Opts>()>(
+                  get_member(value, get<I>(to_tie(value))), ctx, it, end);
+            }
+         }
+
+         if constexpr (Opts.error_on_missing_keys || Opts.partial_read) {
+            ((selected_index = I), ...);
+         }
+      }
+      else [[unlikely]] {
+         if constexpr (Opts.error_on_unknown_keys) {
+            ctx.error = error_code::unknown_key;
+         }
+         else {
+            auto* start = it;
+            skip_string_view<Opts>(ctx, it, end);
+            if (bool(ctx.error)) [[unlikely]]
+               return;
+            const sv key = {start, size_t(it - start)};
+            ++it;
+            if constexpr (not Opts.null_terminated) {
+               if (it == end) [[unlikely]] {
+                  ctx.error = error_code::unexpected_end;
                   return;
                }
+            }
 
-               if (i > n) {
-                  ctx.error = error_code::exceeded_static_array_size;
+            if (parse_ws_colon<Opts>(ctx, it, end)) {
+               return;
+            }
+
+            parse<JSON>::handle_unknown<Opts>(key, value, ctx, it, end);
+         }
+      }
+   }
+
+   template <auto Opts, class T, size_t I, class Value>
+      requires(glaze_enum_t<T> || (meta_keys<T> && std::is_enum_v<T>))
+   void decode_index(Value&& value, is_context auto&& ctx, auto&& it, auto&& end) noexcept
+   {
+      static constexpr auto TargetKey = glz::get<I>(reflect<T>::keys);
+      static constexpr auto Length = TargetKey.size();
+
+      if (((it + Length) < end) && comparitor<TargetKey>(it)) [[likely]] {
+         it += Length;
+         if (*it != '"') [[unlikely]] {
+            ctx.error = error_code::unexpected_enum;
+            return;
+         }
+         value = get<I>(reflect<T>::values);
+
+         ++it;
+         if constexpr (not Opts.null_terminated) {
+            if (it == end) {
+               ctx.error = error_code::end_reached;
+               return;
+            }
+         }
+      }
+      else [[unlikely]] {
+         ctx.error = error_code::unexpected_enum;
+         return;
+      }
+   }
+
+   template <auto Opts, class T, auto& HashInfo, class Value, class... SelectedIndex>
+      requires(glaze_object_t<T> || reflectable<T>)
+   GLZ_ALWAYS_INLINE constexpr void parse_and_invoke(Value&& value, is_context auto&& ctx, auto&& it, auto&& end,
+                                                     SelectedIndex&&... selected_index)
+   {
+      constexpr auto type = HashInfo.type;
+      constexpr auto N = reflect<T>::size;
+
+      static_assert(bool(type), "invalid hash algorithm");
+
+      if constexpr (N == 1) {
+         decode_index<Opts, T, 0>(value, ctx, it, end, selected_index...);
+      }
+      else {
+         const auto index = decode_hash<JSON, T, HashInfo, HashInfo.type>::op(it, end);
+
+         if (index >= N) [[unlikely]] {
+            if constexpr (Opts.error_on_unknown_keys) {
+               ctx.error = error_code::unknown_key;
+               return;
+            }
+            else {
+               // we need to search until we find the ending quote of the key
+               auto start = it;
+               skip_string_view<Opts>(ctx, it, end);
+               if (bool(ctx.error)) [[unlikely]]
                   return;
+               const sv key = {start, size_t(it - start)};
+               ++it; // skip the quote
+               if constexpr (not Opts.null_terminated) {
+                  if (it == end) [[unlikely]] {
+                     ctx.error = error_code::unexpected_end;
+                     return;
+                  }
                }
 
-               if (*it == '0') {
-                  value[n - i] = 0;
-               }
-               else if (*it == '1') {
-                  value[n - i] = 1;
-               }
-               else [[unlikely]] {
-                  ctx.error = error_code::syntax_error;
+               if (parse_ws_colon<Opts>(ctx, it, end)) {
                   return;
                }
+
+               parse<JSON>::handle_unknown<Opts>(key, value, ctx, it, end);
+               return;
             }
+         }
 
-            ctx.error = error_code::expected_quote;
+         if constexpr (N == 2) {
+            if (index == 0) {
+               decode_index<Opts, T, 0>(value, ctx, it, end, selected_index...);
+            }
+            else {
+               decode_index<Opts, T, 1>(value, ctx, it, end, selected_index...);
+            }
+         }
+         else {
+            visit<N>([&]<size_t I>() { decode_index<Opts, T, I>(value, ctx, it, end, selected_index...); }, index);
          }
-      };
+      }
+   }
 
-      template <>
-      struct from_json<skip>
+   template <is_member_function_pointer T>
+   struct from<JSON, T>
+   {
+      template <auto Opts>
+      GLZ_ALWAYS_INLINE static void op(auto&&, is_context auto&& ctx, auto&&...) noexcept
       {
-         template <auto Opts>
-         GLZ_ALWAYS_INLINE static void op(auto&&, is_context auto&& ctx, auto&&... args) noexcept
-         {
-            skip_value<Opts>(ctx, args...);
-         }
-      };
+         ctx.error = error_code::attempt_member_func_read;
+      }
+   };
 
-      template <is_reference_wrapper T>
-      struct from_json<T>
+   template <is_includer T>
+   struct from<JSON, T>
+   {
+      template <auto Opts, class... Args>
+      static void op(auto&&, is_context auto&& ctx, auto&& it, auto&& end) noexcept
       {
-         template <auto Opts, class... Args>
-         GLZ_ALWAYS_INLINE static void op(auto&& value, Args&&... args) noexcept
-         {
-            using V = std::decay_t<decltype(value.get())>;
-            from_json<V>::template op<Opts>(value.get(), std::forward<Args>(args)...);
+         if constexpr (!check_ws_handled(Opts)) {
+            if (skip_ws<Opts>(ctx, it, end)) {
+               return;
+            }
          }
-      };
 
-      template <>
-      struct from_json<hidden>
+         match<R"("")", Opts>(ctx, it, end);
+      }
+   };
+
+   template <is_bitset T>
+   struct from<JSON, T>
+   {
+      template <auto Opts>
+      static void op(auto&& value, is_context auto&& ctx, auto&& it, auto&& end) noexcept
       {
-         template <auto Opts>
-         GLZ_ALWAYS_INLINE static void op(auto&&, is_context auto&& ctx, auto&&...) noexcept
-         {
-            ctx.error = error_code::attempt_read_hidden;
+         if (match_invalid_end<'"', Opts>(ctx, it, end)) {
+            return;
          }
-      };
 
-      template <complex_t T>
-      struct from_json<T>
-      {
-         template <auto Options>
-         GLZ_ALWAYS_INLINE static void op(auto&& v, is_context auto&& ctx, auto&& it, auto&& end) noexcept
-         {
-            constexpr auto Opts = ws_handled_off<Options>();
-            if constexpr (!Options.ws_handled) {
-               GLZ_SKIP_WS;
-            }
-            GLZ_MATCH_OPEN_BRACKET;
-
-            auto* ptr = reinterpret_cast<typename T::value_type*>(&v);
-            static_assert(sizeof(T) == sizeof(typename T::value_type) * 2);
-            read<json>::op<Opts>(ptr[0], ctx, it, end);
-            if (bool(ctx.error)) [[unlikely]]
+         const auto n = value.size();
+         for (size_t i = 1; it < end; ++i, ++it) {
+            if (*it == '"') {
+               ++it;
+               if constexpr (not Opts.null_terminated) {
+                  if (it == end) {
+                     ctx.error = error_code::end_reached;
+                     return;
+                  }
+               }
                return;
+            }
+
+            if (i > n) {
+               ctx.error = error_code::exceeded_static_array_size;
+               return;
+            }
 
-            GLZ_SKIP_WS;
+            if (*it == '0') {
+               value[n - i] = 0;
+            }
+            else if (*it == '1') {
+               value[n - i] = 1;
+            }
+            else [[unlikely]] {
+               ctx.error = error_code::syntax_error;
+               return;
+            }
+         }
 
-            GLZ_MATCH_COMMA;
+         ctx.error = error_code::expected_quote;
+      }
+   };
 
-            read<json>::op<Opts>(ptr[1], ctx, it, end);
-            if (bool(ctx.error)) [[unlikely]]
+   template <>
+   struct from<JSON, skip>
+   {
+      template <auto Opts>
+      GLZ_ALWAYS_INLINE static void op(auto&&, is_context auto&& ctx, auto&&... args) noexcept
+      {
+         skip_value<JSON>::op<Opts>(ctx, args...);
+      }
+   };
+
+   template <is_reference_wrapper T>
+   struct from<JSON, T>
+   {
+      template <auto Opts, class... Args>
+      GLZ_ALWAYS_INLINE static void op(auto&& value, Args&&... args)
+      {
+         using V = std::decay_t<decltype(value.get())>;
+         from<JSON, V>::template op<Opts>(value.get(), std::forward<Args>(args)...);
+      }
+   };
+
+   template <>
+   struct from<JSON, hidden>
+   {
+      template <auto Opts>
+      GLZ_ALWAYS_INLINE static void op(auto&&, is_context auto&& ctx, auto&&...) noexcept
+      {
+         ctx.error = error_code::attempt_read_hidden;
+      }
+   };
+
+   template <complex_t T>
+   struct from<JSON, T>
+   {
+      template <auto Options>
+      static void op(auto&& v, is_context auto&& ctx, auto&& it, auto&& end) noexcept
+      {
+         constexpr auto Opts = ws_handled_off<Options>();
+         if constexpr (!check_ws_handled(Options)) {
+            if (skip_ws<Opts>(ctx, it, end)) {
                return;
+            }
+         }
+         if (match_invalid_end<'[', Opts>(ctx, it, end)) {
+            return;
+         }
+         if constexpr (not Opts.null_terminated) {
+            ++ctx.indentation_level;
+         }
+
+         auto* ptr = reinterpret_cast<typename T::value_type*>(&v);
+         static_assert(sizeof(T) == sizeof(typename T::value_type) * 2);
+         parse<JSON>::op<Opts>(ptr[0], ctx, it, end);
+         if (bool(ctx.error)) [[unlikely]]
+            return;
+
+         if (skip_ws<Opts>(ctx, it, end)) {
+            return;
+         }
 
-            GLZ_SKIP_WS;
-            GLZ_MATCH_CLOSE_BRACKET;
+         if (match_invalid_end<',', Opts>(ctx, it, end)) {
+            return;
          }
-      };
 
-      template <always_null_t T>
-      struct from_json<T>
+         parse<JSON>::op<Opts>(ptr[1], ctx, it, end);
+         if (bool(ctx.error)) [[unlikely]]
+            return;
+
+         if (skip_ws<Opts>(ctx, it, end)) {
+            return;
+         }
+         match<']'>(ctx, it);
+         if constexpr (not Opts.null_terminated) {
+            --ctx.indentation_level;
+         }
+      }
+   };
+
+   template <always_null_t T>
+   struct from<JSON, T>
+   {
+      template <auto Opts>
+      GLZ_ALWAYS_INLINE static void op(auto&&, is_context auto&& ctx, auto&& it, auto&& end) noexcept
       {
-         template <auto Opts>
-         GLZ_ALWAYS_INLINE static void op(auto&&, is_context auto&& ctx, auto&& it, auto&& end) noexcept
-         {
-            if constexpr (!Opts.ws_handled) {
-               GLZ_SKIP_WS;
+         if constexpr (!check_ws_handled(Opts)) {
+            if (skip_ws<Opts>(ctx, it, end)) {
+               return;
+            }
+         }
+         static constexpr sv null_string = "null";
+         if constexpr (not check_is_padded(Opts)) {
+            const auto n = size_t(end - it);
+            if ((n < 4) || not comparitor<null_string>(it)) [[unlikely]] {
+               ctx.error = error_code::syntax_error;
             }
-            match<"null", Opts>(ctx, it, end);
          }
-      };
+         else {
+            if (not comparitor<null_string>(it)) [[unlikely]] {
+               ctx.error = error_code::syntax_error;
+            }
+         }
+         it += 4; // always advance for performance
+      }
+   };
 
-      template <bool_t T>
-      struct from_json<T>
+   template <bool_t T>
+   struct from<JSON, T>
+   {
+      template <auto Opts>
+      static void op(bool_t auto&& value, is_context auto&& ctx, auto&& it, auto&& end) noexcept
       {
-         template <auto Opts>
-         GLZ_ALWAYS_INLINE static void op(bool_t auto&& value, is_context auto&& ctx, auto&& it, auto&& end) noexcept
-         {
-            if constexpr (Opts.quoted_num) {
-               GLZ_SKIP_WS;
-               GLZ_MATCH_QUOTE;
+         if constexpr (Opts.quoted_num) {
+            if (skip_ws<Opts>(ctx, it, end)) {
+               return;
+            }
+            if (match_invalid_end<'"', Opts>(ctx, it, end)) {
+               return;
             }
+         }
 
-            if constexpr (!Opts.ws_handled) {
-               GLZ_SKIP_WS;
+         if constexpr (!check_ws_handled(Opts)) {
+            if (skip_ws<Opts>(ctx, it, end)) {
+               return;
             }
+         }
 
-            if constexpr (Opts.bools_as_numbers) {
-               if (*it == '1') {
-                  value = true;
-                  ++it;
+         if constexpr (Opts.bools_as_numbers) {
+            if (*it == '1') {
+               value = true;
+               ++it;
+            }
+            else if (*it == '0') {
+               value = false;
+               ++it;
+            }
+            else {
+               ctx.error = error_code::syntax_error;
+               return;
+            }
+         }
+         else {
+            if constexpr (not check_is_padded(Opts)) {
+               if (size_t(end - it) < 4) [[unlikely]] {
+                  ctx.error = error_code::expected_true_or_false;
+                  return;
                }
-               else if (*it == '0') {
+            }
+
+            uint32_t c;
+            static constexpr uint32_t u_true = 0b01100101'01110101'01110010'01110100;
+            static constexpr uint32_t u_fals = 0b01110011'01101100'01100001'01100110;
+            std::memcpy(&c, it, 4);
+            it += 4;
+            if (c == u_true) {
+               value = true;
+            }
+            else if (it == end) [[unlikely]] {
+               ctx.error = error_code::unexpected_end;
+               return;
+            }
+            else {
+               if (c == u_fals && (*it == 'e')) [[likely]] {
                   value = false;
                   ++it;
                }
-               else {
-                  ctx.error = error_code::syntax_error;
+               else [[unlikely]] {
+                  ctx.error = error_code::expected_true_or_false;
                   return;
                }
             }
-            else {
-               if constexpr (not Opts.is_padded) {
-                  if (size_t(end - it) < 4) [[unlikely]] {
-                     ctx.error = error_code::expected_true_or_false;
-                     return;
-                  }
-               }
+         }
 
-               uint64_t c{};
-               // Note that because our buffer must be null terminated, we can read one more index without checking:
-               std::memcpy(&c, it, 5);
-               constexpr uint64_t u_true = 0b00000000'00000000'00000000'00000000'01100101'01110101'01110010'01110100;
-               constexpr uint64_t u_false = 0b00000000'00000000'00000000'01100101'01110011'01101100'01100001'01100110;
-               // We have to wipe the 5th character for true testing
-               if ((c & 0xFF'FF'FF'00'FF'FF'FF'FF) == u_true) {
-                  value = true;
-                  it += 4;
+         if constexpr (Opts.quoted_num) {
+            if constexpr (not Opts.null_terminated) {
+               if (it == end) [[unlikely]] {
+                  ctx.error = error_code::unexpected_end;
+                  return;
                }
-               else {
-                  if (c != u_false) [[unlikely]] {
-                     ctx.error = error_code::expected_true_or_false;
-                     return;
-                  }
-                  value = false;
-                  it += 5;
+            }
+            if (match<'"'>(ctx, it)) {
+               return;
+            }
+            if constexpr (not Opts.null_terminated) {
+               if (it == end) {
+                  ctx.error = error_code::end_reached;
+                  return;
                }
             }
-
-            if constexpr (Opts.quoted_num) {
-               GLZ_MATCH_QUOTE;
+         }
+         else {
+            if constexpr (not Opts.null_terminated) {
+               if (it == end) {
+                  ctx.error = error_code::end_reached;
+                  return;
+               }
             }
          }
-      };
+      }
+   };
 
-      template <num_t T>
-      struct from_json<T>
+   template <num_t T>
+   struct from<JSON, T>
+   {
+      template <auto Opts, class It>
+      GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, It&& it, auto&& end) noexcept
       {
-         template <auto Opts, class It>
-         GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, It&& it, auto&& end) noexcept
-         {
-            if constexpr (Opts.quoted_num) {
-               GLZ_SKIP_WS;
-               GLZ_MATCH_QUOTE;
+         if constexpr (Opts.quoted_num) {
+            if (skip_ws<Opts>(ctx, it, end)) {
+               return;
             }
-
-            if constexpr (!Opts.ws_handled) {
-               GLZ_SKIP_WS;
+            if (match_invalid_end<'"', Opts>(ctx, it, end)) {
+               return;
             }
+         }
 
-            using V = std::decay_t<decltype(value)>;
-            if constexpr (int_t<V>) {
-               static constexpr auto maximum = uint64_t((std::numeric_limits<V>::max)());
-               if constexpr (std::is_unsigned_v<V>) {
-                  if constexpr (std::same_as<V, uint64_t>) {
-                     if (*it == '-') [[unlikely]] {
-                        ctx.error = error_code::parse_number_failure;
-                        return;
-                     }
+         if constexpr (!check_ws_handled(Opts)) {
+            if (skip_ws<Opts>(ctx, it, end)) {
+               return;
+            }
+         }
 
-                     static_assert(sizeof(*it) == sizeof(char));
-                     const char* cur = reinterpret_cast<const char*>(it);
-                     const char* beg = cur;
-                     if constexpr (std::is_volatile_v<std::remove_reference_t<decltype(value)>>) {
-                        // Hardware may interact with value changes, so we parse into a temporary and assign in one
-                        // place
-                        uint64_t i{};
-                        auto s = parse_int<uint64_t, Opts.force_conformance>(i, cur);
-                        if (!s) [[unlikely]] {
-                           ctx.error = error_code::parse_number_failure;
-                           return;
-                        }
-                        value = i;
-                     }
-                     else {
-                        auto s = parse_int<decay_keep_volatile_t<decltype(value)>, Opts.force_conformance>(value, cur);
-                        if (!s) [[unlikely]] {
-                           ctx.error = error_code::parse_number_failure;
-                           return;
-                        }
-                     }
+         using V = std::decay_t<decltype(value)>;
+         if constexpr (int_t<V>) {
+            static_assert(sizeof(*it) == sizeof(char));
 
-                     it += (cur - beg);
+            if constexpr (Opts.null_terminated) {
+               if (not glz::atoi(value, it)) [[unlikely]] {
+                  ctx.error = error_code::parse_number_failure;
+                  return;
+               }
+            }
+            else {
+               if (not glz::atoi(value, it, end)) [[unlikely]] {
+                  ctx.error = error_code::parse_number_failure;
+                  return;
+               }
+            }
+         }
+         else {
+            if constexpr (is_float128<V>) {
+               auto [ptr, ec] = std::from_chars(it, end, value);
+               if (ec != std::errc()) {
+                  ctx.error = error_code::parse_number_failure;
+                  return;
+               }
+               it = ptr;
+            }
+            else {
+               if constexpr (std::is_volatile_v<std::remove_reference_t<decltype(value)>>) {
+                  // Hardware may interact with value changes, so we parse into a temporary and assign in one
+                  // place
+                  V temp;
+                  auto [ptr, ec] = glz::from_chars<Opts.null_terminated>(it, end, temp);
+                  if (ec != std::errc()) [[unlikely]] {
+                     ctx.error = error_code::parse_number_failure;
+                     return;
                   }
-                  else {
-                     uint64_t i{};
-                     if (*it == '-') [[unlikely]] {
-                        ctx.error = error_code::parse_number_failure;
-                        return;
-                     }
+                  value = temp;
+                  it = ptr;
+               }
+               else {
+                  auto [ptr, ec] = glz::from_chars<Opts.null_terminated>(it, end, value);
+                  if (ec != std::errc()) [[unlikely]] {
+                     ctx.error = error_code::parse_number_failure;
+                     return;
+                  }
+                  it = ptr;
+               }
+            }
+         }
 
-                     static_assert(sizeof(*it) == sizeof(char));
-                     const char* cur = reinterpret_cast<const char*>(it);
-                     const char* beg = cur;
-                     auto s = parse_int<std::decay_t<decltype(i)>, Opts.force_conformance>(i, cur);
-                     if (!s) [[unlikely]] {
-                        ctx.error = error_code::parse_number_failure;
-                        return;
-                     }
+         if constexpr (Opts.quoted_num) {
+            if constexpr (not Opts.null_terminated) {
+               if (it == end) [[unlikely]] {
+                  ctx.error = error_code::unexpected_end;
+                  return;
+               }
+            }
+            if (match<'"'>(ctx, it)) {
+               return;
+            }
+            if constexpr (not Opts.null_terminated) {
+               if (it == end) {
+                  ctx.error = error_code::end_reached;
+                  return;
+               }
+            }
+         }
+         else {
+            if constexpr (not Opts.null_terminated) {
+               if (it == end) {
+                  ctx.error = error_code::end_reached;
+                  return;
+               }
+            }
+         }
+      }
+   };
 
-                     if (i > maximum) [[unlikely]] {
-                        ctx.error = error_code::parse_number_failure;
-                        return;
-                     }
-                     value = V(i);
-                     it += (cur - beg);
+   template <string_t T>
+   struct from<JSON, T>
+   {
+      template <auto Opts, class It, class End>
+         requires(check_is_padded(Opts))
+      static void op(auto& value, is_context auto&& ctx, It&& it, End&& end)
+      {
+         if constexpr (Opts.number) {
+            auto start = it;
+            skip_number<Opts>(ctx, it, end);
+            if (bool(ctx.error)) [[unlikely]] {
+               return;
+            }
+            value.append(start, size_t(it - start));
+         }
+         else {
+            if constexpr (!check_opening_handled(Opts)) {
+               if constexpr (!check_ws_handled(Opts)) {
+                  if (skip_ws<Opts>(ctx, it, end)) {
+                     return;
                   }
                }
-               else {
-                  uint64_t i{};
-                  int sign = 1;
-                  if (*it == '-') {
-                     sign = -1;
-                     ++it;
-                  }
 
-                  static_assert(sizeof(*it) == sizeof(char));
-                  const char* cur = reinterpret_cast<const char*>(it);
-                  const char* beg = cur;
-                  auto s = parse_int<decay_keep_volatile_t<decltype(i)>, Opts.force_conformance>(i, cur);
-                  if (!s) [[unlikely]] {
-                     ctx.error = error_code::parse_number_failure;
+               if (match_invalid_end<'"', Opts>(ctx, it, end)) {
+                  return;
+               }
+            }
+
+            if constexpr (not Opts.raw_string) {
+               static constexpr auto string_padding_bytes = 8;
+
+               auto start = it;
+               while (true) {
+                  if (it >= end) [[unlikely]] {
+                     ctx.error = error_code::unexpected_end;
                      return;
                   }
 
-                  if (sign == -1) {
-                     static constexpr auto min_abs = uint64_t((std::numeric_limits<V>::max)()) + 1;
-                     if (i > min_abs) [[unlikely]] {
-                        ctx.error = error_code::parse_number_failure;
-                        return;
+                  uint64_t chunk;
+                  std::memcpy(&chunk, it, 8);
+                  const uint64_t test_chars = has_quote(chunk);
+                  if (test_chars) {
+                     it += (countr_zero(test_chars) >> 3);
+
+                     auto* prev = it - 1;
+                     while (*prev == '\\') {
+                        --prev;
                      }
-                     value = V(sign * i);
+                     if (size_t(it - prev) % 2) {
+                        break;
+                     }
+                     ++it; // skip the escaped quote
                   }
                   else {
-                     if (i > maximum) [[unlikely]] {
-                        ctx.error = error_code::parse_number_failure;
-                        return;
-                     }
-                     value = V(i);
+                     it += 8;
                   }
-                  it += (cur - beg);
                }
-            }
-            else {
-               if constexpr (is_float128<V>) {
-                  auto [ptr, ec] = std::from_chars(it, end, value);
-                  if (ec != std::errc()) {
-                     ctx.error = error_code::parse_number_failure;
+
+               auto n = size_t(it - start);
+               value.resize(n + string_padding_bytes);
+
+               auto* p = value.data();
+
+               while (true) {
+                  if (start >= it) {
+                     break;
+                  }
+
+                  std::memcpy(p, start, 8);
+                  uint64_t swar;
+                  std::memcpy(&swar, p, 8);
+
+                  constexpr uint64_t lo7_mask = repeat_byte8(0b01111111);
+                  const uint64_t lo7 = swar & lo7_mask;
+                  const uint64_t backslash = (lo7 ^ repeat_byte8('\\')) + lo7_mask;
+                  const uint64_t less_32 = (swar & repeat_byte8(0b01100000)) + lo7_mask;
+                  uint64_t next = ~((backslash & less_32) | swar);
+
+                  next &= repeat_byte8(0b10000000);
+                  if (next == 0) {
+                     start += 8;
+                     p += 8;
+                     continue;
+                  }
+
+                  next = countr_zero(next) >> 3;
+                  start += next;
+                  if (start >= it) {
+                     break;
+                  }
+
+                  if ((*start & 0b11100000) == 0) [[unlikely]] {
+                     ctx.error = error_code::syntax_error;
                      return;
                   }
-                  it = ptr;
-               }
-               else {
-                  if constexpr (std::is_volatile_v<std::remove_reference_t<decltype(value)>>) {
-                     // Hardware may interact with value changes, so we parse into a temporary and assign in one place
-                     V temp;
-                     auto s = parse_float<V, Opts.force_conformance>(temp, it);
-                     if (!s) [[unlikely]] {
-                        ctx.error = error_code::parse_number_failure;
+                  ++start; // skip the escape
+                  if (*start == 'u') {
+                     ++start;
+                     p += next;
+                     const auto mark = start;
+                     const auto offset = handle_unicode_code_point(start, p, end);
+                     if (offset == 0) [[unlikely]] {
+                        ctx.error = error_code::unicode_escape_conversion_failure;
                         return;
                      }
-                     value = temp;
+                     n += offset;
+                     // escape + u + unicode code points
+                     n -= 2 + uint32_t(start - mark);
                   }
                   else {
-                     auto s = parse_float<V, Opts.force_conformance>(value, it);
-                     if (!s) [[unlikely]] {
-                        ctx.error = error_code::parse_number_failure;
+                     p += next;
+                     *p = char_unescape_table[uint8_t(*start)];
+                     if (*p == 0) [[unlikely]] {
+                        ctx.error = error_code::invalid_escape;
                         return;
                      }
+                     ++p;
+                     ++start;
+                     --n;
                   }
                }
+
+               value.resize(n);
+               ++it;
             }
+            else {
+               // raw_string
+               auto start = it;
+               skip_string_view<Opts>(ctx, it, end);
+               if (bool(ctx.error)) [[unlikely]]
+                  return;
 
-            if constexpr (Opts.quoted_num) {
-               GLZ_MATCH_QUOTE;
+               value.assign(start, size_t(it - start));
+               ++it;
             }
          }
-      };
+      }
 
-      template <string_t T>
-      struct from_json<T>
+      template <auto Opts, class It, class End>
+         requires(not check_is_padded(Opts))
+      static void op(auto& value, is_context auto&& ctx, It&& it, End&& end)
       {
-         template <auto Opts, class It, class End>
-            requires(Opts.is_padded)
-         static void op(auto& value, is_context auto&& ctx, It&& it, End&& end) noexcept
-         {
-            if constexpr (Opts.number) {
-               auto start = it;
-               skip_number<Opts>(ctx, it, end);
-               if (bool(ctx.error)) [[unlikely]] {
-                  return;
-               }
-               value.append(start, size_t(it - start));
+         if constexpr (Opts.number) {
+            auto start = it;
+            skip_number<Opts>(ctx, it, end);
+            if (bool(ctx.error)) [[unlikely]] {
+               return;
             }
-            else {
-               if constexpr (!Opts.opening_handled) {
-                  if constexpr (!Opts.ws_handled) {
-                     GLZ_SKIP_WS;
+            if (start == it) [[unlikely]] {
+               ctx.error = error_code::parse_number_failure;
+               return;
+            }
+            value.append(start, size_t(it - start));
+         }
+         else {
+            if constexpr (!check_opening_handled(Opts)) {
+               if constexpr (!check_ws_handled(Opts)) {
+                  if (skip_ws<Opts>(ctx, it, end)) {
+                     return;
                   }
+               }
 
-                  GLZ_MATCH_QUOTE;
+               if (match_invalid_end<'"', Opts>(ctx, it, end)) {
+                  return;
                }
+            }
 
-               if constexpr (not Opts.raw_string) {
-                  auto& temp = string_decode_buffer();
-                  auto* p = temp.data();
-                  auto* p_end = p + temp.size() - padding_bytes;
+            if constexpr (not Opts.raw_string) {
+               static constexpr auto string_padding_bytes = 8;
 
+               if (size_t(end - it) >= 8) {
+                  auto start = it;
+                  const auto end8 = end - 8;
                   while (true) {
-                     if (p >= p_end) [[unlikely]] {
-                        // the rare case of running out of temp buffer
-                        const auto distance = size_t(p - temp.data());
-                        temp.resize(temp.size() * 2);
-                        p = temp.data() + distance; // reset p from new memory
-                        p_end = temp.data() + temp.size() - padding_bytes;
+                     if (it >= end8) [[unlikely]] {
+                        break;
+                     }
+
+                     uint64_t chunk;
+                     std::memcpy(&chunk, it, 8);
+                     const uint64_t test_chars = has_quote(chunk);
+                     if (test_chars) {
+                        it += (countr_zero(test_chars) >> 3);
+
+                        auto* prev = it - 1;
+                        while (*prev == '\\') {
+                           --prev;
+                        }
+                        if (size_t(it - prev) % 2) {
+                           goto continue_decode;
+                        }
+                        ++it; // skip the escaped quote
                      }
-                     std::memcpy(p, it, 8);
-                     uint64_t swar;
-                     std::memcpy(&swar, p, 8);
-
-                     constexpr uint64_t high_mask = repeat_byte8(0b10000000);
-                     constexpr uint64_t lo7_mask = repeat_byte8(0b01111111);
-                     const uint64_t hi = swar & high_mask;
-                     uint64_t next;
-                     if (hi == high_mask) {
-                        // unescaped unicode has all high bits set
+                     else {
                         it += 8;
-                        p += 8;
-                        continue;
                      }
-                     else if (hi == 0) {
-                        // we have only ascii
-                        const uint64_t quote = (swar ^ repeat_byte8('"')) + lo7_mask;
-                        const uint64_t backslash = (swar ^ repeat_byte8('\\')) + lo7_mask;
-                        const uint64_t less_32 = (swar & repeat_byte8(0b01100000)) + lo7_mask;
-                        next = ~(quote & backslash & less_32);
+                  }
+
+                  while (it[-1] == '\\') [[unlikely]] {
+                     // if we ended on an escape character then we need to rewind
+                     // because we lost our context
+                     --it;
+                  }
+
+                  for (; it < end; ++it) {
+                     if (*it == '"') {
+                        auto* prev = it - 1;
+                        while (*prev == '\\') {
+                           --prev;
+                        }
+                        if (size_t(it - prev) % 2) {
+                           goto continue_decode;
+                        }
                      }
-                     else {
+                  }
+
+                  ctx.error = error_code::unexpected_end;
+                  return;
+
+               continue_decode:
+
+                  const auto available_padding = size_t(end - it);
+                  auto n = size_t(it - start);
+                  if (available_padding >= 8) [[likely]] {
+                     value.resize(n + string_padding_bytes);
+
+                     auto* p = value.data();
+
+                     while (true) {
+                        if (start >= it) {
+                           break;
+                        }
+
+                        std::memcpy(p, start, 8);
+                        uint64_t swar;
+                        std::memcpy(&swar, p, 8);
+
+                        constexpr uint64_t lo7_mask = repeat_byte8(0b01111111);
                         const uint64_t lo7 = swar & lo7_mask;
-                        const uint64_t quote = (lo7 ^ repeat_byte8('"')) + lo7_mask;
                         const uint64_t backslash = (lo7 ^ repeat_byte8('\\')) + lo7_mask;
                         const uint64_t less_32 = (swar & repeat_byte8(0b01100000)) + lo7_mask;
-                        next = ~((quote & backslash & less_32) | swar);
-                     }
+                        uint64_t next = ~((backslash & less_32) | swar);
+
+                        next &= repeat_byte8(0b10000000);
+                        if (next == 0) {
+                           start += 8;
+                           p += 8;
+                           continue;
+                        }
 
-                     next &= repeat_byte8(0b10000000);
-                     if (next) {
                         next = countr_zero(next) >> 3;
-                        it += next;
-                        if (*it == '"') {
-                           value.assign(temp.data(), size_t((p + next) - temp.data()));
-                           ++it;
-                           return;
+                        start += next;
+                        if (start >= it) {
+                           break;
                         }
-                        if ((*it & 0b11100000) == 0) [[unlikely]] {
+
+                        if ((*start & 0b11100000) == 0) [[unlikely]] {
                            ctx.error = error_code::syntax_error;
                            return;
                         }
-                        ++it; // skip the escape
-                        if (*it == 'u') {
-                           ++it;
+                        ++start; // skip the escape
+                        if (*start == 'u') {
+                           ++start;
                            p += next;
-                           if (!handle_unicode_code_point(it, p)) [[unlikely]] {
+                           const auto mark = start;
+                           const auto offset = handle_unicode_code_point(start, p, end);
+                           if (offset == 0) [[unlikely]] {
                               ctx.error = error_code::unicode_escape_conversion_failure;
                               return;
                            }
+                           n += offset;
+                           // escape + u + unicode code points
+                           n -= 2 + uint32_t(start - mark);
                         }
                         else {
                            p += next;
-                           *p = char_unescape_table[*it];
+                           *p = char_unescape_table[uint8_t(*start)];
                            if (*p == 0) [[unlikely]] {
                               ctx.error = error_code::invalid_escape;
                               return;
                            }
                            ++p;
-                           ++it;
+                           ++start;
+                           --n;
                         }
                      }
-                     else {
-                        it += 8;
-                        p += 8;
-                     }
-                  }
-               }
-               else {
-                  // raw_string
-                  auto start = it;
-                  skip_string_view<Opts>(ctx, it, end);
-                  if (bool(ctx.error)) [[unlikely]]
-                     return;
-
-                  value.assign(start, size_t(it - start));
-                  ++it;
-               }
-            }
-         }
 
-         template <auto Opts, class It, class End>
-            requires(not Opts.is_padded)
-         GLZ_ALWAYS_INLINE static void op(auto& value, is_context auto&& ctx, It&& it, End&& end) noexcept
-         {
-            if constexpr (Opts.number) {
-               auto start = it;
-               skip_number<Opts>(ctx, it, end);
-               if (bool(ctx.error)) [[unlikely]] {
-                  return;
-               }
-               value.append(start, size_t(it - start));
-            }
-            else {
-               if constexpr (!Opts.opening_handled) {
-                  if constexpr (!Opts.ws_handled) {
-                     GLZ_SKIP_WS;
+                     value.resize(n);
+                     ++it;
                   }
+                  else {
+                     // For large inputs this case of running out of buffer is very rare
+                     value.resize(n);
+                     auto* p = value.data();
 
-                  GLZ_MATCH_QUOTE;
-               }
-
-               if constexpr (not Opts.raw_string) {
-                  auto& temp = string_decode_buffer();
-                  auto* p = temp.data();
-
-                  if (size_t(end - it) > 11) {
-                     // A surrogate pair unicode code point may require 12 characters
-                     // So we need to have this much space available in our read buffer
-                     const auto end12 = end - 12;
-                     auto* p_end = p + temp.size() - padding_bytes;
-
-                     while (true) {
-                        if (p >= p_end) [[unlikely]] {
-                           // the rare case of running out of temp buffer
-                           const auto distance = size_t(p - temp.data());
-                           temp.resize(temp.size() * 2);
-                           p = temp.data() + distance; // reset p from new memory
-                           p_end = temp.data() + temp.size() - padding_bytes;
-                        }
-                        if (it > end12) {
-                           break;
+                     it = start;
+                     while (it < end) [[likely]] {
+                        if (*it == '"') {
+                           value.resize(size_t(p - value.data()));
+                           ++it;
+                           return;
                         }
-                        std::memcpy(p, it, 8);
-                        uint64_t swar;
-                        std::memcpy(&swar, p, 8);
 
-                        constexpr uint64_t high_mask = repeat_byte8(0b10000000);
-                        constexpr uint64_t lo7_mask = repeat_byte8(0b01111111);
-                        const uint64_t hi = swar & high_mask;
-                        uint64_t next;
-                        if (hi == high_mask) {
-                           // unescaped unicode has all high bits set
-                           it += 8;
-                           p += 8;
-                           continue;
-                        }
-                        else if (hi == 0) {
-                           // we have only ascii
-                           const uint64_t quote = (swar ^ repeat_byte8('"')) + lo7_mask;
-                           const uint64_t backslash = (swar ^ repeat_byte8('\\')) + lo7_mask;
-                           const uint64_t less_32 = (swar & repeat_byte8(0b01100000)) + lo7_mask;
-                           next = ~(quote & backslash & less_32);
-                        }
-                        else {
-                           const uint64_t lo7 = swar & lo7_mask;
-                           const uint64_t quote = (lo7 ^ repeat_byte8('"')) + lo7_mask;
-                           const uint64_t backslash = (lo7 ^ repeat_byte8('\\')) + lo7_mask;
-                           const uint64_t less_32 = (swar & repeat_byte8(0b01100000)) + lo7_mask;
-                           next = ~((quote & backslash & less_32) | swar);
-                        }
+                        *p = *it;
 
-                        next &= repeat_byte8(0b10000000);
-                        if (next) {
-                           next = countr_zero(next) >> 3;
-                           it += next;
-                           if (*it == '"') {
-                              value.assign(temp.data(), size_t((p + next) - temp.data()));
-                              ++it;
-                              return;
-                           }
-                           if ((*it & 0b11100000) == 0) [[unlikely]] {
-                              ctx.error = error_code::syntax_error;
-                              return;
-                           }
+                        if (*it == '\\') {
                            ++it; // skip the escape
                            if (*it == 'u') {
                               ++it;
-                              p += next;
-                              if (!handle_unicode_code_point(it, p)) [[unlikely]] {
+                              if (!handle_unicode_code_point(it, p, end)) [[unlikely]] {
                                  ctx.error = error_code::unicode_escape_conversion_failure;
                                  return;
                               }
                            }
                            else {
-                              p += next;
-                              *p = char_unescape_table[*it];
+                              *p = char_unescape_table[uint8_t(*it)];
                               if (*p == 0) [[unlikely]] {
                                  ctx.error = error_code::invalid_escape;
                                  return;
@@ -701,38 +1022,57 @@ namespace glz
                            }
                         }
                         else {
-                           it += 8;
-                           p += 8;
+                           ++it;
+                           ++p;
                         }
                      }
 
-                     // we know we won't run out of space in our temp buffer because we subtract padding_bytes
-                     while (it[-1] == '\\') [[unlikely]] {
-                        // if we ended on an escape character then we need to rewind
-                        // because we lost our context
-                        --it;
-                        --p;
-                     }
+                     ctx.error = error_code::unexpected_end;
                   }
+               }
+               else {
+                  // For short strings
+
+                  std::array<char, 8> buffer{};
+
+                  auto* p = buffer.data();
 
                   while (it < end) [[likely]] {
                      *p = *it;
                      if (*it == '"') {
-                        value.assign(temp.data(), size_t(p - temp.data()));
+                        value.assign(buffer.data(), size_t(p - buffer.data()));
                         ++it;
+                        if constexpr (not Opts.null_terminated) {
+                           if (it == end) {
+                              ctx.error = error_code::end_reached;
+                              return;
+                           }
+                        }
                         return;
                      }
                      else if (*it == '\\') {
                         ++it; // skip the escape
+                        if constexpr (not Opts.null_terminated) {
+                           if (it == end) [[unlikely]] {
+                              ctx.error = error_code::unexpected_end;
+                              return;
+                           }
+                        }
                         if (*it == 'u') {
                            ++it;
+                           if constexpr (not Opts.null_terminated) {
+                              if (it == end) [[unlikely]] {
+                                 ctx.error = error_code::unexpected_end;
+                                 return;
+                              }
+                           }
                            if (!handle_unicode_code_point(it, p, end)) [[unlikely]] {
                               ctx.error = error_code::unicode_escape_conversion_failure;
                               return;
                            }
                         }
                         else {
-                           *p = char_unescape_table[*it];
+                           *p = char_unescape_table[uint8_t(*it)];
                            if (*p == 0) [[unlikely]] {
                               ctx.error = error_code::invalid_escape;
                               return;
@@ -749,291 +1089,408 @@ namespace glz
 
                   ctx.error = error_code::unexpected_end;
                }
-               else {
-                  // raw_string
-                  auto start = it;
-                  skip_string_view<Opts>(ctx, it, end);
-                  if (bool(ctx.error)) [[unlikely]]
-                     return;
+            }
+            else {
+               // raw_string
+               auto start = it;
+               skip_string_view<Opts>(ctx, it, end);
+               if (bool(ctx.error)) [[unlikely]]
+                  return;
 
-                  value.assign(start, size_t(it - start));
-                  ++it;
-               }
+               value.assign(start, size_t(it - start));
+               ++it;
             }
          }
-      };
+      }
+   };
 
-      template <class T>
-         requires(string_view_t<T> || char_array_t<T>)
-      struct from_json<T>
+   template <class T>
+      requires(string_view_t<T> || char_array_t<T> || array_char_t<T> || static_string_t<T>)
+   struct from<JSON, T>
+   {
+      template <auto Opts, class It, class End>
+      GLZ_ALWAYS_INLINE static void op(auto& value, is_context auto&& ctx, It&& it, End&& end) noexcept
       {
-         template <auto Opts, class It, class End>
-         GLZ_ALWAYS_INLINE static void op(auto& value, is_context auto&& ctx, It&& it, End&& end) noexcept
-         {
-            if constexpr (!Opts.opening_handled) {
-               if constexpr (!Opts.ws_handled) {
-                  GLZ_SKIP_WS;
+         if constexpr (!check_opening_handled(Opts)) {
+            if constexpr (!check_ws_handled(Opts)) {
+               if (skip_ws<Opts>(ctx, it, end)) {
+                  return;
                }
+            }
 
-               GLZ_MATCH_QUOTE;
+            if (match_invalid_end<'"', Opts>(ctx, it, end)) {
+               return;
             }
+         }
 
-            auto start = it;
+         auto start = it;
+         skip_string_view<Opts>(ctx, it, end);
+         if (bool(ctx.error)) [[unlikely]]
+            return;
 
-            if constexpr (string_view_t<T>) {
-               skip_string_view<Opts>(ctx, it, end);
-               if (bool(ctx.error)) [[unlikely]]
-                  return;
-               value = {start, size_t(it - start)};
-               ++it; // skip closing quote
+         if constexpr (string_view_t<T>) {
+            value = {start, size_t(it - start)};
+         }
+         else if constexpr (char_array_t<T>) {
+            const size_t n = it - start;
+            if ((n + 1) > sizeof(value)) {
+               ctx.error = error_code::unexpected_end;
+               return;
             }
-            else if constexpr (char_array_t<T>) {
-               skip_string_view<Opts>(ctx, it, end);
-               if (bool(ctx.error)) [[unlikely]]
-                  return;
-
-               const size_t n = it - start;
-               if ((sizeof(value) - 1) < n) {
-                  ctx.error = error_code::unexpected_end;
-                  return;
-               }
-               std::memcpy(value, start, n);
-               value[n] = '\0';
-               ++it; // skip closing quote
+            std::memcpy(value, start, n);
+            value[n] = '\0';
+         }
+         else if constexpr (array_char_t<T>) {
+            const size_t n = it - start;
+            if ((n + 1) > value.size()) {
+               ctx.error = error_code::unexpected_end;
+               return;
+            }
+            std::memcpy(value.data(), start, n);
+            value[n] = '\0';
+         }
+         else if constexpr (static_string_t<T>) {
+            const size_t n = it - start;
+            if (n > value.capacity()) {
+               ctx.error = error_code::unexpected_end;
+               return;
+            }
+            value.assign(start, n);
+         }
+         ++it; // skip closing quote
+         if constexpr (not Opts.null_terminated) {
+            if (it == end) {
+               ctx.error = error_code::end_reached;
+               return;
             }
          }
-      };
+      }
+   };
 
-      template <char_t T>
-      struct from_json<T>
+   template <char_t T>
+   struct from<JSON, T>
+   {
+      template <auto Opts>
+      static void op(auto& value, is_context auto&& ctx, auto&& it, auto&& end) noexcept
       {
-         template <auto Opts>
-         GLZ_ALWAYS_INLINE static void op(auto& value, is_context auto&& ctx, auto&& it, auto&& end) noexcept
-         {
-            if constexpr (!Opts.opening_handled) {
-               if constexpr (!Opts.ws_handled) {
-                  GLZ_SKIP_WS;
+         if constexpr (!check_opening_handled(Opts)) {
+            if constexpr (!check_ws_handled(Opts)) {
+               if (skip_ws<Opts>(ctx, it, end)) {
+                  return;
                }
+            }
 
-               GLZ_MATCH_QUOTE;
+            if (match_invalid_end<'"', Opts>(ctx, it, end)) {
+               return;
             }
+         }
 
-            if (*it == '\\') [[unlikely]] {
-               ++it;
-               switch (*it) {
-               case '\0': {
-                  ctx.error = error_code::unexpected_end;
-                  return;
-               }
-               case '"':
-               case '\\':
-               case '/':
-                  value = *it++;
-                  break;
-               case 'b':
-                  value = '\b';
-                  ++it;
-                  break;
-               case 'f':
-                  value = '\f';
-                  ++it;
-                  break;
-               case 'n':
-                  value = '\n';
-                  ++it;
-                  break;
-               case 'r':
-                  value = '\r';
-                  ++it;
-                  break;
-               case 't':
-                  value = '\t';
-                  ++it;
-                  break;
-               case 'u': {
-                  ctx.error = error_code::unicode_escape_conversion_failure;
-                  return;
-               }
-               default: {
-                  ctx.error = error_code::invalid_escape;
-                  return;
-               }
-               }
+         if (*it == '\\') [[unlikely]] {
+            ++it;
+            switch (*it) {
+            case '\0': {
+               ctx.error = error_code::unexpected_end;
+               return;
             }
-            else {
-               if (it == end) [[unlikely]] {
-                  ctx.error = error_code::unexpected_end;
-                  return;
-               }
+            case '"':
+            case '\\':
+            case '/':
                value = *it++;
+               break;
+            case 'b':
+               value = '\b';
+               ++it;
+               break;
+            case 'f':
+               value = '\f';
+               ++it;
+               break;
+            case 'n':
+               value = '\n';
+               ++it;
+               break;
+            case 'r':
+               value = '\r';
+               ++it;
+               break;
+            case 't':
+               value = '\t';
+               ++it;
+               break;
+            case 'u': {
+               ctx.error = error_code::unicode_escape_conversion_failure;
+               return;
+            }
+            default: {
+               ctx.error = error_code::invalid_escape;
+               return;
+            }
+            }
+         }
+         else {
+            if (it == end) [[unlikely]] {
+               ctx.error = error_code::unexpected_end;
+               return;
+            }
+            value = *it++;
+         }
+         if constexpr (not Opts.null_terminated) {
+            if (it == end) [[unlikely]] {
+               ctx.error = error_code::unexpected_end;
+               return;
+            }
+         }
+         if (match<'"'>(ctx, it)) {
+            return;
+         }
+         if constexpr (not Opts.null_terminated) {
+            if (it == end) {
+               ctx.error = error_code::end_reached;
+               return;
             }
-            GLZ_MATCH_QUOTE;
          }
-      };
+      }
+   };
 
-      template <class T>
-         requires(glaze_enum_t<T> && !custom_read<T>)
-      struct from_json<T>
+   template <class T>
+      requires(is_named_enum<T>)
+   struct from<JSON, T>
+   {
+      template <auto Opts>
+      static void op(auto& value, is_context auto&& ctx, auto&& it, auto&& end) noexcept
       {
-         template <auto Opts>
-         static void op(auto& value, is_context auto&& ctx, auto&& it, auto&& end) noexcept
-         {
-            if constexpr (!Opts.ws_handled) {
-               GLZ_SKIP_WS;
+         if constexpr (!check_ws_handled(Opts)) {
+            if (skip_ws<Opts>(ctx, it, end)) {
+               return;
             }
+         }
 
-            const auto key = parse_key(ctx, it, end); // TODO: Use more optimal enum key parsing
-            if (bool(ctx.error)) [[unlikely]]
-               return;
+         constexpr auto N = reflect<T>::size;
 
-            static constexpr auto frozen_map = detail::make_string_to_enum_map<T>();
-            const auto& member_it = frozen_map.find(key);
-            if (member_it != frozen_map.end()) {
-               value = member_it->second;
+         if (*it != '"') [[unlikely]] {
+            ctx.error = error_code::expected_quote;
+            return;
+         }
+         ++it;
+         if constexpr (not Opts.null_terminated) {
+            if (it == end) [[unlikely]] {
+               ctx.error = error_code::unexpected_end;
+               return;
             }
-            else [[unlikely]] {
+         }
+
+         if constexpr (N == 1) {
+            decode_index<Opts, T, 0>(value, ctx, it, end);
+         }
+         else {
+            static constexpr auto HashInfo = hash_info<T>;
+
+            const auto index = decode_hash<JSON, T, HashInfo, HashInfo.type>::op(it, end);
+
+            if (index >= N) [[unlikely]] {
                ctx.error = error_code::unexpected_enum;
+               return;
             }
+
+            visit<N>([&]<size_t I>() { decode_index<Opts, T, I>(value, ctx, it, end); }, index);
          }
-      };
+      }
+   };
 
-      template <class T>
-         requires(std::is_enum_v<T> && !glaze_enum_t<T> && !custom_read<T>)
-      struct from_json<T>
+   template <class T>
+      requires(std::is_enum_v<T> && !glaze_enum_t<T> && !meta_keys<T> && !custom_read<T>)
+   struct from<JSON, T>
+   {
+      template <auto Opts>
+      static void op(auto& value, is_context auto&& ctx, auto&& it, auto&& end) noexcept
       {
-         template <auto Opts>
-         GLZ_ALWAYS_INLINE static void op(auto& value, is_context auto&& ctx, auto&& it, auto&& end) noexcept
-         {
-            // read<json>::op<Opts>(*reinterpret_cast<std::underlying_type_t<std::decay_t<decltype(value)>>*>(&value),
-            // ctx, it, end);
-            std::underlying_type_t<std::decay_t<T>> x{};
-            read<json>::op<Opts>(x, ctx, it, end);
-            value = static_cast<std::decay_t<T>>(x);
-         }
-      };
-
-      template <func_t T>
-      struct from_json<T>
+         // TODO: use std::bit_cast???
+         std::underlying_type_t<std::decay_t<T>> x{};
+         parse<JSON>::op<Opts>(x, ctx, it, end);
+         value = static_cast<std::decay_t<T>>(x);
+      }
+   };
+
+   template <func_t T>
+   struct from<JSON, T>
+   {
+      template <auto Opts>
+      static void op(auto& /*value*/, is_context auto&& ctx, auto&& it, auto&& end)
       {
-         template <auto Opts>
-         static void op(auto& /*value*/, is_context auto&& ctx, auto&& it, auto&& end) noexcept
-         {
-            if constexpr (!Opts.ws_handled) {
-               GLZ_SKIP_WS;
+         if constexpr (!check_ws_handled(Opts)) {
+            if (skip_ws<Opts>(ctx, it, end)) {
+               return;
             }
-            GLZ_MATCH_QUOTE;
-            skip_string_view<Opts>(ctx, it, end);
-            if (bool(ctx.error)) [[unlikely]]
+         }
+         if (match_invalid_end<'"', Opts>(ctx, it, end)) {
+            return;
+         }
+         skip_string_view<Opts>(ctx, it, end);
+         if (bool(ctx.error)) [[unlikely]]
+            return;
+         if (match<'"'>(ctx, it)) {
+            return;
+         }
+         if constexpr (not Opts.null_terminated) {
+            if (it == end) {
+               ctx.error = error_code::end_reached;
                return;
-            GLZ_MATCH_QUOTE;
+            }
          }
-      };
+      }
+   };
 
-      template <class T>
-      struct from_json<basic_raw_json<T>>
+   template <class T>
+   struct from<JSON, basic_raw_json<T>>
+   {
+      template <auto Opts>
+      GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, auto&& it, auto&& end)
       {
-         template <auto Opts>
-         GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, auto&& it, auto&& end) noexcept
-         {
-            auto it_start = it;
-            skip_value<Opts>(ctx, it, end);
-            if (bool(ctx.error)) [[unlikely]]
-               return;
-            value.str = {it_start, static_cast<size_t>(it - it_start)};
+         auto it_start = it;
+         if (*it == 'n') {
+            match<"null", Opts>(ctx, it, end);
+         }
+         else if (is_digit(uint8_t(*it))) {
+            skip_number<Opts>(ctx, it, end);
+         }
+         else {
+            skip_value<JSON>::op<Opts>(ctx, it, end);
          }
-      };
+         if (bool(ctx.error)) [[unlikely]]
+            return;
+         value.str = {it_start, static_cast<size_t>(it - it_start)};
+      }
+   };
 
-      template <class T>
-      struct from_json<basic_text<T>>
+   template <class T>
+   struct from<JSON, basic_text<T>>
+   {
+      template <auto Opts>
+      GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&&, auto&& it, auto&& end)
       {
-         template <auto Opts>
-         GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&&, auto&& it, auto&& end) noexcept
-         {
-            value.str = {it, static_cast<size_t>(end - it)}; // read entire contents as string
-            it = end;
-         }
-      };
-
-      // for set types
-      template <class T>
-         requires(readable_array_t<T> && !emplace_backable<T> && !resizable<T> && emplaceable<T>)
-      struct from_json<T>
+         value.str = {it, static_cast<size_t>(end - it)}; // read entire contents as string
+         it = end;
+      }
+   };
+
+   // for set types
+   template <class T>
+      requires(readable_array_t<T> && !emplace_backable<T> && !resizable<T> && emplaceable<T>)
+   struct from<JSON, T>
+   {
+      template <auto Options>
+      static void op(auto& value, is_context auto&& ctx, auto&& it, auto&& end)
       {
-         template <auto Options>
-         static void op(auto& value, is_context auto&& ctx, auto&& it, auto&& end) noexcept
-         {
-            constexpr auto Opts = ws_handled_off<Options>();
-            if constexpr (!Options.ws_handled) {
-               GLZ_SKIP_WS;
+         constexpr auto Opts = ws_handled_off<Options>();
+         if constexpr (!check_ws_handled(Options)) {
+            if (skip_ws<Opts>(ctx, it, end)) {
+               return;
             }
+         }
 
-            GLZ_MATCH_OPEN_BRACKET;
-            GLZ_SKIP_WS;
+         if (match_invalid_end<'[', Opts>(ctx, it, end)) {
+            return;
+         }
+         if constexpr (not Opts.null_terminated) {
+            ++ctx.indentation_level;
+         }
+         if (skip_ws<Opts>(ctx, it, end)) {
+            return;
+         }
 
-            value.clear();
-            if (*it == ']') [[unlikely]] {
-               ++it;
-               return;
+         value.clear();
+         if (*it == ']') [[unlikely]] {
+            if constexpr (not Opts.null_terminated) {
+               --ctx.indentation_level;
             }
+            ++it;
+            return;
+         }
 
-            while (true) {
-               using V = range_value_t<T>;
-               V v;
-               read<json>::op<Opts>(v, ctx, it, end);
-               if (bool(ctx.error)) [[unlikely]]
-                  return;
-               value.emplace(std::move(v));
-               GLZ_SKIP_WS;
-               if (*it == ']') {
-                  ++it;
-                  return;
+         while (true) {
+            using V = range_value_t<T>;
+            V v;
+            parse<JSON>::op<Opts>(v, ctx, it, end);
+            if (bool(ctx.error)) [[unlikely]]
+               return;
+            value.emplace(std::move(v));
+            if (skip_ws<Opts>(ctx, it, end)) {
+               return;
+            }
+            if (*it == ']') {
+               if constexpr (not Opts.null_terminated) {
+                  --ctx.indentation_level;
                }
-               GLZ_MATCH_COMMA;
+               ++it;
+               return;
+            }
+            if (match_invalid_end<',', Opts>(ctx, it, end)) {
+               return;
+            }
+            if (skip_ws<Opts>(ctx, it, end)) {
+               return;
             }
          }
-      };
+      }
+   };
 
-      // for types like std::vector, std::array, std::deque, etc.
-      template <class T>
-         requires(readable_array_t<T> && (emplace_backable<T> || !resizable<T>) && !emplaceable<T>)
-      struct from_json<T>
+   // for types like std::vector, std::array, std::deque, etc.
+   template <class T>
+      requires(readable_array_t<T> && (emplace_backable<T> || is_inplace_vector<T> || !resizable<T>) && !emplaceable<T>)
+   struct from<JSON, T>
+   {
+      template <auto Options>
+      static void op(auto&& value, is_context auto&& ctx, auto&& it, auto&& end)
       {
-         template <auto Options>
-         static void op(auto&& value, is_context auto&& ctx, auto&& it, auto&& end) noexcept
-         {
-            constexpr auto Opts = ws_handled_off<Options>();
-            if constexpr (!Options.ws_handled) {
-               GLZ_SKIP_WS;
+         constexpr auto Opts = ws_handled_off<Options>();
+         if constexpr (!check_ws_handled(Options)) {
+            if (skip_ws<Opts>(ctx, it, end)) {
+               return;
             }
+         }
 
-            GLZ_MATCH_OPEN_BRACKET;
+         if (match_invalid_end<'[', Opts>(ctx, it, end)) {
+            return;
+         }
+         if constexpr (not Opts.null_terminated) {
+            ++ctx.indentation_level;
+         }
 
-            const auto ws_start = it;
-            GLZ_SKIP_WS;
+         const auto ws_start = it;
+         if (skip_ws<Opts>(ctx, it, end)) {
+            return;
+         }
 
-            if (*it == ']') {
-               ++it;
-               if constexpr (resizable<T>) {
-                  value.clear();
+         if (*it == ']') {
+            if constexpr (not Opts.null_terminated) {
+               --ctx.indentation_level;
+            }
+            ++it;
+            if constexpr ((resizable<T> || is_inplace_vector<T>) && not Opts.append_arrays) {
+               value.clear();
 
-                  if constexpr (Opts.shrink_to_fit) {
-                     value.shrink_to_fit();
-                  }
+               if constexpr (check_shrink_to_fit(Opts)) {
+                  value.shrink_to_fit();
                }
-               return;
             }
+            return;
+         }
 
-            const size_t ws_size = size_t(it - ws_start);
+         const size_t ws_size = size_t(it - ws_start);
 
+         static constexpr bool should_append = (resizable<T> || is_inplace_vector<T>) && Opts.append_arrays;
+         if constexpr (not should_append) {
             const auto n = value.size();
 
             auto value_it = value.begin();
 
             for (size_t i = 0; i < n; ++i) {
-               read<json>::op<ws_handled<Opts>()>(*value_it++, ctx, it, end);
+               parse<JSON>::op<ws_handled<Opts>()>(*value_it++, ctx, it, end);
                if (bool(ctx.error)) [[unlikely]]
                   return;
-               GLZ_SKIP_WS;
+               if (skip_ws<Opts>(ctx, it, end)) {
+                  return;
+               }
                if (*it == ',') {
                   ++it;
 
@@ -1043,15 +1500,20 @@ namespace glz
                      }
                   }
 
-                  GLZ_SKIP_WS;
+                  if (skip_ws<Opts>(ctx, it, end)) {
+                     return;
+                  }
                }
                else if (*it == ']') {
+                  if constexpr (not Opts.null_terminated) {
+                     --ctx.indentation_level;
+                  }
                   ++it;
                   if constexpr (erasable<T>) {
                      value.erase(value_it,
                                  value.end()); // use erase rather than resize for non-default constructible elements
 
-                     if constexpr (Opts.shrink_to_fit) {
+                     if constexpr (check_shrink_to_fit(Opts)) {
                         value.shrink_to_fit();
                      }
                   }
@@ -1062,735 +1524,781 @@ namespace glz
                   return;
                }
             }
+         }
 
-            if constexpr (Opts.partial_read) {
-               return;
-            }
-            else {
-               // growing
-               if constexpr (emplace_backable<T>) {
-                  // This optimization is useful when a std::vector contains large types (greater than 4096 bytes)
-                  // It is faster to simply use emplace_back for small types and reasonably lengthed vectors
-                  // (less than a million elements)
-                  // https://baptiste-wicht.com/posts/2012/12/cpp-benchmark-vector-list-deque.html
-                  if constexpr (has_reserve<T> && has_capacity<T> &&
-                                requires { requires(sizeof(typename T::value_type) > 4096); }) {
-                     // If we can reserve memmory, like std::vector, then we want to check the capacity
-                     // and use a temporary buffer if the capacity needs to grow
-                     if (value.capacity() == 0) {
-                        value.reserve(1); // we want to directly use our vector for the first element
-                     }
-                     const auto capacity = value.capacity();
-                     for (size_t i = value.size(); i < capacity; ++i) {
-                        // emplace_back while we have capacity
-                        read<json>::op<ws_handled<Opts>()>(value.emplace_back(), ctx, it, end);
-                        if (bool(ctx.error)) [[unlikely]]
-                           return;
-                        GLZ_SKIP_WS;
-                        if (*it == ',') [[likely]] {
-                           ++it;
-
-                           if constexpr (!Opts.minified) {
-                              if (ws_size && ws_size < size_t(end - it)) {
-                                 skip_matching_ws(ws_start, it, ws_size);
-                              }
-                           }
-
-                           GLZ_SKIP_WS;
-                        }
-                        else if (*it == ']') {
-                           ++it;
-                           return;
-                        }
-                        else [[unlikely]] {
-                           ctx.error = error_code::expected_bracket;
-                           return;
-                        }
-                     }
-
-                     using value_type = typename T::value_type;
-
-                     std::vector<std::vector<value_type>> intermediate;
-                     intermediate.reserve(48);
-                     auto* active = &intermediate.emplace_back();
-                     active->reserve(2);
-                     while (it < end) {
-                        if (active->size() == active->capacity()) {
-                           // we want to populate the next vector
-                           const auto former_capacity = active->capacity();
-                           active = &intermediate.emplace_back();
-                           active->reserve(2 * former_capacity);
-                        }
-
-                        read<json>::op<ws_handled<Opts>()>(active->emplace_back(), ctx, it, end);
-                        if (bool(ctx.error)) [[unlikely]]
-                           return;
-                        GLZ_SKIP_WS;
-                        if (*it == ',') [[likely]] {
-                           ++it;
+         if constexpr (Opts.partial_read) {
+            return;
+         }
+         else {
+            // growing
+            if constexpr (emplace_backable<T> || has_try_emplace_back<T>) {
+               while (it < end) {
+                  if constexpr (has_try_emplace_back<T>) {
+                     if (value.try_emplace_back() != nullptr)
+                        parse<JSON>::op<ws_handled<Opts>()>(value.back(), ctx, it, end);
+                     else
+                        ctx.error = error_code::exceeded_static_array_size;
+                  }
+                  else {
+                     parse<JSON>::op<ws_handled<Opts>()>(value.emplace_back(), ctx, it, end);
+                  }
 
-                           if constexpr (!Opts.minified) {
-                              if (ws_size && ws_size < size_t(end - it)) {
-                                 skip_matching_ws(ws_start, it, ws_size);
-                              }
-                           }
+                  if (bool(ctx.error)) [[unlikely]]
+                     return;
+                  if (skip_ws<Opts>(ctx, it, end)) {
+                     return;
+                  }
+                  if (*it == ',') [[likely]] {
+                     ++it;
 
-                           GLZ_SKIP_WS;
-                        }
-                        else if (*it == ']') {
-                           ++it;
-                           break;
-                        }
-                        else [[unlikely]] {
-                           ctx.error = error_code::expected_bracket;
-                           return;
+                     if constexpr (!Opts.minified) {
+                        if (ws_size && ws_size < size_t(end - it)) {
+                           skip_matching_ws(ws_start, it, ws_size);
                         }
                      }
 
-                     const auto intermediate_size = intermediate.size();
-                     size_t reserve_size = value.size();
-                     for (size_t i = 0; i < intermediate_size; ++i) {
-                        reserve_size += intermediate[i].size();
-                     }
-
-                     if constexpr (std::is_trivially_copyable_v<value_type> && !std::same_as<T, std::vector<bool>>) {
-                        const auto original_size = value.size();
-                        value.resize(reserve_size);
-                        auto* dest = value.data() + original_size;
-                        for (const auto& vector : intermediate) {
-                           const auto vector_size = vector.size();
-                           std::memcpy(dest, vector.data(), vector_size * sizeof(value_type));
-                           dest += vector_size;
-                        }
-                     }
-                     else {
-                        value.reserve(reserve_size);
-                        for (const auto& vector : intermediate) {
-                           const auto inter_end = vector.end();
-                           for (auto inter = vector.begin(); inter < inter_end; ++inter) {
-                              value.emplace_back(std::move(*inter));
-                           }
-                        }
+                     if (skip_ws<Opts>(ctx, it, end)) {
+                        return;
                      }
                   }
-                  else {
-                     // If we don't have reserve (like std::deque) or we have small sized elements
-                     while (it < end) {
-                        read<json>::op<ws_handled<Opts>()>(value.emplace_back(), ctx, it, end);
-                        if (bool(ctx.error)) [[unlikely]]
-                           return;
-                        GLZ_SKIP_WS;
-                        if (*it == ',') [[likely]] {
-                           ++it;
-
-                           if constexpr (!Opts.minified) {
-                              if (ws_size && ws_size < size_t(end - it)) {
-                                 skip_matching_ws(ws_start, it, ws_size);
-                              }
-                           }
-
-                           GLZ_SKIP_WS;
-                        }
-                        else if (*it == ']') {
-                           ++it;
-                           return;
-                        }
-                        else [[unlikely]] {
-                           ctx.error = error_code::expected_bracket;
-                           return;
-                        }
+                  else if (*it == ']') {
+                     if constexpr (not Opts.null_terminated) {
+                        --ctx.indentation_level;
                      }
+                     ++it;
+                     return;
+                  }
+                  else [[unlikely]] {
+                     ctx.error = error_code::expected_bracket;
+                     return;
                   }
                }
-               else {
-                  ctx.error = error_code::exceeded_static_array_size;
-               }
-            }
-         }
-      };
-
-      // counts the number of JSON array elements
-      // needed for classes that are resizable, but do not have an emplace_back
-      // 'it' is copied so that it does not actually progress the iterator
-      // expects the opening brace ([) to have already been consumed
-      template <auto Opts>
-      [[nodiscard]] GLZ_ALWAYS_INLINE size_t number_of_array_elements(is_context auto&& ctx, auto it,
-                                                                      auto&& end) noexcept
-      {
-         skip_ws<Opts>(ctx, it, end);
-         if (bool(ctx.error)) [[unlikely]]
-            return {};
-
-         if (*it == ']') [[unlikely]] {
-            return 0;
-         }
-         size_t count = 1;
-         while (true) {
-            switch (*it) {
-            case ',': {
-               ++count;
-               ++it;
-               break;
-            }
-            case '/': {
-               skip_comment(ctx, it, end);
-               if (bool(ctx.error)) [[unlikely]]
-                  return {};
-               break;
-            }
-            case '{':
-               ++it;
-               skip_until_closed<Opts, '{', '}'>(ctx, it, end);
-               if (bool(ctx.error)) [[unlikely]]
-                  return {};
-               break;
-            case '[':
-               ++it;
-               skip_until_closed<Opts, '[', ']'>(ctx, it, end);
-               if (bool(ctx.error)) [[unlikely]]
-                  return {};
-               break;
-            case '"': {
-               skip_string<Opts>(ctx, it, end);
-               if (bool(ctx.error)) [[unlikely]]
-                  return {};
-               break;
-            }
-            case ']': {
-               return count;
-            }
-            case '\0': {
-               ctx.error = error_code::unexpected_end;
-               return {};
             }
-            default:
-               ++it;
+            else {
+               ctx.error = error_code::exceeded_static_array_size;
             }
          }
-         unreachable();
       }
 
-      // For types like std::forward_list
-      template <class T>
-         requires readable_array_t<T> && (!emplace_backable<T> && resizable<T>)
-      struct from_json<T>
+      // for types like std::vector<std::pair...> that can't look up with operator[]
+      // Intead of hashing or linear searching, we just clear the input and overwrite the entire contents
+      template <auto Options>
+         requires(pair_t<range_value_t<T>> && check_concatenate(Options) == true)
+      static void op(auto&& value, is_context auto&& ctx, auto&& it, auto&& end)
       {
-         template <auto Options>
-         static void op(auto& value, is_context auto&& ctx, auto&& it, auto&& end) noexcept
-         {
-            constexpr auto Opts = ws_handled_off<Options>();
-            if constexpr (!Options.ws_handled) {
-               GLZ_SKIP_WS;
+         static constexpr auto Opts = opening_handled_off<ws_handled_off<Options>()>();
+         if constexpr (!check_opening_handled(Options)) {
+            if constexpr (!check_ws_handled(Options)) {
+               if (skip_ws<Opts>(ctx, it, end)) {
+                  return;
+               }
             }
-
-            GLZ_MATCH_OPEN_BRACKET;
-            const auto n = number_of_array_elements<Opts>(ctx, it, end);
-            if (bool(ctx.error)) [[unlikely]]
+            if (match_invalid_end<'{', Opts>(ctx, it, end)) {
                return;
-            value.resize(n);
-            size_t i = 0;
-            for (auto& x : value) {
-               read<json>::op<Opts>(x, ctx, it, end);
-               if (bool(ctx.error)) [[unlikely]]
+            }
+            if constexpr (not Opts.null_terminated) {
+               if (it == end) [[unlikely]] {
+                  ctx.error = error_code::unexpected_end;
                   return;
-
-               GLZ_SKIP_WS;
-               if (i < n - 1) {
-                  GLZ_MATCH_COMMA;
                }
-               ++i;
             }
-            match<']'>(ctx, it);
+            if constexpr (not Opts.null_terminated) {
+               ++ctx.indentation_level;
+            }
          }
-      };
 
-      template <class T>
-         requires glaze_array_t<T> || tuple_t<T> || is_std_tuple<T>
-      struct from_json<T>
-      {
-         template <auto Opts>
-         static void op(auto& value, is_context auto&& ctx, auto&& it, auto&& end) noexcept
-         {
-            static constexpr auto N = []() constexpr {
-               if constexpr (glaze_array_t<T>) {
-                  return glz::tuple_size_v<meta_t<T>>;
-               }
-               else {
-                  return glz::tuple_size_v<T>;
-               }
-            }();
+         // clear all contents and repopulate
+         value.clear();
 
-            if constexpr (!Opts.ws_handled) {
-               GLZ_SKIP_WS;
+         while (it < end) {
+            if (skip_ws<Opts>(ctx, it, end)) {
+               return;
             }
 
-            GLZ_MATCH_OPEN_BRACKET;
-            GLZ_SKIP_WS;
-
-            for_each<N>([&](auto I) {
-               if (*it == ']') {
-                  return;
-               }
-               if constexpr (I != 0) {
-                  GLZ_MATCH_COMMA;
-                  GLZ_SKIP_WS;
-               }
-               if constexpr (is_std_tuple<T>) {
-                  read<json>::op<ws_handled<Opts>()>(std::get<I>(value), ctx, it, end);
-                  if (bool(ctx.error)) [[unlikely]]
-                     return;
-               }
-               else if constexpr (glaze_array_t<T>) {
-                  read<json>::op<ws_handled<Opts>()>(get_member(value, glz::get<I>(meta_v<T>)), ctx, it, end);
-                  if (bool(ctx.error)) [[unlikely]]
-                     return;
+            if (*it == '}') {
+               ++it;
+               if constexpr (not Opts.null_terminated) {
+                  --ctx.indentation_level;
                }
-               else {
-                  read<json>::op<ws_handled<Opts>()>(glz::get<I>(value), ctx, it, end);
-                  if (bool(ctx.error)) [[unlikely]]
+               if constexpr (not Opts.null_terminated) {
+                  if (it == end) {
+                     ctx.error = error_code::end_reached;
                      return;
+                  }
                }
-               GLZ_SKIP_WS;
-            });
-
-            if constexpr (Opts.partial_read) {
                return;
             }
-            else {
-               match<']'>(ctx, it);
-            }
-         }
-      };
 
-      template <glaze_flags_t T>
-      struct from_json<T>
-      {
-         template <auto Opts>
-         static void op(auto&& value, is_context auto&& ctx, auto&& it, auto&& end) noexcept
-         {
-            if constexpr (!Opts.ws_handled) {
-               GLZ_SKIP_WS;
+            if constexpr (has_try_emplace_back<T>) {
+               if (value.try_emplace_back() == nullptr) [[unlikely]] {
+                  ctx.error = error_code::exceeded_static_array_size;
+                  return;
+               }
             }
+            else {
+               value.emplace_back();
+            }
+            auto& item = value.back();
 
-            GLZ_MATCH_OPEN_BRACKET;
-
-            std::string& s = string_buffer();
-
-            static constexpr auto flag_map = make_map<T>();
+            using V = std::decay_t<decltype(item)>;
 
-            while (true) {
-               read<json>::op<ws_handled_off<Opts>()>(s, ctx, it, end);
+            if constexpr (str_t<typename V::first_type> ||
+                          (std::is_enum_v<typename V::first_type> && glaze_t<typename V::first_type>)) {
+               parse<JSON>::op<Opts>(item.first, ctx, it, end);
                if (bool(ctx.error)) [[unlikely]]
                   return;
-
-               auto itr = flag_map.find(s);
-               if (itr != flag_map.end()) {
-                  std::visit([&](auto&& x) { get_member(value, x) = true; }, itr->second);
+            }
+            else {
+               std::string_view key;
+               parse<JSON>::op<Opts>(key, ctx, it, end);
+               if (bool(ctx.error)) [[unlikely]]
+                  return;
+               if constexpr (Opts.null_terminated) {
+                  parse<JSON>::op<Opts>(item.first, ctx, key.data(), key.data() + key.size());
                }
                else {
-                  ctx.error = error_code::invalid_flag_input;
-                  return;
+                  if (size_t(end - it) == key.size()) [[unlikely]] {
+                     ctx.error = error_code::unexpected_end;
+                     return;
+                  }
+                  // For the non-null terminated case we just want one more character so that we don't parse
+                  // until the end of the buffer and create an end_reached code (unless there is an error).
+                  parse<JSON>::op<Opts>(item.first, ctx, key.data(), key.data() + key.size() + 1);
                }
-
-               GLZ_SKIP_WS;
-               if (*it == ']') {
-                  ++it;
+               if (bool(ctx.error)) [[unlikely]]
                   return;
-               }
-               GLZ_MATCH_COMMA;
             }
-         }
-      };
-
-      template <class T>
-      struct from_json<includer<T>>
-      {
-         template <auto Options>
-         static void op(auto&& value, is_context auto&& ctx, auto&& it, auto&& end) noexcept
-         {
-            constexpr auto Opts = ws_handled_off<Options>();
-            std::string& buffer = string_buffer();
-            read<json>::op<Opts>(buffer, ctx, it, end);
-            if (bool(ctx.error)) [[unlikely]]
-               return;
-
-            const auto file_path = relativize_if_not_absolute(std::filesystem::path(ctx.current_file).parent_path(),
-                                                              std::filesystem::path{buffer});
 
-            const auto string_file_path = file_path.string();
-            const auto ec = file_to_buffer(buffer, string_file_path);
-
-            if (bool(ec)) [[unlikely]] {
-               ctx.error = error_code::includer_error;
-               auto& error_msg = error_buffer();
-               error_msg = "file failed to open: " + string_file_path;
-               ctx.includer_error = error_msg;
+            if (parse_ws_colon<Opts>(ctx, it, end)) {
                return;
             }
 
-            const auto current_file = ctx.current_file;
-            ctx.current_file = string_file_path;
+            parse<JSON>::op<Opts>(item.second, ctx, it, end);
+            if (bool(ctx.error)) [[unlikely]]
+               return;
 
-            // We need to allocate a new buffer here because we could call another includer that uses buffer
-            std::string nested_buffer = buffer;
-            const auto ecode = glz::read<opt_true<Opts, &opts::disable_padding>>(value.value, nested_buffer, ctx);
-            if (bool(ctx.error)) [[unlikely]] {
-               ctx.error = error_code::includer_error;
-               auto& error_msg = error_buffer();
-               error_msg = glz::format_error(ecode, nested_buffer);
-               ctx.includer_error = error_msg;
+            if (skip_ws<Opts>(ctx, it, end)) {
                return;
             }
 
-            ctx.current_file = current_file;
-         }
-      };
-
-      // TODO: count the maximum number of escapes that can be seen if error_on_unknown_keys is true
-      template <glaze_object_t T>
-      constexpr bool keys_may_contain_escape()
-      {
-         auto is_unicode = [](const auto c) { return (static_cast<uint8_t>(c) >> 7) > 0; };
-
-         bool may_escape = false;
-         constexpr auto N = glz::tuple_size_v<meta_t<T>>;
-         for_each<N>([&](auto I) {
-            constexpr auto first = get<0>(get<I>(meta_v<T>));
-            using T0 = std::decay_t<decltype(first)>;
-            if constexpr (std::is_member_pointer_v<T0>) {
-               constexpr auto s = get_name<first>();
-               for (auto& c : s) {
-                  if (c == '\\' || c == '"' || is_unicode(c)) {
-                     may_escape = true;
-                     return;
-                  }
-               }
-            }
-            else {
-               for (auto& c : first) {
-                  if (c == '\\' || c == '"' || is_unicode(c)) {
-                     may_escape = true;
+            if (*it == ',') {
+               ++it;
+               if constexpr (not Opts.null_terminated) {
+                  if (it == end) [[unlikely]] {
+                     ctx.error = error_code::unexpected_end;
                      return;
                   }
                }
             }
-         });
+         }
 
-         return may_escape;
+         ctx.error = error_code::unexpected_end;
       }
+   };
+
+   // counts the number of JSON array elements
+   // needed for classes that are resizable, but do not have an emplace_back
+   // 'it' is copied so that it does not actually progress the iterator
+   // expects the opening brace ([) to have already been consumed
+   template <auto Opts>
+   [[nodiscard]] size_t number_of_array_elements(is_context auto&& ctx, auto it, auto&& end) noexcept
+   {
+      skip_ws<Opts>(ctx, it, end);
+      if (bool(ctx.error)) [[unlikely]]
+         return {};
 
-      template <reflectable T>
-      constexpr bool keys_may_contain_escape()
-      {
-         return false; // escapes are not valid in C++ names
+      if (*it == ']') [[unlikely]] {
+         return 0;
       }
-
-      template <is_variant T>
-      constexpr bool keys_may_contain_escape()
-      {
-         bool may_escape = false;
-         constexpr auto N = std::variant_size_v<T>;
-         for_each<N>([&](auto I) {
-            using V = std::decay_t<std::variant_alternative_t<I, T>>;
-            constexpr bool is_object = glaze_object_t<V>;
-            if constexpr (is_object) {
-               if constexpr (keys_may_contain_escape<V>()) {
-                  may_escape = true;
-                  return;
-               }
-            }
-         });
-         return may_escape;
+      size_t count = 1;
+      while (true) {
+         switch (*it) {
+         case ',': {
+            ++count;
+            ++it;
+            break;
+         }
+         case '/': {
+            skip_comment(ctx, it, end);
+            if (bool(ctx.error)) [[unlikely]]
+               return {};
+            break;
+         }
+         case '{':
+            ++it;
+            skip_until_closed<Opts, '{', '}'>(ctx, it, end);
+            if (bool(ctx.error)) [[unlikely]]
+               return {};
+            break;
+         case '[':
+            ++it;
+            skip_until_closed<Opts, '[', ']'>(ctx, it, end);
+            if (bool(ctx.error)) [[unlikely]]
+               return {};
+            break;
+         case '"': {
+            skip_string<Opts>(ctx, it, end);
+            if (bool(ctx.error)) [[unlikely]]
+               return {};
+            break;
+         }
+         case ']': {
+            return count;
+         }
+         case '\0': {
+            ctx.error = error_code::unexpected_end;
+            return {};
+         }
+         default:
+            ++it;
+         }
       }
+      unreachable();
+   }
 
-      // only use this if the keys cannot contain escape characters
-      template <class T, string_literal tag = "">
-         requires(glaze_object_t<T> || reflectable<T>)
-      constexpr auto key_stats()
+   // For types like std::forward_list
+   template <class T>
+      requires readable_array_t<T> && (!emplace_backable<T> && resizable<T>)
+   struct from<JSON, T>
+   {
+      template <auto Options>
+      static void op(auto& value, is_context auto&& ctx, auto&& it, auto&& end)
       {
-         key_stats_t stats{};
-         if constexpr (!tag.sv().empty()) {
-            constexpr auto tag_size = tag.sv().size();
-            stats.max_length = tag_size;
-            stats.min_length = tag_size;
-         }
-
-         constexpr auto N = reflection_count<T>;
-
-         for_each<N>([&](auto I) {
-            using Element = glaze_tuple_element<I, N, T>;
-            constexpr sv key = key_name<I, T, Element::use_reflection>;
-
-            const auto n = key.size();
-            if (n < stats.min_length) {
-               stats.min_length = n;
-            }
-            if (n > stats.max_length) {
-               stats.max_length = n;
+         constexpr auto Opts = ws_handled_off<Options>();
+         if constexpr (!check_ws_handled(Options)) {
+            if (skip_ws<Opts>(ctx, it, end)) {
+               return;
             }
-         });
-
-         if constexpr (N > 0) { // avoid overflow
-            stats.length_range = stats.max_length - stats.min_length;
          }
 
-         return stats;
-      }
-
-      template <is_variant T, string_literal tag = "">
-      constexpr auto key_stats()
-      {
-         key_stats_t stats{};
-         if constexpr (!tag.sv().empty()) {
-            constexpr auto tag_size = tag.sv().size();
-            stats.max_length = tag_size;
-            stats.min_length = tag_size;
+         if (match_invalid_end<'[', Opts>(ctx, it, end)) {
+            return;
          }
+         if constexpr (not Opts.null_terminated) {
+            ++ctx.indentation_level;
+         }
+         const auto n = number_of_array_elements<Opts>(ctx, it, end);
+         if (bool(ctx.error)) [[unlikely]]
+            return;
+         value.resize(n);
+         size_t i = 0;
+         for (auto& x : value) {
+            parse<JSON>::op<Opts>(x, ctx, it, end);
+            if (bool(ctx.error)) [[unlikely]]
+               return;
 
-         constexpr auto N = std::variant_size_v<T>;
-         for_each<N>([&](auto I) {
-            using V = std::decay_t<std::variant_alternative_t<I, T>>;
-            constexpr bool is_object = glaze_object_t<V>;
-            if constexpr (is_object) {
-               constexpr auto substats = key_stats<V>();
-               if (substats.min_length < stats.min_length) {
-                  stats.min_length = substats.min_length;
-               }
-               if (substats.max_length > stats.max_length) {
-                  stats.max_length = substats.max_length;
+            if (skip_ws<Opts>(ctx, it, end)) {
+               return;
+            }
+            if (i < n - 1) {
+               if (match_invalid_end<',', Opts>(ctx, it, end)) {
+                  return;
                }
             }
-         });
-
-         stats.length_range = stats.max_length - stats.min_length;
-
-         return stats;
+            ++i;
+         }
+         match<']'>(ctx, it);
+         if constexpr (not Opts.null_terminated) {
+            --ctx.indentation_level;
+         }
       }
+   };
 
-      template <glz::opts Opts>
-      GLZ_ALWAYS_INLINE void parse_object_entry_sep(is_context auto& ctx, auto& it, const auto end)
+   template <class T>
+      requires glaze_array_t<T> || tuple_t<T> || is_std_tuple<T>
+   struct from<JSON, T>
+   {
+      template <auto Opts>
+      static void op(auto& value, is_context auto&& ctx, auto&& it, auto&& end)
       {
-         GLZ_SKIP_WS;
-         GLZ_MATCH_COLON;
-         GLZ_SKIP_WS;
-      }
+         static constexpr auto N = []() constexpr {
+            if constexpr (glaze_array_t<T>) {
+               return reflect<T>::size;
+            }
+            else {
+               return glz::tuple_size_v<T>;
+            }
+         }();
 
-      // Key parsing for meta objects or variants of meta objects.
-      // We do not check for an ending quote, we simply parse up to the quote
-      // TODO: We could expand this to compiletime known strings in general like enums
-      template <class T, auto Opts, string_literal tag = "">
-      GLZ_ALWAYS_INLINE std::string_view parse_object_key(is_context auto&& ctx, auto&& it, auto&& end)
-      {
-         // skip white space and escape characters and find the string
-         if constexpr (!Opts.ws_handled) {
-            skip_ws<Opts>(ctx, it, end);
-            if (bool(ctx.error)) [[unlikely]]
-               return {};
+         if constexpr (!check_ws_handled(Opts)) {
+            if (skip_ws<Opts>(ctx, it, end)) {
+               return;
+            }
          }
-         match<'"'>(ctx, it);
-         if (bool(ctx.error)) [[unlikely]]
-            return {};
-
-         constexpr auto N = reflection_count<T>;
 
-         if constexpr (keys_may_contain_escape<T>()) {
-            std::string& static_key = string_buffer();
-            read<json>::op<opening_handled<Opts>()>(static_key, ctx, it, end);
-            --it; // reveal the quote
-            return static_key;
+         if (match_invalid_end<'[', Opts>(ctx, it, end)) {
+            return;
          }
-         else if constexpr (N > 0) {
-            static constexpr auto stats = key_stats<T, tag>();
-            if constexpr (stats.length_range < 24) {
-               if ((it + stats.max_length) < end) [[likely]] {
-                  return parse_key_cx<Opts, stats>(it);
-               }
-            }
-            auto start = it;
-            skip_till_quote(ctx, it, end);
-            return {start, size_t(it - start)};
+         if constexpr (not Opts.null_terminated) {
+            ++ctx.indentation_level;
          }
-         else {
-            auto start = it;
-            skip_till_quote(ctx, it, end);
-            return {start, size_t(it - start)};
+         if (skip_ws<Opts>(ctx, it, end)) {
+            return;
          }
-      }
-
-      template <pair_t T>
-      struct from_json<T>
-      {
-         template <opts Options, string_literal tag = "">
-         static void op(T& value, is_context auto&& ctx, auto&& it, auto&& end)
-         {
-            constexpr auto Opts = opening_handled_off<ws_handled_off<Options>()>();
-            if constexpr (!Options.opening_handled) {
-               if constexpr (!Options.ws_handled) {
-                  GLZ_SKIP_WS;
-               }
-               GLZ_MATCH_OPEN_BRACE;
-            }
-            GLZ_SKIP_WS;
 
-            // Only used if error_on_missing_keys = true
-            [[maybe_unused]] bit_array<1> fields{};
+         for_each<N>([&]<size_t I>() {
+            if (bool(ctx.error)) [[unlikely]]
+               return;
 
-            if (*it == '}') {
-               if constexpr (Opts.error_on_missing_keys) {
-                  ctx.error = error_code::missing_key;
+            if (*it == ']') {
+               if constexpr (not Opts.null_terminated) {
+                  --ctx.indentation_level;
                }
                return;
             }
-
-            if constexpr (str_t<typename T::first_type>) {
-               read<json>::op<Opts>(value.first, ctx, it, end);
+            if constexpr (I != 0) {
+               if (match_invalid_end<',', Opts>(ctx, it, end)) {
+                  return;
+               }
+               if (skip_ws<Opts>(ctx, it, end)) {
+                  return;
+               }
+            }
+            if constexpr (is_std_tuple<T>) {
+               parse<JSON>::op<ws_handled<Opts>()>(std::get<I>(value), ctx, it, end);
                if (bool(ctx.error)) [[unlikely]]
                   return;
             }
-            else {
-               std::string_view key;
-               read<json>::op<Opts>(key, ctx, it, end);
+            else if constexpr (glaze_array_t<T>) {
+               parse<JSON>::op<ws_handled<Opts>()>(get_member(value, glz::get<I>(meta_v<T>)), ctx, it, end);
                if (bool(ctx.error)) [[unlikely]]
                   return;
-               read<json>::op<Opts>(value.first, ctx, key.data(), key.data() + key.size());
+            }
+            else {
+               parse<JSON>::op<ws_handled<Opts>()>(glz::get<I>(value), ctx, it, end);
                if (bool(ctx.error)) [[unlikely]]
                   return;
             }
-
-            parse_object_entry_sep<Opts>(ctx, it, end);
-            if (bool(ctx.error)) [[unlikely]]
+            if (skip_ws<Opts>(ctx, it, end)) {
                return;
+            }
+         });
 
-            read<json>::op<Opts>(value.second, ctx, it, end);
+         if constexpr (Opts.partial_read) {
+            return;
+         }
+         else {
             if (bool(ctx.error)) [[unlikely]]
                return;
-
-            GLZ_SKIP_WS;
-
-            match<'}'>(ctx, it);
-         }
-      };
-
-      template <class T>
-         requires readable_map_t<T> || glaze_object_t<T> || reflectable<T>
-      struct from_json<T>
-      {
-         template <auto Options, string_literal tag = "">
-         static void op(auto&& value, is_context auto&& ctx, auto&& it, auto&& end)
-         {
-            static constexpr auto num_members = reflection_count<T>;
-            if constexpr (num_members == 0 && is_partial_read<T>) {
-               static_assert(false_v<T>, "No members to read for partial read");
+            match<']'>(ctx, it);
+            if constexpr (not Opts.null_terminated) {
+               --ctx.indentation_level;
             }
-
-            constexpr auto Opts = opening_handled_off<ws_handled_off<Options>()>();
-            if constexpr (!Options.opening_handled) {
-               if constexpr (!Options.ws_handled) {
-                  GLZ_SKIP_WS;
+            if constexpr (not Opts.null_terminated) {
+               if (it == end) {
+                  ctx.error = error_code::end_reached;
+                  return;
                }
-               GLZ_MATCH_OPEN_BRACE;
             }
-            const auto ws_start = it;
-            GLZ_SKIP_WS;
-            const size_t ws_size = size_t(it - ws_start);
+         }
+      }
+   };
 
-            if constexpr ((glaze_object_t<T> || reflectable<T>)&&num_members == 0 && Opts.error_on_unknown_keys) {
-               if (*it == '}') [[likely]] {
-                  ++it;
-                  return;
-               }
-               ctx.error = error_code::unknown_key;
+   template <glaze_flags_t T>
+   struct from<JSON, T>
+   {
+      template <auto Opts>
+      static void op(auto&& value, is_context auto&& ctx, auto&& it, auto&& end)
+      {
+         if constexpr (!check_ws_handled(Opts)) {
+            if (skip_ws<Opts>(ctx, it, end)) {
                return;
             }
-            else {
-               static constexpr bit_array<num_members> all_fields = [] {
-                  bit_array<num_members> arr{};
-                  for (size_t i = 0; i < num_members; ++i) {
-                     arr[i] = true;
-                  }
-                  return arr;
-               }();
+         }
 
-               decltype(auto) fields = [&]() -> decltype(auto) {
-                  if constexpr ((glaze_object_t<T> || reflectable<T>)&&(Opts.error_on_missing_keys ||
-                                                                        is_partial_read<T> || Opts.partial_read)) {
-                     return bit_array<num_members>{};
-                  }
-                  else {
-                     return nullptr;
-                  }
-               }();
+         if (match_invalid_end<'[', Opts>(ctx, it, end)) {
+            return;
+         }
+         if constexpr (not Opts.null_terminated) {
+            ++ctx.indentation_level;
+         }
 
-               size_t read_count{}; // for partial_read and dynamic objects
+         std::string& s = string_buffer();
 
-               decltype(auto) frozen_map = [&]() -> decltype(auto) {
-                  using V = decay_keep_volatile_t<decltype(value)>;
-                  if constexpr (reflectable<T> && num_members > 0) {
-#if ((defined _MSC_VER) && (!defined __clang__))
-                     static thread_local auto cmap = make_map<V, Opts.use_hash_comparison>();
-#else
-                     static thread_local constinit auto cmap = make_map<V, Opts.use_hash_comparison>();
-#endif
-                     // We want to run this populate outside of the while loop
-                     populate_map(value, cmap); // Function required for MSVC to build
-                     return cmap;
-                  }
-                  else if constexpr (glaze_object_t<T> && num_members > 0) {
-                     static constexpr auto cmap = make_map<T, Opts.use_hash_comparison>();
-                     return cmap;
-                  }
-                  else {
-                     return nullptr;
-                  }
-               }();
+         constexpr auto& HashInfo = hash_info<T>;
+         static_assert(bool(HashInfo.type));
 
-               bool first = true;
-               while (true) {
-                  if constexpr ((glaze_object_t<T> || reflectable<T>)&&(is_partial_read<T> || Opts.partial_read)) {
-                     if ((all_fields & fields) == all_fields) {
-                        if constexpr (Opts.partial_read_nested) {
-                           skip_until_closed<Opts, '{', '}'>(ctx, it, end);
-                        }
-                        return;
-                     }
-                  }
+         while (true) {
+            parse<JSON>::op<ws_handled_off<Opts>()>(s, ctx, it, end);
+            if (bool(ctx.error)) [[unlikely]]
+               return;
 
-                  if (*it == '}') {
-                     if constexpr ((glaze_object_t<T> || reflectable<T>)&&((is_partial_read<T> || Opts.partial_read) &&
-                                                                           Opts.error_on_missing_keys)) {
-                        ctx.error = error_code::missing_key;
-                     }
-                     else {
-                        ++it;
-                        if constexpr ((glaze_object_t<T> || reflectable<T>)&&Opts.error_on_missing_keys) {
-                           constexpr auto req_fields = required_fields<T, Opts>();
-                           if ((req_fields & fields) != req_fields) {
-                              ctx.error = error_code::missing_key;
-                           }
-                        }
+            const auto index =
+               decode_hash_with_size<JSON, T, HashInfo, HashInfo.type>::op(s.data(), s.data() + s.size(), s.size());
+
+            constexpr auto N = reflect<T>::size;
+            if (index < N) [[likely]] {
+               visit<N>([&]<size_t I>() { get_member(value, get<I>(reflect<T>::values)) = true; }, index);
+            }
+            else [[unlikely]] {
+               ctx.error = error_code::invalid_flag_input;
+               return;
+            }
+
+            if (skip_ws<Opts>(ctx, it, end)) {
+               return;
+            }
+            if (*it == ']') {
+               if constexpr (not Opts.null_terminated) {
+                  --ctx.indentation_level;
+               }
+               ++it;
+               if constexpr (not Opts.null_terminated) {
+                  if (it == end) {
+                     ctx.error = error_code::end_reached;
+                     return;
+                  }
+               }
+               return;
+            }
+            if (match_invalid_end<',', Opts>(ctx, it, end)) {
+               return;
+            }
+         }
+      }
+   };
+
+   template <class T>
+   struct from<JSON, includer<T>>
+   {
+      template <auto Options>
+      static void op(auto&& value, is_context auto&& ctx, auto&& it, auto&& end)
+      {
+         constexpr auto Opts = ws_handled_off<Options>();
+         std::string buffer{};
+         parse<JSON>::op<Opts>(buffer, ctx, it, end);
+         if (bool(ctx.error)) [[unlikely]]
+            return;
+
+         const auto file_path = relativize_if_not_absolute(std::filesystem::path(ctx.current_file).parent_path(),
+                                                           std::filesystem::path{buffer});
+
+         const auto string_file_path = file_path.string();
+         const auto ec = file_to_buffer(buffer, string_file_path);
+
+         if (bool(ec)) [[unlikely]] {
+            ctx.error = error_code::includer_error;
+            auto& error_msg = error_buffer();
+            error_msg = "file failed to open: " + string_file_path;
+            ctx.includer_error = error_msg;
+            return;
+         }
+
+         const auto current_file = ctx.current_file;
+         ctx.current_file = string_file_path;
+
+         // We need to allocate a new buffer here because we could call another includer that uses the buffer
+         std::string nested_buffer = buffer;
+         static constexpr auto NestedOpts = opt_true<disable_padding_on<Opts>(), &opts::null_terminated>;
+         const auto ecode = glz::read<NestedOpts>(value.value, nested_buffer, ctx);
+         if (bool(ctx.error)) [[unlikely]] {
+            ctx.error = error_code::includer_error;
+            auto& error_msg = error_buffer();
+            error_msg = glz::format_error(ecode, nested_buffer);
+            ctx.includer_error = error_msg;
+            return;
+         }
+
+         ctx.current_file = current_file;
+      }
+   };
+
+   template <pair_t T>
+   struct from<JSON, T>
+   {
+      template <auto Options, string_literal tag = "">
+      static void op(T& value, is_context auto&& ctx, auto&& it, auto&& end)
+      {
+         constexpr auto Opts = opening_handled_off<ws_handled_off<Options>()>();
+         if constexpr (!check_opening_handled(Options)) {
+            if constexpr (!check_ws_handled(Options)) {
+               if (skip_ws<Opts>(ctx, it, end)) {
+                  return;
+               }
+            }
+            if (match_invalid_end<'{', Opts>(ctx, it, end)) {
+               return;
+            }
+            if constexpr (not Opts.null_terminated) {
+               ++ctx.indentation_level;
+            }
+         }
+         if (skip_ws<Opts>(ctx, it, end)) {
+            return;
+         }
+
+         if (*it == '}') {
+            if constexpr (not Opts.null_terminated) {
+               --ctx.indentation_level;
+            }
+            if constexpr (Opts.error_on_missing_keys) {
+               ctx.error = error_code::missing_key;
+            }
+            return;
+         }
+
+         using first_type = typename T::first_type;
+         if constexpr (str_t<first_type> || is_named_enum<first_type>) {
+            parse<JSON>::op<Opts>(value.first, ctx, it, end);
+            if (bool(ctx.error)) [[unlikely]]
+               return;
+         }
+         else {
+            std::string_view key;
+            parse<JSON>::op<Opts>(key, ctx, it, end);
+            if (bool(ctx.error)) [[unlikely]]
+               return;
+            if constexpr (Opts.null_terminated) {
+               parse<JSON>::op<Opts>(value.first, ctx, key.data(), key.data() + key.size());
+            }
+            else {
+               if (size_t(end - it) == key.size()) [[unlikely]] {
+                  ctx.error = error_code::unexpected_end;
+                  return;
+               }
+               // For the non-null terminated case we just want one more character so that we don't parse
+               // until the end of the buffer and create an end_reached code (unless there is an error).
+               parse<JSON>::op<Opts>(value.first, ctx, key.data(), key.data() + key.size() + 1);
+            }
+            if (bool(ctx.error)) [[unlikely]]
+               return;
+         }
+
+         if (parse_ws_colon<Opts>(ctx, it, end)) {
+            return;
+         }
+
+         parse<JSON>::op<Opts>(value.second, ctx, it, end);
+         if (bool(ctx.error)) [[unlikely]]
+            return;
+
+         if (skip_ws<Opts>(ctx, it, end)) {
+            return;
+         }
+
+         match<'}'>(ctx, it);
+         if constexpr (not Opts.null_terminated) {
+            --ctx.indentation_level;
+         }
+         if constexpr (not Opts.null_terminated) {
+            if (it == end) {
+               ctx.error = error_code::end_reached;
+               return;
+            }
+         }
+      }
+   };
+
+   template <class T, string_literal Tag>
+   inline consteval bool contains_tag()
+   {
+      auto& keys = reflect<T>::keys;
+      for (size_t i = 0; i < keys.size(); ++i) {
+         if (Tag.sv() == keys[i]) {
+            return true;
+         }
+      }
+      return false;
+   }
+
+   template <class T>
+      requires((readable_map_t<T> || glaze_object_t<T> || reflectable<T>) && not custom_read<T>)
+   struct from<JSON, T>
+   {
+      template <auto Options, string_literal tag = "">
+      static void op(auto&& value, is_context auto&& ctx, auto&& it, auto&& end)
+      {
+         static constexpr auto num_members = reflect<T>::size;
+
+         static constexpr auto Opts = opening_handled_off<ws_handled_off<Options>()>();
+         if constexpr (!check_opening_handled(Options)) {
+            if constexpr (!check_ws_handled(Options)) {
+               if (skip_ws<Opts>(ctx, it, end)) {
+                  return;
+               }
+            }
+            if (match_invalid_end<'{', Opts>(ctx, it, end)) {
+               return;
+            }
+            if constexpr (not Opts.null_terminated) {
+               if (it == end) [[unlikely]] {
+                  ctx.error = error_code::unexpected_end;
+                  return;
+               }
+            }
+            if constexpr (not Opts.null_terminated) {
+               ++ctx.indentation_level;
+            }
+         }
+         const auto ws_start = it;
+         if (skip_ws<Opts>(ctx, it, end)) {
+            return;
+         }
+         const size_t ws_size = size_t(it - ws_start);
+
+         if constexpr ((glaze_object_t<T> || reflectable<T>) && num_members == 0 && Opts.error_on_unknown_keys) {
+            if constexpr (not tag.sv().empty()) {
+               if (*it == '"') {
+                  ++it;
+                  if constexpr (not Opts.null_terminated) {
+                     if (it == end) [[unlikely]] {
+                        ctx.error = error_code::unexpected_end;
+                        return;
                      }
+                  }
+
+                  const auto start = it;
+                  skip_string_view<Opts>(ctx, it, end);
+                  if (bool(ctx.error)) [[unlikely]]
                      return;
+                  const sv key{start, size_t(it - start)};
+                  ++it;
+                  if constexpr (not Opts.null_terminated) {
+                     if (it == end) [[unlikely]] {
+                        ctx.error = error_code::unexpected_end;
+                        return;
+                     }
                   }
-                  else if (first) {
-                     first = false;
+
+                  if (key == tag.sv()) {
+                     if (parse_ws_colon<Opts>(ctx, it, end)) {
+                        return;
+                     }
+
+                     parse<JSON>::handle_unknown<Opts>(key, value, ctx, it, end);
+                     if (bool(ctx.error)) [[unlikely]]
+                        return;
+
+                     if (skip_ws<Opts>(ctx, it, end)) {
+                        return;
+                     }
                   }
                   else {
-                     GLZ_MATCH_COMMA;
+                     ctx.error = error_code::unknown_key;
+                     return;
+                  }
+               }
+            }
 
-                     if constexpr ((not Opts.minified) && (num_members > 1 || !Opts.error_on_unknown_keys)) {
-                        if (ws_size && ws_size < size_t(end - it)) {
-                           skip_matching_ws(ws_start, it, ws_size);
+            if (*it == '}') [[likely]] {
+               if constexpr (not Opts.null_terminated) {
+                  --ctx.indentation_level;
+               }
+               ++it;
+               if constexpr (not Opts.null_terminated) {
+                  if (it == end) {
+                     ctx.error = error_code::end_reached;
+                     return;
+                  }
+               }
+               if constexpr (Opts.partial_read) {
+                  ctx.error = error_code::partial_read_complete;
+               }
+               return;
+            }
+            ctx.error = error_code::unknown_key;
+            return;
+         }
+         else {
+            decltype(auto) fields = [&]() -> decltype(auto) {
+               if constexpr ((glaze_object_t<T> || reflectable<T>) &&
+                             (Opts.error_on_missing_keys || Opts.partial_read)) {
+                  return bit_array<num_members>{};
+               }
+               else {
+                  return nullptr;
+               }
+            }();
+
+            size_t read_count{}; // for partial_read
+
+            bool first = true;
+            while (true) {
+               if constexpr ((glaze_object_t<T> || reflectable<T>) && Opts.partial_read) {
+                  static constexpr bit_array<num_members> all_fields = [] {
+                     bit_array<num_members> arr{};
+                     for (size_t i = 0; i < num_members; ++i) {
+                        arr[i] = true;
+                     }
+                     return arr;
+                  }();
+
+                  if ((all_fields & fields) == all_fields) {
+                     ctx.error = error_code::partial_read_complete;
+                     return;
+                  }
+               }
+
+               if (*it == '}') {
+                  if constexpr (not Opts.null_terminated) {
+                     --ctx.indentation_level;
+                  }
+                  if constexpr ((glaze_object_t<T> || reflectable<T>) &&
+                                (Opts.partial_read && Opts.error_on_missing_keys)) {
+                     ctx.error = error_code::missing_key;
+                     return;
+                  }
+                  else {
+                     if constexpr ((glaze_object_t<T> || reflectable<T>) && Opts.error_on_missing_keys) {
+                        constexpr auto req_fields = required_fields<T, Opts>();
+                        if ((req_fields & fields) != req_fields) {
+                           for (size_t i = 0; i < num_members; ++i) {
+                              if (not fields[i] && req_fields[i]) {
+                                 ctx.custom_error_message = reflect<T>::keys[i];
+                                 // We just return the first missing key in order to avoid heap allocations
+                                 break;
+                              }
+                           }
+
+                           ctx.error = error_code::missing_key;
+                           return;
+                        }
+                     }
+                     ++it; // Increment after checking for mising keys so errors are within buffer bounds
+                     if constexpr (not Opts.null_terminated) {
+                        if (it == end) {
+                           ctx.error = error_code::end_reached;
+                           return;
                         }
                      }
+                  }
+                  return;
+               }
+               else if (first) {
+                  first = false;
+               }
+               else {
+                  if (match_invalid_end<',', Opts>(ctx, it, end)) {
+                     return;
+                  }
+                  if constexpr (not Opts.null_terminated) {
+                     if (it == end) [[unlikely]] {
+                        ctx.error = error_code::unexpected_end;
+                        return;
+                     }
+                  }
+
+                  if constexpr ((not Opts.minified) && (num_members > 1 || not Opts.error_on_unknown_keys)) {
+                     if (ws_size && ws_size < size_t(end - it)) {
+                        skip_matching_ws(ws_start, it, ws_size);
+                     }
+                  }
 
-                     GLZ_SKIP_WS;
+                  if (skip_ws<Opts>(ctx, it, end)) {
+                     return;
                   }
+               }
+
+               constexpr auto reflection_type = glaze_object_t<T> || reflectable<T>;
 
-                  if constexpr ((glaze_object_t<T> || reflectable<T>)&&num_members == 0 && Opts.error_on_unknown_keys) {
+               if constexpr (reflection_type && (num_members == 0)) {
+                  if constexpr (Opts.error_on_unknown_keys) {
                      static_assert(false_v<T>, "This should be unreachable");
                   }
-                  else if constexpr ((glaze_object_t<T> || reflectable<T>)&&num_members == 0) {
-                     GLZ_MATCH_QUOTE;
+                  else {
+                     if (match_invalid_end<'"', Opts>(ctx, it, end)) {
+                        return;
+                     }
 
                      // parsing to an empty object, but at this point the JSON presents keys
 
@@ -1803,732 +2311,895 @@ namespace glz
                         return;
                      const sv key{start, size_t(it - start)};
                      ++it;
+                     if constexpr (not Opts.null_terminated) {
+                        if (it == end) [[unlikely]] {
+                           ctx.error = error_code::unexpected_end;
+                           return;
+                        }
+                     }
 
-                     parse_object_entry_sep<Opts>(ctx, it, end);
-                     if (bool(ctx.error)) [[unlikely]]
+                     if (parse_ws_colon<Opts>(ctx, it, end)) {
                         return;
+                     }
 
-                     read<json>::handle_unknown<Opts>(key, value, ctx, it, end);
+                     parse<JSON>::handle_unknown<Opts>(key, value, ctx, it, end);
                      if (bool(ctx.error)) [[unlikely]]
                         return;
+                     if constexpr (not Opts.null_terminated) {
+                        if (it == end) [[unlikely]] {
+                           ctx.error = error_code::unexpected_end;
+                           return;
+                        }
+                     }
                   }
-                  else if constexpr (glaze_object_t<T> || reflectable<T>) {
-                     static_assert(!std::same_as<std::decay_t<decltype(frozen_map)>, std::nullptr_t>);
-                     std::conditional_t<Opts.error_on_unknown_keys, const sv, sv> key =
-                        parse_object_key<T, ws_handled<Opts>(), tag>(ctx, it, end);
-                     if (bool(ctx.error)) [[unlikely]]
+               }
+               else if constexpr (reflection_type) {
+                  static_assert(bool(hash_info<T>.type));
+
+                  if (*it != '"') [[unlikely]] {
+                     ctx.error = error_code::expected_quote;
+                     return;
+                  }
+                  ++it;
+                  if constexpr (not Opts.null_terminated) {
+                     if (it == end) [[unlikely]] {
+                        ctx.error = error_code::unexpected_end;
                         return;
+                     }
+                  }
 
-                     // Because parse_object_key does not necessarily return a valid JSON key, the logic for handling
-                     // whitespace and the colon must run after checking if the key exists
+                  if constexpr (not tag.sv().empty() && not contains_tag<T, tag>()) {
+                     // For tagged variants we first check to see if the key matches the tag
+                     // We only need to do this if the tag is not part of the keys
 
-                     if constexpr (Opts.error_on_unknown_keys) {
-                        if (*it != '"') [[unlikely]] {
-                           ctx.error = error_code::unknown_key;
+                     const auto start = it;
+                     skip_string_view<Opts>(ctx, it, end);
+                     if (bool(ctx.error)) [[unlikely]]
+                        return;
+                     const sv key{start, size_t(it - start)};
+                     ++it;
+                     if constexpr (not Opts.null_terminated) {
+                        if (it == end) [[unlikely]] {
+                           ctx.error = error_code::unexpected_end;
                            return;
                         }
-                        ++it;
-
-                        if (const auto& member_it = frozen_map.find(key); member_it != frozen_map.end()) [[likely]] {
-                           parse_object_entry_sep<Opts>(ctx, it, end);
-                           if (bool(ctx.error)) [[unlikely]]
-                              return;
+                     }
 
-                           if constexpr (Opts.error_on_missing_keys || is_partial_read<T> || Opts.partial_read) {
-                              // TODO: Kludge/hack. Should work but could easily cause memory issues with small changes.
-                              // At the very least if we are going to do this add a get_index method to the maps and
-                              // call that
-                              auto index = member_it - frozen_map.begin();
-                              fields[index] = true;
-                           }
-                           std::visit(
-                              [&](auto&& member_ptr) {
-                                 read<json>::op<ws_handled<Opts>()>(get_member(value, member_ptr), ctx, it, end);
-                              },
-                              member_it->second);
-                           if (bool(ctx.error)) [[unlikely]]
-                              return;
+                     if (key == tag.sv()) {
+                        if (parse_ws_colon<Opts>(ctx, it, end)) {
+                           return;
                         }
-                        else [[unlikely]] {
-                           if constexpr (tag.sv().empty()) {
-                              it -= int64_t(key.size());
-                              ctx.error = error_code::unknown_key;
-                              return;
-                           }
-                           else if (key != tag.sv()) {
-                              it -= int64_t(key.size());
-                              ctx.error = error_code::unknown_key;
-                              return;
-                           }
-                           else {
-                              // We duplicate this code to avoid generating unreachable code
-                              parse_object_entry_sep<Opts>(ctx, it, end);
-                              if (bool(ctx.error)) [[unlikely]]
-                                 return;
 
-                              read<json>::handle_unknown<Opts>(key, value, ctx, it, end);
-                              if (bool(ctx.error)) [[unlikely]]
-                                 return;
-                           }
+                        parse<JSON>::handle_unknown<Opts>(key, value, ctx, it, end);
+                        if (bool(ctx.error)) [[unlikely]]
+                           return;
+
+                        if (skip_ws<Opts>(ctx, it, end)) {
+                           return;
                         }
+                        continue;
                      }
                      else {
-                        if (const auto& member_it = frozen_map.find(key); member_it != frozen_map.end()) [[likely]] {
-                           // This code should not error on valid unknown keys
-                           // We arrived here because the key was perhaps found, but if the quote does not exist
-                           // then this does not necessarily mean we have a syntax error.
-                           // We may have just found the prefix of a longer, unknown key.
-                           if (*it != '"') [[unlikely]] {
-                              auto* start = key.data();
-                              skip_string_view<Opts>(ctx, it, end);
-                              if (bool(ctx.error)) [[unlikely]]
-                                 return;
-                              key = {start, size_t(it - start)};
-                              ++it;
-
-                              parse_object_entry_sep<Opts>(ctx, it, end);
-                              if (bool(ctx.error)) [[unlikely]]
-                                 return;
-
-                              read<json>::handle_unknown<Opts>(key, value, ctx, it, end);
-                              if (bool(ctx.error)) [[unlikely]]
-                                 return;
-                           }
-                           else {
-                              ++it; // skip the quote
-
-                              parse_object_entry_sep<Opts>(ctx, it, end);
-                              if (bool(ctx.error)) [[unlikely]]
-                                 return;
-
-                              if constexpr (Opts.error_on_missing_keys || is_partial_read<T> || Opts.partial_read) {
-                                 // TODO: Kludge/hack. Should work but could easily cause memory issues with small
-                                 // changes. At the very least if we are going to do this add a get_index method to the
-                                 // maps and call that
-                                 auto index = member_it - frozen_map.begin();
-                                 fields[index] = true;
-                              }
-                              std::visit(
-                                 [&](auto&& member_ptr) {
-                                    read<json>::op<ws_handled<Opts>()>(get_member(value, member_ptr), ctx, it, end);
-                                 },
-                                 member_it->second);
-                              if (bool(ctx.error)) [[unlikely]]
-                                 return;
-                           }
-                        }
-                        else [[unlikely]] {
-                           if (*it != '"') {
-                              // we need to search until we find the ending quote of the key
-                              skip_string_view<Opts>(ctx, it, end);
-                              if (bool(ctx.error)) [[unlikely]]
-                                 return;
-                              auto start = key.data();
-                              key = {start, size_t(it - start)};
-                           }
-                           ++it; // skip the quote
-
-                           parse_object_entry_sep<Opts>(ctx, it, end);
-                           if (bool(ctx.error)) [[unlikely]]
-                              return;
+                        it = start; // reset the iterator
+                     }
+                  }
 
-                           read<json>::handle_unknown<Opts>(key, value, ctx, it, end);
-                           if (bool(ctx.error)) [[unlikely]]
-                              return;
-                        }
+                  if constexpr (Opts.error_on_missing_keys || Opts.partial_read) {
+                     size_t index = num_members;
+                     parse_and_invoke<Opts, T, hash_info<T>>(value, ctx, it, end, index);
+                     if (bool(ctx.error)) [[unlikely]]
+                        return;
+                     if (index < num_members) {
+                        fields[index] = true;
                      }
                   }
                   else {
-                     // For types like std::map, std::unordered_map
-                     // using Key = std::conditional_t<heterogeneous_map<T>, sv, typename T::key_type>;
-                     using Key = typename T::key_type;
-                     if constexpr (std::is_same_v<Key, std::string>) {
-                        static thread_local Key key;
-                        read<json>::op<Opts>(key, ctx, it, end);
-                        if (bool(ctx.error)) [[unlikely]]
-                           return;
-
-                        parse_object_entry_sep<Opts>(ctx, it, end);
+                     parse_and_invoke<Opts, T, hash_info<T>>(value, ctx, it, end);
+                     if (bool(ctx.error)) [[unlikely]]
+                        return;
+                  }
+               }
+               else {
+                  // For types like std::map, std::unordered_map
 
-                        if constexpr (Opts.partial_read) {
-                           if (auto element = value.find(key); element != value.end()) {
-                              ++read_count;
-                              read<json>::op<ws_handled<Opts>()>(element->second, ctx, it, end);
-                           }
-                           else {
-                              skip_value<Opts>(ctx, it, end);
-                           }
-                           if (read_count == value.size()) {
-                              return;
-                           }
+                  auto reading = [&](auto&& key) {
+                     if constexpr (Opts.partial_read) {
+                        if (auto element = value.find(key); element != value.end()) {
+                           ++read_count;
+                           parse<JSON>::op<ws_handled<Opts>()>(element->second, ctx, it, end);
                         }
                         else {
-                           read<json>::op<ws_handled<Opts>()>(value[key], ctx, it, end);
+                           skip_value<JSON>::op<Opts>(ctx, it, end);
                         }
-                        if (bool(ctx.error)) [[unlikely]]
-                           return;
                      }
-                     else if constexpr (str_t<Key>) {
-                        Key key;
-                        read<json>::op<Opts>(key, ctx, it, end);
-                        if (bool(ctx.error)) [[unlikely]]
-                           return;
+                     else {
+                        parse<JSON>::op<ws_handled<Opts>()>(value[key], ctx, it, end);
+                     }
+                  };
 
-                        parse_object_entry_sep<Opts>(ctx, it, end);
-                        if (bool(ctx.error)) [[unlikely]]
-                           return;
+                  // using Key = std::conditional_t<heterogeneous_map<T>, sv, typename T::key_type>;
+                  using Key = typename T::key_type;
+                  if constexpr (std::is_same_v<Key, std::string>) {
+                     static thread_local Key key;
+                     parse<JSON>::op<Opts>(key, ctx, it, end);
+                     if (bool(ctx.error)) [[unlikely]]
+                        return;
 
-                        if constexpr (Opts.partial_read) {
-                           if (auto element = value.find(key); element != value.end()) {
-                              ++read_count;
-                              read<json>::op<ws_handled<Opts>()>(element->second, ctx, it, end);
-                           }
-                           else {
-                              skip_value<Opts>(ctx, it, end);
-                           }
-                           if (read_count == value.size()) {
-                              return;
-                           }
-                        }
-                        else {
-                           read<json>::op<ws_handled<Opts>()>(value[key], ctx, it, end);
+                     if (parse_ws_colon<Opts>(ctx, it, end)) {
+                        return;
+                     }
+
+                     reading(key);
+                     if constexpr (Opts.partial_read) {
+                        if (read_count == value.size()) {
+                           return;
                         }
-                        if (bool(ctx.error)) [[unlikely]]
+                     }
+                     if (bool(ctx.error)) [[unlikely]]
+                        return;
+                  }
+                  else if constexpr (str_t<Key>) {
+                     Key key;
+                     parse<JSON>::op<Opts>(key, ctx, it, end);
+                     if (bool(ctx.error)) [[unlikely]]
+                        return;
+
+                     if (parse_ws_colon<Opts>(ctx, it, end)) {
+                        return;
+                     }
+
+                     reading(key);
+                     if constexpr (Opts.partial_read) {
+                        if (read_count == value.size()) {
                            return;
+                        }
+                     }
+                     if (bool(ctx.error)) [[unlikely]]
+                        return;
+                  }
+                  else {
+                     Key key_value{};
+                     if constexpr (glaze_enum_t<Key>) {
+                        parse<JSON>::op<Opts>(key_value, ctx, it, end);
+                     }
+                     else if constexpr (std::is_arithmetic_v<Key>) {
+                        // prefer over quoted_t below to avoid double parsing of quoted_t
+                        parse<JSON>::op<opt_true<Opts, &opts::quoted_num>>(key_value, ctx, it, end);
                      }
                      else {
-                        Key key_value{};
-                        if constexpr (glaze_enum_t<Key>) {
-                           read<json>::op<Opts>(key_value, ctx, it, end);
-                        }
-                        else if constexpr (std::is_arithmetic_v<Key>) {
-                           // prefer over quoted_t below to avoid double parsing of quoted_t
-                           read<json>::op<opt_true<Opts, &opts::quoted_num>>(key_value, ctx, it, end);
-                        }
-                        else {
-                           read<json>::op<opt_false<Opts, &opts::raw_string>>(quoted_t<Key>{key_value}, ctx, it, end);
-                        }
-                        if (bool(ctx.error)) [[unlikely]]
-                           return;
+                        parse<JSON>::op<opt_false<Opts, &opts::raw_string>>(quoted_t<Key>{key_value}, ctx, it, end);
+                     }
+                     if (bool(ctx.error)) [[unlikely]]
+                        return;
 
-                        parse_object_entry_sep<Opts>(ctx, it, end);
-                        if (bool(ctx.error)) [[unlikely]]
-                           return;
+                     if (parse_ws_colon<Opts>(ctx, it, end)) {
+                        return;
+                     }
 
-                        if constexpr (Opts.partial_read) {
-                           if (auto element = value.find(key_value); element != value.end()) {
-                              ++read_count;
-                              read<json>::op<ws_handled<Opts>()>(element->second, ctx, it, end);
-                           }
-                           else {
-                              skip_value<Opts>(ctx, it, end);
-                           }
-                           if (read_count == value.size()) {
-                              return;
-                           }
-                        }
-                        else {
-                           read<json>::op<Opts>(value[key_value], ctx, it, end);
-                        }
-                        if (bool(ctx.error)) [[unlikely]]
+                     reading(key_value);
+                     if constexpr (Opts.partial_read) {
+                        if (read_count == value.size()) {
                            return;
+                        }
                      }
+                     if (bool(ctx.error)) [[unlikely]]
+                        return;
                   }
-                  skip_ws<Opts>(ctx, it, end);
+               }
+               if (skip_ws<Opts>(ctx, it, end)) {
+                  return;
                }
             }
          }
-      };
-
-      template <is_variant T>
-      consteval auto variant_is_auto_deducible()
-      {
-         // Contains at most one each of the basic json types bool, numeric, string, object, array
-         // If all objects are meta-objects then we can attempt to deduce them as well either through a type tag or
-         // unique combinations of keys
-         int bools{}, numbers{}, strings{}, objects{}, meta_objects{}, arrays{};
-         constexpr auto N = std::variant_size_v<T>;
-         for_each<N>([&](auto I) {
-            using V = std::decay_t<std::variant_alternative_t<I, T>>;
-            // ICE workaround
-            bools += bool_t<V>;
-            numbers += num_t<V>;
-            strings += str_t<V>;
-            strings += glaze_enum_t<V>;
-            objects += pair_t<V>;
-            objects += (writable_map_t<V> || readable_map_t<V>);
-            objects += glaze_object_t<V>;
-            meta_objects += glaze_object_t<V> || reflectable<V>;
-            arrays += glaze_array_t<V>;
-            arrays += array_t<V>;
-            // TODO null
-         });
-         return bools < 2 && numbers < 2 && strings < 2 && (objects < 2 || meta_objects == objects) && arrays < 2;
       }
+   };
 
-      template <class>
-      struct variant_types;
+   template <is_variant T>
+   consteval auto variant_is_auto_deducible()
+   {
+      // Contains at most one each of the basic json types bool, numeric, string, object, array
+      // If all objects are meta-objects then we can attempt to deduce them as well either through a type tag or
+      // unique combinations of keys
+      int bools{}, numbers{}, strings{}, objects{}, meta_objects{}, arrays{};
+      constexpr auto N = std::variant_size_v<T>;
+      for_each<N>([&]<auto I>() {
+         using V = std::decay_t<std::variant_alternative_t<I, T>>;
+         // ICE workaround
+         bools += bool_t<V>;
+         numbers += num_t<V>;
+         strings += str_t<V>;
+         strings += glaze_enum_t<V>;
+         objects += pair_t<V>;
+         objects += (writable_map_t<V> || readable_map_t<V> || is_memory_object<V>);
+         objects += glaze_object_t<V>;
+         meta_objects += glaze_object_t<V> || reflectable<V> || is_memory_object<V>;
+         arrays += glaze_array_t<V>;
+         arrays += array_t<V>;
+         // TODO null
+      });
+      return bools < 2 && numbers < 2 && strings < 2 && (objects < 2 || meta_objects == objects) && arrays < 2;
+   }
 
-      template <class... Ts>
-      struct variant_types<std::variant<Ts...>>
-      {
-         // TODO: this way of filtering types is compile time intensive.
-         using bool_types = decltype(tuplet::tuple_cat(
-            std::conditional_t<bool_t<remove_meta_wrapper_t<Ts>>, tuplet::tuple<Ts>, tuplet::tuple<>>{}...));
-         using number_types = decltype(tuplet::tuple_cat(
-            std::conditional_t<num_t<remove_meta_wrapper_t<Ts>>, tuplet::tuple<Ts>, tuplet::tuple<>>{}...));
-         using string_types = decltype(tuplet::tuple_cat( // glaze_enum_t remove_meta_wrapper_t supports constexpr types
-                                                          // while the other supports non const
-            std::conditional_t < str_t<remove_meta_wrapper_t<Ts>> || glaze_enum_t<remove_meta_wrapper_t<Ts>> ||
-               glaze_enum_t<Ts>,
-            tuplet::tuple<Ts>, tuplet::tuple < >> {}...));
-         using object_types = decltype(tuplet::tuple_cat(
-            std::conditional_t < reflectable<Ts> || readable_map_t<Ts> || writable_map_t<Ts> || glaze_object_t<Ts>,
-            tuplet::tuple<Ts>, tuplet::tuple < >> {}...));
-         using array_types =
-            decltype(tuplet::tuple_cat(std::conditional_t < array_t<remove_meta_wrapper_t<Ts>> || glaze_array_t<Ts>,
-                                       tuplet::tuple<Ts>, tuplet::tuple < >> {}...));
-         using nullable_types =
-            decltype(tuplet::tuple_cat(std::conditional_t<null_t<Ts>, tuplet::tuple<Ts>, tuplet::tuple<>>{}...));
-      };
-
-      // post process output of variant_types
-      template <class>
-      struct tuple_types;
-
-      template <class... Ts>
-      struct tuple_types<tuplet::tuple<Ts...>>
-      {
-         using glaze_const_types = decltype(tuplet::tuple_cat(
-            std::conditional_t<glaze_const_value_t<Ts>, tuplet::tuple<Ts>, tuplet::tuple<>>{}...));
-         using glaze_non_const_types = decltype(tuplet::tuple_cat(
-            std::conditional_t<!glaze_const_value_t<Ts>, tuplet::tuple<Ts>, tuplet::tuple<>>{}...));
-      };
+   template <class>
+   struct variant_types;
+
+   template <class... Ts>
+   struct variant_types<std::variant<Ts...>>
+   {
+      // TODO: this way of filtering types is compile time intensive.
+      using bool_types =
+         decltype(tuplet::tuple_cat(std::conditional_t<bool_t<remove_meta_wrapper_t<Ts>>, tuple<Ts>, tuple<>>{}...));
+      using number_types =
+         decltype(tuplet::tuple_cat(std::conditional_t<num_t<remove_meta_wrapper_t<Ts>>, tuple<Ts>, tuple<>>{}...));
+      using string_types = decltype(tuplet::tuple_cat( // glaze_enum_t remove_meta_wrapper_t supports constexpr
+                                                       // types while the other supports non const
+         std::conditional_t < str_t<remove_meta_wrapper_t<Ts>> || glaze_enum_t<remove_meta_wrapper_t<Ts>> ||
+            glaze_enum_t<Ts>,
+         tuple<Ts>, tuple < >> {}...));
+      using object_types = decltype(tuplet::tuple_cat(std::conditional_t<json_object<Ts>, tuple<Ts>, tuple<>>{}...));
+      using array_types = decltype(tuplet::tuple_cat(std::conditional_t < array_t<remove_meta_wrapper_t<Ts>> ||
+                                                        glaze_array_t<Ts> || tuple_t<Ts> || is_std_tuple<Ts>,
+                                                     tuple<Ts>, tuple < >> {}...));
+      using nullable_types = decltype(tuplet::tuple_cat(std::conditional_t<null_t<Ts>, tuple<Ts>, tuple<>>{}...));
+      using nullable_objects =
+         decltype(tuplet::tuple_cat(std::conditional_t<is_memory_object<Ts>, tuple<Ts>, tuple<>>{}...));
+   };
+
+   // post process output of variant_types
+   template <class>
+   struct tuple_types;
+
+   template <class... Ts>
+   struct tuple_types<tuple<Ts...>>
+   {
+      using glaze_const_types =
+         decltype(tuplet::tuple_cat(std::conditional_t<glaze_const_value_t<Ts>, tuple<Ts>, tuple<>>{}...));
+      using glaze_non_const_types =
+         decltype(tuplet::tuple_cat(std::conditional_t<!glaze_const_value_t<Ts>, tuple<Ts>, tuple<>>{}...));
+   };
 
-      template <class>
-      struct variant_type_count;
+   template <class>
+   struct variant_type_count;
 
-      template <class... Ts>
-      struct variant_type_count<std::variant<Ts...>>
-      {
-         using V = variant_types<std::variant<Ts...>>;
-         static constexpr auto n_bool = glz::tuple_size_v<typename V::bool_types>;
-         static constexpr auto n_number = glz::tuple_size_v<typename V::number_types>;
-         static constexpr auto n_string = glz::tuple_size_v<typename V::string_types>;
-         static constexpr auto n_object = glz::tuple_size_v<typename V::object_types>;
-         static constexpr auto n_array = glz::tuple_size_v<typename V::array_types>;
-         static constexpr auto n_null = glz::tuple_size_v<typename V::nullable_types>;
-      };
-
-      template <class Tuple>
-      struct process_arithmetic_boolean_string_or_array
+   template <class... Ts>
+   struct variant_type_count<std::variant<Ts...>>
+   {
+      using V = variant_types<std::variant<Ts...>>;
+      static constexpr auto n_bool = glz::tuple_size_v<typename V::bool_types>;
+      static constexpr auto n_number = glz::tuple_size_v<typename V::number_types>;
+      static constexpr auto n_string = glz::tuple_size_v<typename V::string_types>;
+      static constexpr auto n_nullable_object = glz::tuple_size_v<typename V::nullable_objects>;
+      static constexpr auto n_object = glz::tuple_size_v<typename V::object_types> + n_nullable_object;
+      static constexpr auto n_array = glz::tuple_size_v<typename V::array_types>;
+      static constexpr auto n_null = glz::tuple_size_v<typename V::nullable_types>;
+   };
+
+   template <class Tuple>
+   struct process_arithmetic_boolean_string_or_array
+   {
+      template <auto Options>
+      static void op(auto&& value, is_context auto&& ctx, auto&& it, auto&& end)
       {
-         template <auto Options>
-         static void op(auto&& value, is_context auto&& ctx, auto&& it, auto&& end)
-         {
-            if constexpr (glz::tuple_size_v<Tuple> < 1) {
-               ctx.error = error_code::no_matching_variant_type;
-            }
-            else {
-               using const_glaze_types = typename tuple_types<Tuple>::glaze_const_types;
-               bool found_match{};
-               for_each<glz::tuple_size_v<const_glaze_types>>([&]([[maybe_unused]] auto I) mutable {
-                  if (found_match) {
-                     return;
-                  }
-                  using V = glz::tuple_element_t<I, const_glaze_types>;
-                  // run time substitute to compare to const value
-                  std::remove_const_t<std::remove_pointer_t<std::remove_const_t<meta_wrapper_t<V>>>> substitute{};
-                  auto copy_it{it};
-                  read<json>::op<ws_handled<Options>()>(substitute, ctx, it, end);
-                  static constexpr auto const_value{*meta_wrapper_v<V>};
-                  if (substitute == const_value) {
-                     found_match = true;
-                     if (!std::holds_alternative<V>(value)) value = V{};
+         if constexpr (glz::tuple_size_v<Tuple> < 1) {
+            ctx.error = error_code::no_matching_variant_type;
+         }
+         else {
+            using const_glaze_types = typename tuple_types<Tuple>::glaze_const_types;
+            bool found_match{};
+            for_each<glz::tuple_size_v<const_glaze_types>>([&]<size_t I>() {
+               if (found_match) {
+                  return;
+               }
+               using V = glz::tuple_element_t<I, const_glaze_types>;
+               // run time substitute to compare to const value
+               std::remove_const_t<std::remove_pointer_t<std::remove_const_t<meta_wrapper_t<V>>>> substitute{};
+               auto copy_it{it};
+               parse<JSON>::op<ws_handled<Options>()>(substitute, ctx, it, end);
+               static constexpr auto const_value{*meta_wrapper_v<V>};
+               if (substitute == const_value) {
+                  found_match = true;
+                  if (!std::holds_alternative<V>(value)) {
+                     value = V{};
                   }
-                  else {
-                     it = copy_it;
+               }
+               else {
+                  if constexpr (not Options.null_terminated) {
+                     if (ctx.error == error_code::end_reached) {
+                        // reset the context for next attempt
+                        ctx.error = error_code::none;
+                     }
                   }
-               });
-               if (found_match) {
+                  it = copy_it;
+               }
+            });
+            if (found_match) {
+               return;
+            }
+
+            using non_const_types = typename tuple_types<Tuple>::glaze_non_const_types;
+            if constexpr (glz::tuple_size_v < non_const_types >> 0) {
+               using V = glz::tuple_element_t<0, non_const_types>;
+               if (!std::holds_alternative<V>(value)) value = V{};
+               parse<JSON>::op<ws_handled<Options>()>(std::get<V>(value), ctx, it, end);
+            }
+            else {
+               ctx.error = error_code::no_matching_variant_type;
+            }
+         }
+      }
+   };
+
+   template <is_variant T>
+   struct from<JSON, T>
+   {
+      // Note that items in the variant are required to be default constructable for us to switch types
+      template <auto Options>
+      static void op(auto&& value, is_context auto&& ctx, auto&& it, auto&& end)
+      {
+         constexpr auto Opts = ws_handled_off<Options>();
+         if constexpr (variant_is_auto_deducible<T>()) {
+            if constexpr (not check_ws_handled(Options)) {
+               if (skip_ws<Opts>(ctx, it, end)) {
+                  return;
+               }
+            }
+
+            switch (*it) {
+            case '\0':
+               ctx.error = error_code::unexpected_end;
+               return;
+            case '{':
+               if (ctx.indentation_level >= max_recursive_depth_limit) {
+                  ctx.error = error_code::exceeded_max_recursive_depth;
                   return;
                }
+               // In the null terminated case this guards for stack overflow
+               // Depth counting is done at the object level when not null terminated
+               ++ctx.indentation_level;
 
-               using non_const_types = typename tuple_types<Tuple>::glaze_non_const_types;
-               if constexpr (glz::tuple_size_v < non_const_types >> 0) {
-                  using V = glz::tuple_element_t<0, non_const_types>;
-                  if (!std::holds_alternative<V>(value)) value = V{};
-                  read<json>::op<ws_handled<Options>()>(std::get<V>(value), ctx, it, end);
+               ++it;
+               if constexpr (not Opts.null_terminated) {
+                  if (it == end) [[unlikely]] {
+                     ctx.error = error_code::unexpected_end;
+                     return;
+                  }
                }
-               else {
+               using type_counts = variant_type_count<T>;
+               using object_types = typename variant_types<T>::object_types;
+               if constexpr ((type_counts::n_object < 1) //
+                             && (type_counts::n_nullable_object < 1)) {
                   ctx.error = error_code::no_matching_variant_type;
-               }
-            }
-         }
-      };
-
-      template <is_variant T>
-      struct from_json<T>
-      {
-         // Note that items in the variant are required to be default constructable for us to switch types
-         template <auto Options>
-         static void op(auto&& value, is_context auto&& ctx, auto&& it, auto&& end)
-         {
-            constexpr auto Opts = ws_handled_off<Options>();
-            if constexpr (variant_is_auto_deducible<T>()) {
-               if constexpr (!Options.ws_handled) {
-                  GLZ_SKIP_WS;
-               }
-
-               switch (*it) {
-               case '\0':
-                  ctx.error = error_code::unexpected_end;
                   return;
-               case '{':
-                  ++it;
-                  using object_types = typename variant_types<T>::object_types;
-                  if constexpr (glz::tuple_size_v<object_types> < 1) {
-                     ctx.error = error_code::no_matching_variant_type;
-                     return;
+               }
+               else if constexpr ((type_counts::n_object + type_counts::n_nullable_object) == 1 && tag_v<T>.empty()) {
+                  using V = glz::tuple_element_t<0, object_types>;
+                  if (!std::holds_alternative<V>(value)) value = V{};
+                  parse<JSON>::op<opening_handled<Opts>()>(std::get<V>(value), ctx, it, end);
+                  if constexpr (Opts.null_terminated) {
+                     // In the null terminated case this guards for stack overflow
+                     // Depth counting is done at the object level when not null terminated
+                     --ctx.indentation_level;
                   }
-                  else if constexpr (glz::tuple_size_v<object_types> == 1) {
-                     using V = glz::tuple_element_t<0, object_types>;
-                     if (!std::holds_alternative<V>(value)) value = V{};
-                     read<json>::op<opening_handled<Opts>()>(std::get<V>(value), ctx, it, end);
+                  return;
+               }
+               else {
+                  auto possible_types = bit_array<std::variant_size_v<T>>{}.flip();
+                  static constexpr auto deduction_map = make_variant_deduction_map<T>();
+                  static constexpr auto tag_literal = string_literal_from_view<tag_v<T>.size()>(tag_v<T>);
+                  if (skip_ws<Opts>(ctx, it, end)) {
                      return;
                   }
-                  else {
-                     auto possible_types = bit_array<std::variant_size_v<T>>{}.flip();
-                     static constexpr auto deduction_map = detail::make_variant_deduction_map<T>();
-                     static constexpr auto tag_literal = string_literal_from_view<tag_v<T>.size()>(tag_v<T>);
-                     GLZ_SKIP_WS;
-                     auto start = it;
-                     while (*it != '}') {
-                        if (it != start) {
-                           GLZ_MATCH_COMMA;
-                        }
-                        const sv key = parse_object_key<T, Opts, tag_literal>(ctx, it, end);
-                        if (bool(ctx.error)) [[unlikely]]
+                  auto start = it;
+                  while (*it != '}') {
+                     if (it != start) {
+                        if (match_invalid_end<',', Opts>(ctx, it, end)) {
                            return;
-                        GLZ_MATCH_QUOTE;
-
-                        if constexpr (deduction_map.size()) {
-                           // We first check if a tag is defined and see if the key matches the tag
-                           if constexpr (!tag_v<T>.empty()) {
-                              if (key == tag_v<T>) {
-                                 parse_object_entry_sep<Opts>(ctx, it, end);
-                                 if (bool(ctx.error)) [[unlikely]]
-                                    return;
-                                 std::string_view type_id{};
-                                 read<json>::op<ws_handled<Opts>()>(type_id, ctx, it, end);
-                                 if (bool(ctx.error)) [[unlikely]]
-                                    return;
-                                 GLZ_SKIP_WS;
-                                 if (!(*it == ',' || *it == '}')) {
-                                    ctx.error = error_code::syntax_error;
-                                    return;
-                                 }
+                        }
+                     }
 
-                                 static constexpr auto id_map = make_variant_id_map<T>();
-                                 auto id_it = id_map.find(type_id);
-                                 if (id_it != id_map.end()) [[likely]] {
-                                    it = start;
-                                    const auto type_index = id_it->second;
-                                    if (value.index() != type_index) value = runtime_variant_map<T>()[type_index];
-                                    std::visit(
-                                       [&](auto&& v) {
-                                          using V = std::decay_t<decltype(v)>;
-                                          constexpr bool is_object = glaze_object_t<V> || reflectable<V>;
-                                          if constexpr (is_object) {
-                                             from_json<V>::template op<opening_handled<Opts>(), tag_literal>(v, ctx, it,
-                                                                                                             end);
-                                          }
-                                       },
-                                       value);
-                                    return; // we've decoded our target type
-                                 }
-                                 else {
-                                    ctx.error = error_code::no_matching_variant_type;
-                                    return;
-                                 }
-                              }
-                           }
+                     if (skip_ws<Opts>(ctx, it, end)) {
+                        return;
+                     }
+                     if (match_invalid_end<'"', Opts>(ctx, it, end)) {
+                        return;
+                     }
 
-                           auto deduction_it = deduction_map.find(key);
-                           if (deduction_it != deduction_map.end()) [[likely]] {
-                              possible_types &= deduction_it->second;
-                           }
-                           else if constexpr (Opts.error_on_unknown_keys) {
-                              ctx.error = error_code::unknown_key;
-                              return;
-                           }
-                        }
-                        else if constexpr (!tag_v<T>.empty()) {
-                           // empty object case for variant, if there are no normal elements
+                     auto* key_start = it;
+                     skip_string_view<Opts>(ctx, it, end);
+                     if (bool(ctx.error)) [[unlikely]]
+                        return;
+                     const sv key = {key_start, size_t(it - key_start)};
+
+                     if (match_invalid_end<'"', Opts>(ctx, it, end)) {
+                        return;
+                     }
+
+                     if constexpr (deduction_map.size()) {
+                        // We first check if a tag is defined and see if the key matches the tag
+                        if constexpr (not tag_v<T>.empty()) {
                            if (key == tag_v<T>) {
-                              parse_object_entry_sep<Opts>(ctx, it, end);
-                              if (bool(ctx.error)) [[unlikely]]
+                              if (parse_ws_colon<Opts>(ctx, it, end)) {
                                  return;
+                              }
+
+                              using id_type = std::decay_t<decltype(ids_v<T>[0])>;
 
-                              std::string_view type_id{};
-                              read<json>::op<ws_handled<Opts>()>(type_id, ctx, it, end);
+                              std::conditional_t<std::integral<id_type>, id_type, sv> type_id{};
+                              if constexpr (std::integral<id_type>) {
+                                 from<JSON, id_type>::template op<ws_handled<Opts>()>(type_id, ctx, it, end);
+                              }
+                              else {
+                                 from<JSON, sv>::template op<ws_handled<Opts>()>(type_id, ctx, it, end);
+                              }
                               if (bool(ctx.error)) [[unlikely]]
                                  return;
-                              GLZ_SKIP_WS;
+                              if (skip_ws<Opts>(ctx, it, end)) {
+                                 return;
+                              }
+                              if (!(*it == ',' || *it == '}')) [[unlikely]] {
+                                 ctx.error = error_code::syntax_error;
+                                 return;
+                              }
 
                               static constexpr auto id_map = make_variant_id_map<T>();
                               auto id_it = id_map.find(type_id);
                               if (id_it != id_map.end()) [[likely]] {
-                                 it = start;
+                                 it = start; // we restart our object parsing now that we know the target type
                                  const auto type_index = id_it->second;
                                  if (value.index() != type_index) value = runtime_variant_map<T>()[type_index];
-                                 return;
+                                 std::visit(
+                                    [&](auto&& v) {
+                                       using V = std::decay_t<decltype(v)>;
+                                       constexpr bool is_object = glaze_object_t<V> || reflectable<V>;
+                                       if constexpr (is_object) {
+                                          from<JSON, V>::template op<opening_handled<Opts>(), tag_literal>(v, ctx, it,
+                                                                                                           end);
+                                       }
+                                       else if constexpr (is_memory_object<V>) {
+                                          if (!v) {
+                                             if constexpr (is_specialization_v<V, std::optional>) {
+                                                if constexpr (requires { v.emplace(); }) {
+                                                   v.emplace();
+                                                }
+                                                else {
+                                                   v = typename V::value_type{};
+                                                }
+                                             }
+                                             else if constexpr (is_specialization_v<V, std::unique_ptr>)
+                                                v = std::make_unique<typename V::element_type>();
+                                             else if constexpr (is_specialization_v<V, std::shared_ptr>)
+                                                v = std::make_shared<typename V::element_type>();
+                                             else if constexpr (constructible<V>) {
+                                                v = meta_construct_v<V>();
+                                             }
+                                             else {
+                                                ctx.error = error_code::invalid_nullable_read;
+                                                return;
+                                                // Cannot read into unset nullable that is not std::optional,
+                                                // std::unique_ptr, or std::shared_ptr
+                                             }
+                                          }
+                                          from<JSON, memory_type<V>>::template op<opening_handled<Opts>(), tag_literal>(
+                                             *v, ctx, it, end);
+                                       }
+                                    },
+                                    value);
+
+                                 if constexpr (Opts.null_terminated) {
+                                    // In the null terminated case this guards for stack overflow
+                                    // Depth counting is done at the object level when not null terminated
+                                    --ctx.indentation_level;
+                                 }
+                                 return; // we've decoded our target type
                               }
-                              else {
+                              else [[unlikely]] {
                                  ctx.error = error_code::no_matching_variant_type;
                                  return;
                               }
                            }
-                           else if constexpr (Opts.error_on_unknown_keys) {
-                              ctx.error = error_code::unknown_key;
-                              return;
-                           }
+                        }
+
+                        auto deduction_it = deduction_map.find(key);
+                        if (deduction_it != deduction_map.end()) [[likely]] {
+                           possible_types &= deduction_it->second;
                         }
                         else if constexpr (Opts.error_on_unknown_keys) {
                            ctx.error = error_code::unknown_key;
                            return;
                         }
+                     }
+                     else if constexpr (not tag_v<T>.empty()) {
+                        // empty object case for variant, if there are no normal elements
+                        if (key == tag_v<T>) {
+                           if (parse_ws_colon<Opts>(ctx, it, end)) {
+                              return;
+                           }
+
+                           std::string_view type_id{};
+                           parse<JSON>::op<ws_handled<Opts>()>(type_id, ctx, it, end);
+                           if (bool(ctx.error)) [[unlikely]]
+                              return;
+                           if (skip_ws<Opts>(ctx, it, end)) {
+                              return;
+                           }
 
-                        auto matching_types = possible_types.popcount();
-                        if (matching_types == 0) {
-                           ctx.error = error_code::no_matching_variant_type;
+                           static constexpr auto id_map = make_variant_id_map<T>();
+                           auto id_it = id_map.find(type_id);
+                           if (id_it != id_map.end()) [[likely]] {
+                              it = start;
+                              const auto type_index = id_it->second;
+                              if (value.index() != type_index) value = runtime_variant_map<T>()[type_index];
+                              return;
+                           }
+                           else {
+                              ctx.error = error_code::no_matching_variant_type;
+                              return;
+                           }
+                        }
+                        else if constexpr (Opts.error_on_unknown_keys) {
+                           ctx.error = error_code::unknown_key;
                            return;
                         }
-                        else if (matching_types == 1) {
-                           it = start;
-                           const auto type_index = possible_types.countr_zero();
-                           if (value.index() != static_cast<size_t>(type_index))
-                              value = runtime_variant_map<T>()[type_index];
-                           std::visit(
-                              [&](auto&& v) {
-                                 using V = std::decay_t<decltype(v)>;
-                                 constexpr bool is_object = glaze_object_t<V> || reflectable<V>;
-                                 if constexpr (is_object) {
-                                    from_json<V>::template op<opening_handled<Opts>(), tag_literal>(v, ctx, it, end);
+                     }
+                     else if constexpr (Opts.error_on_unknown_keys) {
+                        ctx.error = error_code::unknown_key;
+                        return;
+                     }
+
+                     auto matching_types = possible_types.popcount();
+                     if (matching_types == 0) {
+                        ctx.error = error_code::no_matching_variant_type;
+                        return;
+                     }
+                     else if (matching_types == 1) {
+                        it = start;
+                        const auto type_index = possible_types.countr_zero();
+                        if (value.index() != static_cast<size_t>(type_index))
+                           value = runtime_variant_map<T>()[type_index];
+                        std::visit(
+                           [&](auto&& v) {
+                              using V = std::decay_t<decltype(v)>;
+                              constexpr bool is_object = glaze_object_t<V> || reflectable<V>;
+                              if constexpr (is_object) {
+                                 from<JSON, V>::template op<opening_handled<Opts>(), tag_literal>(v, ctx, it, end);
+                              }
+                              else if constexpr (is_memory_object<V>) {
+                                 if (!v) {
+                                    if constexpr (is_specialization_v<V, std::optional>) {
+                                       if constexpr (requires { v.emplace(); }) {
+                                          v.emplace();
+                                       }
+                                       else {
+                                          v = typename V::value_type{};
+                                       }
+                                    }
+                                    else if constexpr (is_specialization_v<V, std::unique_ptr>)
+                                       v = std::make_unique<typename V::element_type>();
+                                    else if constexpr (is_specialization_v<V, std::shared_ptr>)
+                                       v = std::make_shared<typename V::element_type>();
+                                    else if constexpr (constructible<V>) {
+                                       v = meta_construct_v<V>();
+                                    }
+                                    else {
+                                       ctx.error = error_code::invalid_nullable_read;
+                                       return;
+                                       // Cannot read into unset nullable that is not std::optional,
+                                       // std::unique_ptr, or std::shared_ptr
+                                    }
                                  }
-                              },
-                              value);
-                           return;
+                                 from<JSON, memory_type<V>>::template op<opening_handled<Opts>(), tag_literal>(*v, ctx,
+                                                                                                               it, end);
+                              }
+                           },
+                           value);
+
+                        if constexpr (Opts.null_terminated) {
+                           // In the null terminated case this guards for stack overflow
+                           // Depth counting is done at the object level when not null terminated
+                           --ctx.indentation_level;
                         }
-                        parse_object_entry_sep<Opts>(ctx, it, end);
-                        if (bool(ctx.error)) [[unlikely]]
-                           return;
+                        return; // we've decoded our target type
+                     }
+                     if (parse_ws_colon<Opts>(ctx, it, end)) {
+                        return;
+                     }
 
-                        skip_value<Opts>(ctx, it, end);
-                        if (bool(ctx.error)) [[unlikely]]
-                           return;
-                        GLZ_SKIP_WS;
+                     skip_value<JSON>::op<Opts>(ctx, it, end);
+                     if (bool(ctx.error)) [[unlikely]]
+                        return;
+                     if (skip_ws<Opts>(ctx, it, end)) {
+                        return;
                      }
-                     ctx.error = error_code::no_matching_variant_type;
-                  }
-                  break;
-               case '[':
-                  using array_types = typename variant_types<T>::array_types;
-                  process_arithmetic_boolean_string_or_array<array_types>::template op<Opts>(value, ctx, it, end);
-                  break;
-               case '"': {
-                  using string_types = typename variant_types<T>::string_types;
-                  process_arithmetic_boolean_string_or_array<string_types>::template op<Opts>(value, ctx, it, end);
-                  break;
-               }
-               case 't':
-               case 'f': {
-                  using bool_types = typename variant_types<T>::bool_types;
-                  process_arithmetic_boolean_string_or_array<bool_types>::template op<Opts>(value, ctx, it, end);
-                  break;
-               }
-               case 'n':
-                  using nullable_types = typename variant_types<T>::nullable_types;
-                  if constexpr (glz::tuple_size_v<nullable_types> < 1) {
-                     ctx.error = error_code::no_matching_variant_type;
-                  }
-                  else {
-                     using V = glz::tuple_element_t<0, nullable_types>;
-                     if (!std::holds_alternative<V>(value)) value = V{};
-                     match<"null", Opts>(ctx, it, end);
                   }
-                  break;
-               default: {
-                  // Not bool, string, object, or array so must be number or null
-                  using number_types = typename variant_types<T>::number_types;
-                  process_arithmetic_boolean_string_or_array<number_types>::template op<Opts>(value, ctx, it, end);
+                  ctx.error = error_code::no_matching_variant_type;
+               }
+               break;
+            case '[':
+               using array_types = typename variant_types<T>::array_types;
+
+               if (ctx.indentation_level >= max_recursive_depth_limit) {
+                  ctx.error = error_code::exceeded_max_recursive_depth;
+                  return;
+               }
+               if constexpr (Opts.null_terminated) {
+                  // In the null terminated case this guards for stack overflow
+                  // Depth counting is done at the object level when not null terminated
+                  ++ctx.indentation_level;
+               }
+               process_arithmetic_boolean_string_or_array<array_types>::template op<Opts>(value, ctx, it, end);
+               if constexpr (Opts.null_terminated) {
+                  --ctx.indentation_level;
+               }
+               break;
+            case '"': {
+               using string_types = typename variant_types<T>::string_types;
+               process_arithmetic_boolean_string_or_array<string_types>::template op<Opts>(value, ctx, it, end);
+               break;
+            }
+            case 't':
+            case 'f': {
+               using bool_types = typename variant_types<T>::bool_types;
+               process_arithmetic_boolean_string_or_array<bool_types>::template op<Opts>(value, ctx, it, end);
+               break;
+            }
+            case 'n':
+               using nullable_types = typename variant_types<T>::nullable_types;
+               if constexpr (glz::tuple_size_v<nullable_types> < 1) {
+                  ctx.error = error_code::no_matching_variant_type;
                }
+               else {
+                  using V = glz::tuple_element_t<0, nullable_types>;
+                  if (!std::holds_alternative<V>(value)) value = V{};
+                  match<"null", Opts>(ctx, it, end);
                }
+               break;
+            default: {
+               // Not bool, string, object, or array so must be number or null
+               using number_types = typename variant_types<T>::number_types;
+               process_arithmetic_boolean_string_or_array<number_types>::template op<Opts>(value, ctx, it, end);
             }
-            else {
-               std::visit([&](auto&& v) { read<json>::op<Options>(v, ctx, it, end); }, value);
             }
          }
-      };
+         else {
+            std::visit([&](auto&& v) { parse<JSON>::op<Options>(v, ctx, it, end); }, value);
+         }
+      }
+   };
 
-      template <class T>
-      struct from_json<array_variant_wrapper<T>>
+   template <class T>
+   struct from<JSON, array_variant_wrapper<T>>
+   {
+      template <auto Options>
+      static void op(auto&& wrapper, is_context auto&& ctx, auto&& it, auto&& end)
       {
-         template <auto Options>
-         static void op(auto&& wrapper, is_context auto&& ctx, auto&& it, auto&& end)
-         {
-            auto& value = wrapper.value;
+         auto& value = wrapper.value;
 
-            constexpr auto Opts = ws_handled_off<Options>();
-            if constexpr (!Options.ws_handled) {
-               GLZ_SKIP_WS;
+         constexpr auto Opts = ws_handled_off<Options>();
+         if constexpr (!check_ws_handled(Options)) {
+            if (skip_ws<Opts>(ctx, it, end)) {
+               return;
             }
+         }
 
-            GLZ_MATCH_OPEN_BRACKET;
-            GLZ_SKIP_WS;
+         if (match_invalid_end<'[', Opts>(ctx, it, end)) {
+            return;
+         }
+         if constexpr (not Opts.null_terminated) {
+            ++ctx.indentation_level;
+         }
+         if (skip_ws<Opts>(ctx, it, end)) {
+            return;
+         }
 
-            // TODO Use key parsing for compiletime known keys
-            GLZ_MATCH_QUOTE;
-            auto start = it;
-            skip_string_view<Opts>(ctx, it, end);
-            if (bool(ctx.error)) [[unlikely]]
+         // TODO Use key parsing for compiletime known keys
+         if (match_invalid_end<'"', Opts>(ctx, it, end)) {
+            return;
+         }
+         auto start = it;
+         skip_string_view<Opts>(ctx, it, end);
+         if (bool(ctx.error)) [[unlikely]]
+            return;
+         sv type_id = {start, size_t(it - start)};
+         if (match<'"'>(ctx, it)) {
+            return;
+         }
+         if constexpr (not Opts.null_terminated) {
+            if (it == end) {
+               ctx.error = error_code::end_reached;
                return;
-            sv type_id = {start, size_t(it - start)};
-            GLZ_MATCH_QUOTE;
-
-            static constexpr auto id_map = make_variant_id_map<T>();
-            auto id_it = id_map.find(type_id);
-            if (id_it != id_map.end()) [[likely]] {
-               GLZ_SKIP_WS;
-               GLZ_MATCH_COMMA;
-               const auto type_index = id_it->second;
-               if (value.index() != type_index) value = runtime_variant_map<T>()[type_index];
-               std::visit([&](auto&& v) { read<json>::op<Opts>(v, ctx, it, end); }, value);
-               if (bool(ctx.error)) [[unlikely]]
-                  return;
             }
-            else {
-               ctx.error = error_code::no_matching_variant_type;
+         }
+
+         static constexpr auto id_map = make_variant_id_map<T>();
+         auto id_it = id_map.find(type_id);
+         if (id_it != id_map.end()) [[likely]] {
+            if (skip_ws<Opts>(ctx, it, end)) {
+               return;
+            }
+            if (match_invalid_end<',', Opts>(ctx, it, end)) {
                return;
             }
+            const auto type_index = id_it->second;
+            if (value.index() != type_index) value = runtime_variant_map<T>()[type_index];
+            std::visit([&](auto&& v) { parse<JSON>::op<Opts>(v, ctx, it, end); }, value);
+            if (bool(ctx.error)) [[unlikely]]
+               return;
+         }
+         else {
+            ctx.error = error_code::no_matching_variant_type;
+            return;
+         }
 
-            GLZ_SKIP_WS;
-            match<']'>(ctx, it);
+         if (skip_ws<Opts>(ctx, it, end)) {
+            return;
+         }
+         match<']'>(ctx, it);
+         if constexpr (not Opts.null_terminated) {
+            --ctx.indentation_level;
          }
-      };
+      }
+   };
 
-      template <is_expected T>
-      struct from_json<T>
+   template <is_expected T>
+   struct from<JSON, T>
+   {
+      template <auto Opts, class... Args>
+      static void op(auto&& value, is_context auto&& ctx, auto&& it, auto&& end)
       {
-         template <auto Opts, class... Args>
-         static void op(auto&& value, is_context auto&& ctx, auto&& it, auto&& end) noexcept
-         {
-            if constexpr (!Opts.ws_handled) {
-               GLZ_SKIP_WS;
+         if constexpr (!check_ws_handled(Opts)) {
+            if (skip_ws<Opts>(ctx, it, end)) {
+               return;
             }
+         }
 
-            if (*it == '{') {
-               auto start = it;
-               ++it;
-               GLZ_SKIP_WS;
-               if (*it == '}') {
-                  it = start;
-                  // empty object
-                  if (value) {
-                     read<json>::op<Opts>(*value, ctx, it, end);
+         if (*it == '{') {
+            if constexpr (not Opts.null_terminated) {
+               ++ctx.indentation_level;
+            }
+            auto start = it;
+            ++it;
+            if constexpr (not Opts.null_terminated) {
+               if (it == end) [[unlikely]] {
+                  ctx.error = error_code::unexpected_end;
+                  return;
+               }
+            }
+            if (skip_ws<Opts>(ctx, it, end)) {
+               return;
+            }
+            if (*it == '}') {
+               it = start;
+               // empty object
+               if (value) {
+                  parse<JSON>::op<Opts>(*value, ctx, it, end);
+               }
+               else {
+                  value.emplace();
+                  parse<JSON>::op<Opts>(*value, ctx, it, end);
+               }
+            }
+            else {
+               // either we have an unexpected value or we are decoding an object
+               auto& key = string_buffer();
+               parse<JSON>::op<Opts>(key, ctx, it, end);
+               if (bool(ctx.error)) [[unlikely]]
+                  return;
+               if (key == "unexpected") {
+                  if (skip_ws<Opts>(ctx, it, end)) {
+                     return;
+                  }
+                  if (match_invalid_end<':', Opts>(ctx, it, end)) {
+                     return;
+                  }
+                  // read in unexpected value
+                  if (!value) {
+                     parse<JSON>::op<Opts>(value.error(), ctx, it, end);
+                     if (bool(ctx.error)) [[unlikely]]
+                        return;
                   }
                   else {
-                     value.emplace();
-                     read<json>::op<Opts>(*value, ctx, it, end);
+                     // set value to unexpected
+                     using error_ctx = typename std::decay_t<decltype(value)>::error_type;
+                     std::decay_t<error_ctx> error{};
+                     parse<JSON>::op<Opts>(error, ctx, it, end);
+                     if (bool(ctx.error)) [[unlikely]]
+                        return;
+                     value = glz::unexpected(error);
+                  }
+                  if (skip_ws<Opts>(ctx, it, end)) {
+                     return;
+                  }
+                  match<'}'>(ctx, it);
+                  if constexpr (not Opts.null_terminated) {
+                     --ctx.indentation_level;
                   }
                }
                else {
-                  // either we have an unexpected value or we are decoding an object
-                  auto& key = string_buffer();
-                  read<json>::op<Opts>(key, ctx, it, end);
-                  if (bool(ctx.error)) [[unlikely]]
-                     return;
-                  if (key == "unexpected") {
-                     GLZ_SKIP_WS;
-                     GLZ_MATCH_COLON;
-                     // read in unexpected value
-                     if (!value) {
-                        read<json>::op<Opts>(value.error(), ctx, it, end);
-                        if (bool(ctx.error)) [[unlikely]]
-                           return;
-                     }
-                     else {
-                        // set value to unexpected
-                        using error_ctx = typename std::decay_t<decltype(value)>::error_type;
-                        std::decay_t<error_ctx> error{};
-                        read<json>::op<Opts>(error, ctx, it, end);
-                        if (bool(ctx.error)) [[unlikely]]
-                           return;
-                        value = glz::unexpected(error);
-                     }
-                     GLZ_SKIP_WS;
-                     GLZ_MATCH_CLOSE_BRACE;
+                  it = start;
+                  if (value) {
+                     parse<JSON>::op<Opts>(*value, ctx, it, end);
                   }
                   else {
-                     it = start;
-                     if (value) {
-                        read<json>::op<Opts>(*value, ctx, it, end);
-                     }
-                     else {
-                        value.emplace();
-                        read<json>::op<Opts>(*value, ctx, it, end);
-                     }
+                     value.emplace();
+                     parse<JSON>::op<Opts>(*value, ctx, it, end);
                   }
                }
             }
+         }
+         else {
+            // this is not an object and therefore cannot be an unexpected value
+            if (value) {
+               parse<JSON>::op<Opts>(*value, ctx, it, end);
+            }
             else {
-               // this is not an object and therefore cannot be an unexpected value
-               if (value) {
-                  read<json>::op<Opts>(*value, ctx, it, end);
-               }
-               else {
-                  value.emplace();
-                  read<json>::op<Opts>(*value, ctx, it, end);
-               }
+               value.emplace();
+               parse<JSON>::op<Opts>(*value, ctx, it, end);
             }
          }
-      };
+      }
+   };
 
-      template <nullable_t T>
-         requires(std::is_array_v<T>)
-      struct from_json<T>
+   template <nullable_t T>
+      requires(std::is_array_v<T>)
+   struct from<JSON, T>
+   {
+      template <auto Opts, class V, size_t N>
+      GLZ_ALWAYS_INLINE static void op(V (&value)[N], is_context auto&& ctx, auto&& it, auto&& end) noexcept
       {
-         template <auto Opts, class V, size_t N>
-         GLZ_ALWAYS_INLINE static void op(V (&value)[N], is_context auto&& ctx, auto&& it, auto&& end) noexcept
-         {
-            read<json>::op<Opts>(std::span{value, N}, ctx, it, end);
-         }
-      };
+         parse<JSON>::op<Opts>(std::span{value, N}, ctx, it, end);
+      }
+   };
 
-      template <nullable_t T>
-         requires(!is_expected<T> && !std::is_array_v<T>)
-      struct from_json<T>
+   template <class T>
+      requires((nullable_t<T> || nullable_value_t<T>) && not is_expected<T> && not std::is_array_v<T> &&
+               not custom_read<T>)
+   struct from<JSON, T>
+   {
+      template <auto Options>
+      static void op(auto&& value, is_context auto&& ctx, auto&& it, auto&& end)
       {
-         template <auto Options>
-         static void op(auto&& value, is_context auto&& ctx, auto&& it, auto&& end) noexcept
-         {
-            constexpr auto Opts = ws_handled_off<Options>();
-            if constexpr (!Options.ws_handled) {
-               GLZ_SKIP_WS;
+         constexpr auto Opts = ws_handled_off<Options>();
+         if constexpr (!check_ws_handled(Options)) {
+            if (skip_ws<Opts>(ctx, it, end)) {
+               return;
             }
+         }
 
-            if (*it == 'n') {
-               ++it;
-               match<"ull", Opts>(ctx, it, end);
-               if (bool(ctx.error)) [[unlikely]]
+         if (*it == 'n') {
+            ++it;
+            if constexpr (not Opts.null_terminated) {
+               if (it == end) [[unlikely]] {
+                  ctx.error = error_code::unexpected_end;
                   return;
-               if constexpr (!std::is_pointer_v<T>) {
-                  value.reset();
                }
             }
+            match<"ull", Opts>(ctx, it, end);
+            if (bool(ctx.error)) [[unlikely]]
+               return;
+            if constexpr (requires { value.reset(); }) {
+               value.reset();
+            }
+         }
+         else {
+            if constexpr (nullable_value_t<T>) {
+               if (not value.has_value()) {
+                  if constexpr (constructible<T>) {
+                     value = meta_construct_v<T>();
+                  }
+                  else if constexpr (requires { value.emplace(); }) {
+                     value.emplace();
+                  }
+                  else {
+                     static_assert(false_v<T>,
+                                   "Your nullable type must have `emplace()` or be glz::meta constructible, or "
+                                   "create a custom glz::from specialization");
+                  }
+               }
+               parse<JSON>::op<Opts>(value.value(), ctx, it, end);
+            }
             else {
                if (!value) {
-                  if constexpr (is_specialization_v<T, std::optional>) {
+                  if constexpr (optional_like<T>) {
                      if constexpr (requires { value.emplace(); }) {
                         value.emplace();
                      }
@@ -2544,56 +3215,69 @@ namespace glz
                      value = meta_construct_v<T>();
                   }
                   else {
+                     // Cannot read into a null raw pointer
                      ctx.error = error_code::invalid_nullable_read;
                      return;
-                     // Cannot read into unset nullable that is not std::optional, std::unique_ptr, or std::shared_ptr
                   }
                }
-               read<json>::op<Opts>(*value, ctx, it, end);
+               parse<JSON>::op<Opts>(*value, ctx, it, end);
             }
          }
-      };
+      }
+   };
 
-      template <filesystem_path T>
-      struct from_json<T>
+   template <filesystem_path T>
+   struct from<JSON, T>
+   {
+      template <auto Opts>
+      static void op(auto&& value, is_context auto&& ctx, auto&& it, auto&& end)
       {
-         template <auto Opts>
-         GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, auto&& it, auto&& end) noexcept
-         {
-            std::string& buffer = string_buffer();
-            read<json>::op<Opts>(buffer, ctx, it, end);
+         std::string& buffer = string_buffer();
+         parse<JSON>::op<Opts>(buffer, ctx, it, end);
+         if constexpr (Opts.null_terminated) {
             if (bool(ctx.error)) [[unlikely]]
                return;
-            value = buffer;
          }
-      };
-   } // namespace detail
+         else {
+            if (size_t(ctx.error) > size_t(error_code::end_reached)) [[unlikely]] {
+               return;
+            }
+         }
+         value = buffer;
+      }
+   };
 
-   template <class Buffer>
+   struct opts_validate : opts
+   {
+      bool validate_skipped = true;
+      bool validate_trailing_whitespace = true;
+   };
+
+   template <is_buffer Buffer>
    [[nodiscard]] error_ctx validate_json(Buffer&& buffer) noexcept
    {
       context ctx{};
       glz::skip skip_value{};
-      return read<opts{.force_conformance = true}>(skip_value, std::forward<Buffer>(buffer), ctx);
+      return read<opts_validate{}>(skip_value, std::forward<Buffer>(buffer), ctx);
    }
 
-   template <class Buffer>
+   template <is_buffer Buffer>
    [[nodiscard]] error_ctx validate_jsonc(Buffer&& buffer) noexcept
    {
       context ctx{};
       glz::skip skip_value{};
-      return read<opts{}>(skip_value, std::forward<Buffer>(buffer), ctx);
+      return read<opts_validate{{opts{.comments = true}}}>(skip_value, std::forward<Buffer>(buffer), ctx);
    }
 
-   template <read_json_supported T, class Buffer>
-   [[nodiscard]] error_ctx read_json(T& value, Buffer&& buffer) noexcept
+   template <read_supported<JSON> T, is_buffer Buffer>
+   [[nodiscard]] error_ctx read_json(T& value, Buffer&& buffer)
    {
       context ctx{};
       return read<opts{}>(value, std::forward<Buffer>(buffer), ctx);
    }
 
-   template <read_json_supported T, class Buffer>
-   [[nodiscard]] expected<T, error_ctx> read_json(Buffer&& buffer) noexcept
+   template <read_supported<JSON> T, is_buffer Buffer>
+   [[nodiscard]] expected<T, error_ctx> read_json(Buffer&& buffer)
    {
       T value{};
       context ctx{};
@@ -2604,15 +3288,15 @@ namespace glz
       return value;
    }
 
-   template <read_json_supported T, class Buffer>
-   [[nodiscard]] error_ctx read_jsonc(T& value, Buffer&& buffer) noexcept
+   template <read_supported<JSON> T, is_buffer Buffer>
+   [[nodiscard]] error_ctx read_jsonc(T& value, Buffer&& buffer)
    {
       context ctx{};
       return read<opts{.comments = true}>(value, std::forward<Buffer>(buffer), ctx);
    }
 
-   template <read_json_supported T, class Buffer>
-   [[nodiscard]] expected<T, error_ctx> read_jsonc(Buffer&& buffer) noexcept
+   template <read_supported<JSON> T, is_buffer Buffer>
+   [[nodiscard]] expected<T, error_ctx> read_jsonc(Buffer&& buffer)
    {
       T value{};
       context ctx{};
@@ -2623,8 +3307,8 @@ namespace glz
       return value;
    }
 
-   template <auto Opts = opts{}, read_json_supported T>
-   [[nodiscard]] error_ctx read_file_json(T& value, const sv file_name, auto&& buffer) noexcept
+   template <auto Opts = opts{}, read_supported<JSON> T, is_buffer Buffer>
+   [[nodiscard]] error_ctx read_file_json(T& value, const sv file_name, Buffer&& buffer)
    {
       context ctx{};
       ctx.current_file = file_name;
@@ -2638,8 +3322,8 @@ namespace glz
       return read<set_json<Opts>()>(value, buffer, ctx);
    }
 
-   template <auto Opts = opts{}, read_json_supported T>
-   [[nodiscard]] error_ctx read_file_jsonc(T& value, const sv file_name, auto&& buffer) noexcept
+   template <auto Opts = opts{}, read_supported<JSON> T, is_buffer Buffer>
+   [[nodiscard]] error_ctx read_file_jsonc(T& value, const sv file_name, Buffer&& buffer)
    {
       context ctx{};
       ctx.current_file = file_name;
@@ -2654,3 +3338,8 @@ namespace glz
       return read<Options>(value, buffer, ctx);
    }
 }
+
+#ifdef _MSC_VER
+// restore disabled warnings
+#pragma warning(pop)
+#endif
diff --git a/deps/saucer/include/glaze/json/schema.hpp b/deps/saucer/include/glaze/json/schema.hpp
index e1b31e6..74e97ab 100644
--- a/deps/saucer/include/glaze/json/schema.hpp
+++ b/deps/saucer/include/glaze/json/schema.hpp
@@ -25,7 +25,7 @@ namespace glz
 {
    namespace detail
    {
-      enum struct defined_formats : std::uint8_t;
+      enum struct defined_formats : uint32_t;
       struct ExtUnits final
       {
          std::optional<std::string_view> unitAscii{}; // ascii representation of the unit, e.g. "m^2" for square meters
@@ -38,21 +38,21 @@ namespace glz
    {
       bool reflection_helper{}; // needed to support automatic reflection, because ref is a std::optional
       std::optional<std::string_view> ref{};
-      using schema_number = std::optional<std::variant<std::int64_t, std::uint64_t, double>>;
-      using schema_any = std::variant<std::monostate, bool, std::int64_t, std::uint64_t, double, std::string_view>;
+      using schema_number = std::optional<std::variant<int64_t, uint64_t, double>>;
+      using schema_any = std::variant<std::monostate, bool, int64_t, uint64_t, double, std::string_view>;
       // meta data keywords, ref: https://www.learnjsonschema.com/2020-12/meta-data/
       std::optional<std::string_view> title{};
       std::optional<std::string_view> description{};
       std::optional<schema_any> defaultValue{};
       std::optional<bool> deprecated{};
-      std::optional<std::span<const std::string_view>> examples{};
+      std::optional<std::vector<std::string_view>> examples{};
       std::optional<bool> readOnly{};
       std::optional<bool> writeOnly{};
       // hereafter validation keywords, ref: https://www.learnjsonschema.com/2020-12/validation/
       std::optional<schema_any> constant{};
       // string only keywords
-      std::optional<std::uint64_t> minLength{};
-      std::optional<std::uint64_t> maxLength{};
+      std::optional<uint64_t> minLength{};
+      std::optional<uint64_t> maxLength{};
       std::optional<std::string_view> pattern{};
       // https://www.learnjsonschema.com/2020-12/format-annotation/format/
       std::optional<detail::defined_formats> format{};
@@ -63,18 +63,18 @@ namespace glz
       schema_number exclusiveMaximum{};
       schema_number multipleOf{};
       // object only keywords
-      std::optional<std::uint64_t> minProperties{};
-      std::optional<std::uint64_t> maxProperties{};
-      //      std::optional<std::map<std::string_view, std::vector<std::string_view>>> dependent_required{};
-      std::optional<std::span<const std::string_view>> required{};
+      std::optional<uint64_t> minProperties{};
+      std::optional<uint64_t> maxProperties{};
+      // std::optional<std::map<std::string_view, std::vector<std::string_view>>> dependent_required{};
+      std::optional<std::vector<std::string_view>> required{};
       // array only keywords
-      std::optional<std::uint64_t> minItems{};
-      std::optional<std::uint64_t> maxItems{};
-      std::optional<std::uint64_t> minContains{};
-      std::optional<std::uint64_t> maxContains{};
+      std::optional<uint64_t> minItems{};
+      std::optional<uint64_t> maxItems{};
+      std::optional<uint64_t> minContains{};
+      std::optional<uint64_t> maxContains{};
       std::optional<bool> uniqueItems{};
       // properties
-      std::optional<std::span<const std::string_view>> enumeration{}; // enum
+      std::optional<std::vector<std::string_view>> enumeration{}; // enum
 
       // out of json schema specification
       std::optional<detail::ExtUnits> ExtUnits{};
@@ -88,36 +88,67 @@ namespace glz
       struct glaze
       {
          using T = schema;
-         static constexpr auto value = glz::object("$ref", &T::ref, //
-                                                   "title", &T::title, //
-                                                   "description", &T::description, //
-                                                   "default", &T::defaultValue, //
-                                                   "deprecated", &T::deprecated, //
-                                                   "examples", raw<&T::examples>, //
-                                                   "readOnly", &T::readOnly, //
-                                                   "writeOnly", &T::writeOnly, //
-                                                   "const", &T::constant, //
-                                                   "minLength", &T::minLength, //
-                                                   "maxLength", &T::maxLength, //
-                                                   "pattern", &T::pattern, //
-                                                   "format", &T::format, //
-                                                   "minimum", &T::minimum, //
-                                                   "maximum", &T::maximum, //
-                                                   "exclusiveMinimum", &T::exclusiveMinimum, //
-                                                   "exclusiveMaximum", &T::exclusiveMaximum, //
-                                                   "multipleOf", &T::multipleOf, //
-                                                   "minProperties", &T::minProperties, //
-                                                   "maxProperties", &T::maxProperties, //
-                                                   //               "dependentRequired", &T::dependent_required, //
-                                                   "required", &T::required, //
-                                                   "minItems", &T::minItems, //
-                                                   "maxItems", &T::maxItems, //
-                                                   "minContains", &T::minContains, //
-                                                   "maxContains", &T::maxContains, //
-                                                   "uniqueItems", &T::uniqueItems, //
-                                                   "enum", &T::enumeration, //
-                                                   "ExtUnits", &T::ExtUnits, //
-                                                   "ExtAdvanced", &T::ExtAdvanced);
+         static constexpr std::array keys{"$ref", //
+                                          "title", //
+                                          "description", //
+                                          "default", //
+                                          "deprecated", //
+                                          "examples", //
+                                          "readOnly", //
+                                          "writeOnly", //
+                                          "const", //
+                                          "minLength", //
+                                          "maxLength", //
+                                          "pattern", //
+                                          "format", //
+                                          "minimum", //
+                                          "maximum", //
+                                          "exclusiveMinimum", //
+                                          "exclusiveMaximum", //
+                                          "multipleOf", //
+                                          "minProperties", //
+                                          "maxProperties", //
+                                          //"dependentRequired", //
+                                          "required", //
+                                          "minItems", //
+                                          "maxItems", //
+                                          "minContains", //
+                                          "maxContains", //
+                                          "uniqueItems", //
+                                          "enum", //
+                                          "ExtUnits", //
+                                          "ExtAdvanced"};
+
+         static constexpr glz::tuple value = {&T::ref, //
+                                              &T::title, //
+                                              &T::description, //
+                                              &T::defaultValue, //
+                                              &T::deprecated, //
+                                              raw<&T::examples>, //
+                                              &T::readOnly, //
+                                              &T::writeOnly, //
+                                              &T::constant, //
+                                              &T::minLength, //
+                                              &T::maxLength, //
+                                              &T::pattern, //
+                                              &T::format, //
+                                              &T::minimum, //
+                                              &T::maximum, //
+                                              &T::exclusiveMinimum, //
+                                              &T::exclusiveMaximum, //
+                                              &T::multipleOf, //
+                                              &T::minProperties, //
+                                              &T::maxProperties, //
+                                              // &T::dependent_required, //
+                                              &T::required, //
+                                              &T::minItems, //
+                                              &T::maxItems, //
+                                              &T::minContains, //
+                                              &T::maxContains, //
+                                              &T::uniqueItems, //
+                                              &T::enumeration, //
+                                              &T::ExtUnits, //
+                                              &T::ExtAdvanced};
       };
    };
 
@@ -135,129 +166,150 @@ namespace glz
          std::optional<std::vector<std::string_view>> examples{};
          schema attributes{};
       };
-      enum struct defined_formats : std::uint8_t {
-         datetime,
-         date,
-         time,
-         duration,
-         email,
-         idn_email,
-         hostname,
-         idn_hostname,
-         ipv4,
-         ipv6,
-         uri,
-         uri_reference,
-         iri,
-         iri_reference,
-         uuid,
-         uri_template,
-         json_pointer,
-         relative_json_pointer,
+
+      enum struct defined_formats : uint32_t {
+         datetime, //
+         date, //
+         time, //
+         duration, //
+         email, //
+         idn_email, //
+         hostname, //
+         idn_hostname, //
+         ipv4, //
+         ipv6, //
+         uri, //
+         uri_reference, //
+         iri, //
+         iri_reference, //
+         uuid, //
+         uri_template, //
+         json_pointer, //
+         relative_json_pointer, //
          regex
       };
    }
 }
 
 template <>
-struct glz::meta<glz::detail::schematic>
+struct glz::meta<glz::detail::defined_formats>
 {
-   static constexpr std::string_view name = "glz::detail::schema";
-   using T = detail::schematic;
-   static constexpr auto value = glz::object(
-      "type", &T::type, //
-      "properties", &T::properties, //
-      "items", &T::items, //
-      "additionalProperties", &T::additionalProperties, //
-      "$defs", &T::defs, //
-      "oneOf", &T::oneOf, //
-      "examples", raw<&T::examples>, //
-      "required", &T::required, //
-      "title", [](auto&& self) -> auto& { return self.attributes.title; }, //
-      "description", [](auto&& self) -> auto& { return self.attributes.description; }, //
-      "default", [](auto&& self) -> auto& { return self.attributes.defaultValue; }, //
-      "deprecated", [](auto&& self) -> auto& { return self.attributes.deprecated; }, //
-      "readOnly", [](auto&& self) -> auto& { return self.attributes.readOnly; }, //
-      "writeOnly", [](auto&& self) -> auto& { return self.attributes.writeOnly; }, //
-      "const", [](auto&& self) -> auto& { return self.attributes.constant; }, //
-      "minLength", [](auto&& self) -> auto& { return self.attributes.minLength; }, //
-      "maxLength", [](auto&& self) -> auto& { return self.attributes.maxLength; }, //
-      "pattern", [](auto&& self) -> auto& { return self.attributes.pattern; }, //
-      "format", [](auto&& self) -> auto& { return self.attributes.format; }, //
-      "minimum", [](auto&& self) -> auto& { return self.attributes.minimum; }, //
-      "maximum", [](auto&& self) -> auto& { return self.attributes.maximum; }, //
-      "exclusiveMinimum", [](auto&& self) -> auto& { return self.attributes.exclusiveMinimum; }, //
-      "exclusiveMaximum", [](auto&& self) -> auto& { return self.attributes.exclusiveMaximum; }, //
-      "multipleOf", [](auto&& self) -> auto& { return self.attributes.multipleOf; }, //
-      "minProperties", [](auto&& self) -> auto& { return self.attributes.minProperties; }, //
-      "maxProperties", [](auto&& self) -> auto& { return self.attributes.maxProperties; }, //
-      //               "dependentRequired", [](auto&& self) -> auto& { return self.attributes.dependent_required; }, //
-      "minItems", [](auto&& self) -> auto& { return self.attributes.minItems; }, //
-      "maxItems", [](auto&& self) -> auto& { return self.attributes.maxItems; }, //
-      "minContains", [](auto&& self) -> auto& { return self.attributes.minContains; }, //
-      "maxContains", [](auto&& self) -> auto& { return self.attributes.maxContains; }, //
-      "uniqueItems", [](auto&& self) -> auto& { return self.attributes.uniqueItems; }, //
-      "enum", [](auto&& self) -> auto& { return self.attributes.enumeration; }, //
-      "ExtUnits", [](auto&& self) -> auto& { return self.attributes.ExtUnits; }, //
-      "ExtAdvanced", [](auto&& self) -> auto& { return self.attributes.ExtAdvanced; });
+   static constexpr std::string_view name = "defined_formats";
+   using enum glz::detail::defined_formats;
+   static constexpr std::array keys{
+      "date-time", "date",          "time", "duration",     "email",        "idn-email",
+      "hostname",  "idn-hostname",  "ipv4", "ipv6",         "uri",          "uri-reference",
+      "iri",       "iri-reference", "uuid", "uri-template", "json-pointer", "relative-json-pointer",
+      "regex"};
+   static constexpr std::array value{datetime, //
+                                     date, //
+                                     time, //
+                                     duration, //
+                                     email, //
+                                     idn_email, //
+                                     hostname, //
+                                     idn_hostname, //
+                                     ipv4, //
+                                     ipv6, //
+                                     uri, //
+                                     uri_reference, //
+                                     iri, //
+                                     iri_reference, //
+                                     uuid, //
+                                     uri_template, //
+                                     json_pointer, //
+                                     relative_json_pointer, //
+                                     regex};
 };
 
 template <>
-struct glz::meta<glz::detail::defined_formats>
+struct glz::meta<glz::detail::schematic>
 {
-   using enum detail::defined_formats;
-   static constexpr std::string_view name = "defined_formats";
-   static constexpr auto value = enumerate("date-time", datetime, //
-                                           "date", date, //
-                                           "time", time, //
-                                           "duration", duration, //
-                                           "email", email, //
-                                           "idn-email", idn_email, //
-                                           "hostname", hostname, //
-                                           "idn-hostname", idn_hostname, //
-                                           "ipv4", ipv4, //
-                                           "ipv6", ipv6, //
-                                           "uri", uri, //
-                                           "uri-reference", uri_reference, //
-                                           "iri", iri, //
-                                           "iri-reference", iri_reference, //
-                                           "uuid", uuid, //
-                                           "uri-template", uri_template, //
-                                           "json-pointer", json_pointer, //
-                                           "relative-json-pointer", relative_json_pointer, //
-                                           "regex", regex);
+   static constexpr std::string_view name = "glz::detail::schema";
+   using T = detail::schematic;
+   static constexpr std::array keys{"type", //
+                                    "properties", //
+                                    "items", //
+                                    "additionalProperties", //
+                                    "$defs", //
+                                    "oneOf", //
+                                    "examples", //
+                                    "required", //
+                                    "title", //
+                                    "description", //
+                                    "default", //
+                                    "deprecated", //
+                                    "readOnly", //
+                                    "writeOnly", //
+                                    "const", //
+                                    "minLength", //
+                                    "maxLength", //
+                                    "pattern", //
+                                    "format", //
+                                    "minimum", //
+                                    "maximum", //
+                                    "exclusiveMinimum", //
+                                    "exclusiveMaximum", //
+                                    "multipleOf", //
+                                    "minProperties", //
+                                    "maxProperties", //
+                                    // "dependentRequired", //
+                                    "minItems", //
+                                    "maxItems", //
+                                    "minContains", //
+                                    "maxContains", //
+                                    "uniqueItems", //
+                                    "enum", //
+                                    "ExtUnits", //
+                                    "ExtAdvanced"};
+
+   [[maybe_unused]] static constexpr glz::tuple value{
+      &T::type, //
+      &T::properties, //
+      &T::items, //
+      &T::additionalProperties, //
+      &T::defs, //
+      &T::oneOf, //
+      raw<&T::examples>, //
+      &T::required, //
+      [](auto&& s) -> auto& { return s.attributes.title; }, //
+      [](auto&& s) -> auto& { return s.attributes.description; }, //
+      [](auto&& s) -> auto& { return s.attributes.defaultValue; }, //
+      [](auto&& s) -> auto& { return s.attributes.deprecated; }, //
+      [](auto&& s) -> auto& { return s.attributes.readOnly; }, //
+      [](auto&& s) -> auto& { return s.attributes.writeOnly; }, //
+      [](auto&& s) -> auto& { return s.attributes.constant; }, //
+      [](auto&& s) -> auto& { return s.attributes.minLength; }, //
+      [](auto&& s) -> auto& { return s.attributes.maxLength; }, //
+      [](auto&& s) -> auto& { return s.attributes.pattern; }, //
+      [](auto&& s) -> auto& { return s.attributes.format; }, //
+      [](auto&& s) -> auto& { return s.attributes.minimum; }, //
+      [](auto&& s) -> auto& { return s.attributes.maximum; }, //
+      [](auto&& s) -> auto& { return s.attributes.exclusiveMinimum; }, //
+      [](auto&& s) -> auto& { return s.attributes.exclusiveMaximum; }, //
+      [](auto&& s) -> auto& { return s.attributes.multipleOf; }, //
+      [](auto&& s) -> auto& { return s.attributes.minProperties; }, //
+      [](auto&& s) -> auto& { return s.attributes.maxProperties; }, //
+      // [](auto&& s) -> auto& { return s.attributes.dependent_required; }, //
+      [](auto&& s) -> auto& { return s.attributes.minItems; }, //
+      [](auto&& s) -> auto& { return s.attributes.maxItems; }, //
+      [](auto&& s) -> auto& { return s.attributes.minContains; }, //
+      [](auto&& s) -> auto& { return s.attributes.maxContains; }, //
+      [](auto&& s) -> auto& { return s.attributes.uniqueItems; }, //
+      [](auto&& s) -> auto& { return s.attributes.enumeration; }, //
+      [](auto&& s) -> auto& { return s.attributes.ExtUnits; }, //
+      [](auto&& s) -> auto& { return s.attributes.ExtAdvanced; }};
 };
 
 namespace glz
 {
    namespace detail
    {
-      // The reflection schema map makes a map of all schema types within a glz::json_schema
-      // and returns a map of these schemas with their reflected names.
-      template <class T>
-      consteval auto make_reflection_schema_map()
-      {
-         auto schema_instance = json_schema_v<T>;
-         auto tuple = to_tuple(schema_instance);
-         using V = std::decay_t<decltype(tuple)>;
-         constexpr auto N = glz::tuple_size_v<V>;
-         if constexpr (N > 0) {
-            constexpr auto& names = member_names<json_schema_type<T>>;
-            return [&]<size_t... I>(std::index_sequence<I...>) {
-               return detail::normal_map<sv, schema, N>(
-                  std::array<pair<sv, schema>, N>{pair{names[I], std::get<I>(tuple)}...});
-            }(std::make_index_sequence<N>{});
-         }
-         else {
-            return detail::normal_map<sv, schema, 0>(std::array<pair<sv, schema>, 0>{});
-         }
-      }
-
       template <class T = void>
       struct to_json_schema
       {
          template <auto Opts>
-         static void op(auto& s, auto& defs) noexcept
+         static void op(auto& s, auto& defs)
          {
             // &T::member
             if constexpr (glaze_t<T> && std::is_member_object_pointer_v<meta_wrapper_t<T>>) {
@@ -267,7 +319,7 @@ namespace glz
             else if constexpr (glaze_const_value_t<T>) { // &T::constexpr_member
                using constexpr_val_t = member_t<T, meta_wrapper_t<T>>;
                static constexpr auto val_v{*glz::meta_wrapper_v<T>};
-               if constexpr (glz::detail::glaze_enum_t<constexpr_val_t>) {
+               if constexpr (glz::glaze_enum_t<constexpr_val_t>) {
                   s.attributes.constant = glz::enum_name_v<val_v>;
                }
                else {
@@ -288,7 +340,7 @@ namespace glz
       struct to_json_schema<T>
       {
          template <auto Opts>
-         static void op(auto& s, auto&) noexcept
+         static void op(auto& s, auto&)
          {
             s.type = {"boolean"};
          }
@@ -298,18 +350,18 @@ namespace glz
       struct to_json_schema<T>
       {
          template <auto Opts>
-         static void op(auto& s, auto&) noexcept
+         static void op(auto& s, auto&)
          {
             using V = std::decay_t<T>;
             if constexpr (std::integral<V>) {
                s.type = {"integer"};
                s.attributes.minimum = static_cast<std::int64_t>(std::numeric_limits<V>::lowest());
-               s.attributes.maximum = static_cast<std::uint64_t>(std::numeric_limits<V>::max());
+               s.attributes.maximum = static_cast<std::uint64_t>((std::numeric_limits<V>::max)());
             }
             else {
                s.type = {"number"};
                s.attributes.minimum = std::numeric_limits<V>::lowest();
-               s.attributes.maximum = std::numeric_limits<V>::max();
+               s.attributes.maximum = (std::numeric_limits<V>::max)();
             }
          }
       };
@@ -319,7 +371,7 @@ namespace glz
       struct to_json_schema<T>
       {
          template <auto Opts>
-         static void op(auto& s, auto&) noexcept
+         static void op(auto& s, auto&)
          {
             s.type = {"string"};
          }
@@ -329,7 +381,7 @@ namespace glz
       struct to_json_schema<T>
       {
          template <auto Opts>
-         static void op(auto& s, auto&) noexcept
+         static void op(auto& s, auto&)
          {
             s.type = {"null"};
             s.attributes.constant = std::monostate{};
@@ -340,41 +392,26 @@ namespace glz
       struct to_json_schema<T>
       {
          template <auto Opts>
-         static void op(auto& s, auto&) noexcept
+         static void op(auto& s, auto&)
          {
             s.type = {"string"};
 
             // TODO use oneOf instead of enum to handle doc comments
-            using V = std::decay_t<T>;
-            static constexpr auto N = glz::tuple_size_v<meta_t<V>>;
+            static constexpr auto N = reflect<T>::size;
             // s.enumeration = std::vector<std::string_view>(N);
-            // for_each<N>([&](auto I) {
+            // for_each<N>([&]<auto I>() {
             //    static constexpr auto item = std::get<I>(meta_v<V>);
             //    (*s.enumeration)[I] = std::get<0>(item);
             // });
             s.oneOf = std::vector<schematic>(N);
-            for_each<N>([&](auto I) {
-               static constexpr auto item = get<I>(meta_v<V>);
-               using T0 = std::decay_t<decltype(get<0>(item))>;
+            for_each<N>([&]<auto I>() {
                auto& enumeration = (*s.oneOf)[I];
-               static constexpr size_t member_index = std::is_enum_v<T0> ? 0 : 1;
-               static constexpr size_t comment_index = member_index + 1;
-               constexpr auto Size = glz::tuple_size_v<decltype(item)>;
-               if constexpr (Size > comment_index) {
-                  using additional_data_type = decltype(get<comment_index>(item));
-                  if constexpr (std::is_convertible_v<additional_data_type, std::string_view>) {
-                     enumeration.attributes.description = get<comment_index>(item);
-                  }
-                  else if constexpr (std::is_convertible_v<additional_data_type, schema>) {
-                     enumeration.attributes = get<comment_index>(item);
-                  }
-               }
                // Do not override if already set
                if (!enumeration.attributes.constant.has_value()) {
-                  enumeration.attributes.constant = get_enum_key<V, I>();
+                  enumeration.attributes.constant = reflect<T>::keys[I];
                }
                if (!enumeration.attributes.title.has_value()) {
-                  enumeration.attributes.title = get_enum_key<V, I>();
+                  enumeration.attributes.title = reflect<T>::keys[I];
                }
             });
          }
@@ -384,7 +421,7 @@ namespace glz
       struct to_json_schema<basic_raw_json<T>>
       {
          template <auto Opts>
-         static void op(auto& s, auto&) noexcept
+         static void op(auto& s, auto&)
          {
             s.type = {"number", "string", "boolean", "object", "array", "null"};
          }
@@ -394,7 +431,7 @@ namespace glz
       struct to_json_schema<T>
       {
          template <auto Opts>
-         static void op(auto& s, auto& defs) noexcept
+         static void op(auto& s, auto& defs)
          {
             using V = std::decay_t<range_value_t<std::decay_t<T>>>;
             s.type = {"array"};
@@ -414,7 +451,7 @@ namespace glz
       struct to_json_schema<T>
       {
          template <auto Opts>
-         static void op(auto& s, auto& defs) noexcept
+         static void op(auto& s, auto& defs)
          {
             using V = std::decay_t<glz::tuple_element_t<1, range_value_t<std::decay_t<T>>>>;
             s.type = {"object"};
@@ -430,11 +467,12 @@ namespace glz
       struct to_json_schema<T>
       {
          template <auto Opts>
-         static void op(auto& s, auto& defs) noexcept
+         static void op(auto& s, auto& defs)
          {
             using V = std::decay_t<decltype(*std::declval<std::decay_t<T>>())>;
             to_json_schema<V>::template op<Opts>(s, defs);
-            auto& type = *s.type;
+            // to_json_schema above should populate the correct type, let's throw if it wasn't set
+            auto& type = s.type.value();
             auto it = std::find_if(type.begin(), type.end(), [&](const auto& str) { return str == "null"; });
             if (it == type.end()) {
                type.emplace_back("null");
@@ -446,7 +484,7 @@ namespace glz
       struct to_json_schema<T>
       {
          template <auto Opts>
-         static void op(auto& s, auto& defs) noexcept
+         static void op(auto& s, auto& defs)
          {
             static constexpr auto N = std::variant_size_v<T>;
             using type_counts = variant_type_count<T>;
@@ -471,17 +509,24 @@ namespace glz
             }
             s.oneOf = std::vector<schematic>(N);
 
-            for_each<N>([&](auto I) {
+            const auto& ids = ids_v<T>;
+
+            for_each<N>([&]<auto I>() {
                using V = std::decay_t<std::variant_alternative_t<I, T>>;
                auto& schema_val = (*s.oneOf)[I];
                to_json_schema<V>::template op<Opts>(schema_val, defs);
-               if constexpr ((glaze_object_t<V> || reflectable<V>)&&!tag_v<T>.empty()) {
-                  if (!schema_val.required) {
-                     schema_val.required = std::vector<sv>{};
+
+               if (not schema_val.attributes.title) {
+                  schema_val.attributes.title = ids[I];
+               }
+
+               if constexpr ((glaze_object_t<V> || reflectable<V>) && not tag_v<T>.empty()) {
+                  if (not schema_val.required) {
+                     schema_val.required = std::vector<sv>{}; // allocate
                   }
                   schema_val.required->emplace_back(tag_v<T>);
                   auto& tag = (*schema_val.properties)[tag_v<T>];
-                  tag.constant = ids_v<T>[I];
+                  tag.constant = ids[I];
                }
             });
          }
@@ -492,7 +537,7 @@ namespace glz
       struct to_json_schema<T>
       {
          template <auto Opts>
-         static void op(auto& s, auto&) noexcept
+         static void op(auto& s, auto&)
          {
             // TODO: Actually handle this. We can specify a schema per item in items
             //      We can also do size restrictions on static arrays
@@ -500,23 +545,12 @@ namespace glz
          }
       };
 
-      template <class T>
-      inline constexpr auto glaze_names = []() {
-         constexpr auto N = reflection_count<T>;
-         std::array<sv, N> names{};
-         for_each<N>([&](auto I) {
-            using Element = glaze_tuple_element<I, N, T>;
-            names[I] = key_name<I, T, Element::use_reflection>;
-         });
-         return names;
-      }();
-
       template <class T>
       consteval bool json_schema_matches_object_keys()
       {
          if constexpr (json_schema_t<T> && (count_members<json_schema_type<T>> > 0)) {
             constexpr auto& json_schema_names = member_names<json_schema_type<T>>;
-            auto fields = glaze_names<T>;
+            auto fields = reflect<T>::keys;
             std::sort(fields.begin(), fields.end());
 
             for (const auto& key : json_schema_names) {
@@ -538,7 +572,7 @@ namespace glz
       template <const std::string_view& ref>
       auto consteval validate_ref() noexcept -> void
       {
-#if __cpp_static_assert >= 202306L
+#if (__cpp_static_assert >= 202306L) && (__cplusplus > 202302L)
          static_assert(!has_slash(ref),
                        join_v<chars<"Slash in name: \"">, ref, chars<"\" in json schema references is not allowed">>);
 #else
@@ -551,7 +585,7 @@ namespace glz
       struct to_json_schema<T>
       {
          template <auto Opts>
-         static void op(auto& s, auto& defs) noexcept
+         static void op(auto& s, auto& defs)
          {
             static_assert(json_schema_matches_object_keys<T>());
 
@@ -577,25 +611,42 @@ namespace glz
                }
             }
 
-            static constexpr auto N = reflection_count<T>;
-
-            static constexpr auto schema_map = make_reflection_schema_map<T>();
+            static constexpr auto N = reflect<T>::size;
+            static constexpr auto json_schema_size = reflect<json_schema_type<T>>::size;
 
             s.properties = std::map<sv, schema, std::less<>>();
-            for_each<N>([&](auto I) {
-               using Element = glaze_tuple_element<I, N, T>;
-               static constexpr size_t member_index = Element::member_index;
-               using val_t = std::decay_t<typename Element::type>;
+            for_each<N>([&]<auto I>() {
+               using val_t = std::decay_t<refl_t<T, I>>;
 
                auto& def = defs[name_v<val_t>];
 
-               constexpr sv key = key_name<I, T, Element::use_reflection>;
+               static constexpr sv key = reflect<T>::keys[I];
 
                schema ref_val{};
-               if constexpr (schema_map.size()) {
-                  static constexpr auto it = schema_map.find(key);
-                  if constexpr (it != schema_map.end()) {
-                     ref_val = it->second;
+               if constexpr (N > 0 && json_schema_size > 0) {
+                  // We need schema_index to be the index within json_schema_type<T>,
+                  // but this struct may have fewer keys that don't match the full set of keys in the struct T
+                  // we therefore can't use `decode_hash_with_size` for either structure.
+                  // Instead we just loop over the keys, looking for a match:
+
+                  constexpr auto schema_index = [] {
+                     size_t i{};
+                     const auto& schema_keys = reflect<json_schema_type<T>>::keys;
+                     for (; i < json_schema_size; ++i) {
+                        if (schema_keys[i] == key) {
+                           return i;
+                        }
+                     }
+                     return json_schema_size;
+                  }();
+
+                  if constexpr (schema_index < json_schema_size) {
+                     // Experimented with a to_array approach, but the compilation times were significantly higher
+                     // even when converting this access to a run-time access
+                     // Tested with both creating a std::array and a heap allocated C-style array and storing in a
+                     // unique_ptr
+                     static const auto schema_v = json_schema_type<T>{};
+                     ref_val = get<schema_index>(to_tie(schema_v));
                   }
                }
                if (!ref_val.ref) {
@@ -603,22 +654,6 @@ namespace glz
                   ref_val.ref = join_v<chars<"#/$defs/">, name_v<val_t>>;
                }
 
-               static constexpr size_t comment_index = member_index + 1;
-               static constexpr auto Size = glz::tuple_size_v<typename Element::Item>;
-
-               if constexpr (Size > comment_index && glaze_object_t<T>) {
-                  static constexpr auto item = glz::get<I>(meta_v<V>);
-                  using additional_data_type = decltype(get<comment_index>(item));
-                  if constexpr (std::is_convertible_v<additional_data_type, sv>) {
-                     ref_val.description = get<comment_index>(item);
-                  }
-                  else if constexpr (std::is_convertible_v<additional_data_type, schema>) {
-                     ref_val = get<comment_index>(item);
-                     validate_ref<name_v<val_t>>();
-                     ref_val.ref = join_v<chars<"#/$defs/">, name_v<val_t>>;
-                  }
-               }
-
                if (!def.type) {
                   to_json_schema<val_t>::template op<Opts>(def, defs);
                }
@@ -628,20 +663,28 @@ namespace glz
             s.additionalProperties = false;
          }
       };
-
    }
 
-   template <class T, opts Opts = opts{}, class Buffer>
-   [[nodiscard]] error_ctx write_json_schema(Buffer&& buffer) noexcept
+   // Moved definition outside of write_json_schema to fix MSVC bug
+   template <class Opts>
+   struct opts_write_type_info_off : std::decay_t<Opts>
+   {
+      bool write_type_info = false;
+   };
+
+   template <class T, auto Opts = opts{}, class Buffer>
+   [[nodiscard]] error_ctx write_json_schema(Buffer&& buffer)
    {
       detail::schematic s{};
       s.defs.emplace();
       detail::to_json_schema<std::decay_t<T>>::template op<Opts>(s, *s.defs);
-      return write<opt_false<Opts, &opts::write_type_info>>(std::move(s), std::forward<Buffer>(buffer));
+      // Making this static constexpr options to fix MSVC bug
+      static constexpr opts options = opts_write_type_info_off<decltype(Opts)>{{Opts}};
+      return write<options>(std::move(s), std::forward<Buffer>(buffer));
    }
 
-   template <class T, opts Opts = opts{}>
-   [[nodiscard]] glz::expected<std::string, error_ctx> write_json_schema() noexcept
+   template <class T, auto Opts = opts{}>
+   [[nodiscard]] glz::expected<std::string, error_ctx> write_json_schema()
    {
       std::string buffer{};
       const error_ctx ec = write_json_schema<T, Opts>(buffer);
diff --git a/deps/saucer/include/glaze/json/skip.hpp b/deps/saucer/include/glaze/json/skip.hpp
index 19877f4..a47d175 100644
--- a/deps/saucer/include/glaze/json/skip.hpp
+++ b/deps/saucer/include/glaze/json/skip.hpp
@@ -5,20 +5,58 @@
 
 #include "glaze/util/parse.hpp"
 
-namespace glz::detail
+namespace glz
 {
-   template <opts Opts>
+   template <>
+   struct skip_value<JSON>
+   {
+      template <auto Opts>
+         requires(not Opts.comments)
+      GLZ_ALWAYS_INLINE static void op(is_context auto&& ctx, auto&& it, auto&& end) noexcept;
+
+      template <auto Opts>
+         requires(bool(Opts.comments))
+      GLZ_ALWAYS_INLINE static void op(is_context auto&& ctx, auto&& it, auto&& end) noexcept;
+   };
+
+   template <auto Opts>
    void skip_object(is_context auto&& ctx, auto&& it, auto&& end) noexcept
    {
-      if constexpr (!Opts.force_conformance) {
+      if constexpr (!check_validate_skipped(Opts)) {
          ++it;
+         if constexpr (not Opts.null_terminated) {
+            if (it == end) [[unlikely]] {
+               ctx.error = error_code::unexpected_end;
+               return;
+            }
+         }
          skip_until_closed<Opts, '{', '}'>(ctx, it, end);
       }
       else {
+         if constexpr (not Opts.null_terminated) {
+            ++ctx.indentation_level;
+         }
          ++it;
-         GLZ_SKIP_WS;
+         if constexpr (not Opts.null_terminated) {
+            if (it == end) [[unlikely]] {
+               ctx.error = error_code::unexpected_end;
+               return;
+            }
+         }
+         if (skip_ws<Opts>(ctx, it, end)) {
+            return;
+         }
          if (*it == '}') {
+            if constexpr (not Opts.null_terminated) {
+               --ctx.indentation_level;
+            }
             ++it;
+            if constexpr (not Opts.null_terminated) {
+               if (it == end) {
+                  ctx.error = error_code::end_reached;
+                  return;
+               }
+            }
             return;
          }
          while (true) {
@@ -29,65 +67,169 @@ namespace glz::detail
             skip_string<Opts>(ctx, it, end);
             if (bool(ctx.error)) [[unlikely]]
                return;
-            GLZ_SKIP_WS;
-            GLZ_MATCH_COLON;
-            GLZ_SKIP_WS;
-            skip_value<Opts>(ctx, it, end);
+            if (skip_ws<Opts>(ctx, it, end)) {
+               return;
+            }
+            if (match_invalid_end<':', Opts>(ctx, it, end)) {
+               return;
+            }
+            if (skip_ws<Opts>(ctx, it, end)) {
+               return;
+            }
+            skip_value<JSON>::op<Opts>(ctx, it, end);
             if (bool(ctx.error)) [[unlikely]]
                return;
-            GLZ_SKIP_WS;
+            if (skip_ws<Opts>(ctx, it, end)) {
+               return;
+            }
             if (*it != ',') break;
             ++it;
-            GLZ_SKIP_WS;
+            if constexpr (not Opts.null_terminated) {
+               if (it == end) [[unlikely]] {
+                  ctx.error = error_code::unexpected_end;
+                  return;
+               }
+            }
+            if (skip_ws<Opts>(ctx, it, end)) {
+               return;
+            }
          }
          match<'}'>(ctx, it);
+         if constexpr (not Opts.null_terminated) {
+            --ctx.indentation_level;
+         }
+         if constexpr (not Opts.null_terminated) {
+            if (it == end) {
+               ctx.error = error_code::end_reached;
+               return;
+            }
+         }
       }
    }
 
-   template <opts Opts>
+   template <auto Opts>
+      requires(Opts.format == JSON || Opts.format == NDJSON)
    void skip_array(is_context auto&& ctx, auto&& it, auto&& end) noexcept
    {
-      if constexpr (!Opts.force_conformance) {
+      if constexpr (!check_validate_skipped(Opts)) {
          ++it;
+         if constexpr (not Opts.null_terminated) {
+            if (it == end) [[unlikely]] {
+               ctx.error = error_code::unexpected_end;
+               return;
+            }
+         }
          skip_until_closed<Opts, '[', ']'>(ctx, it, end);
       }
       else {
+         if constexpr (not Opts.null_terminated) {
+            ++ctx.indentation_level;
+         }
          ++it;
-         GLZ_SKIP_WS;
+         if constexpr (not Opts.null_terminated) {
+            if (it == end) [[unlikely]] {
+               ctx.error = error_code::unexpected_end;
+               return;
+            }
+         }
+         if (skip_ws<Opts>(ctx, it, end)) {
+            return;
+         }
          if (*it == ']') {
+            if constexpr (not Opts.null_terminated) {
+               --ctx.indentation_level;
+            }
             ++it;
+            if constexpr (not Opts.null_terminated) {
+               if (it == end) {
+                  ctx.error = error_code::end_reached;
+                  return;
+               }
+            }
             return;
          }
          while (true) {
-            skip_value<Opts>(ctx, it, end);
+            skip_value<JSON>::op<Opts>(ctx, it, end);
             if (bool(ctx.error)) [[unlikely]]
                return;
-            GLZ_SKIP_WS;
+            if (skip_ws<Opts>(ctx, it, end)) {
+               return;
+            }
             if (*it != ',') break;
             ++it;
-            GLZ_SKIP_WS;
+            if constexpr (not Opts.null_terminated) {
+               if (it == end) [[unlikely]] {
+                  ctx.error = error_code::unexpected_end;
+                  return;
+               }
+            }
+            if (skip_ws<Opts>(ctx, it, end)) {
+               return;
+            }
          }
          match<']'>(ctx, it);
+         if constexpr (not Opts.null_terminated) {
+            --ctx.indentation_level;
+         }
+         if constexpr (not Opts.null_terminated) {
+            if (it == end) {
+               ctx.error = error_code::end_reached;
+               return;
+            }
+         }
       }
    }
 
-   template <opts Opts>
-   void skip_value(is_context auto&& ctx, auto&& it, auto&& end) noexcept
+   // parse_value is used for JSON pointer reading
+   // we want the JSON pointer access to not care about trailing whitespace
+   // so we use validate_skipped for precise validation and value skipping
+   // expects opening whitespace to be handled
+   template <auto Opts>
+   GLZ_ALWAYS_INLINE auto parse_value(is_context auto&& ctx, auto&& it, auto&& end) noexcept
+   {
+      auto start = it;
+      struct opts_validate_skipped : std::decay_t<decltype(Opts)>
+      {
+         bool validate_skipped = true;
+      };
+      skip_value<JSON>::op<opts_validate_skipped{{Opts}}>(ctx, it, end);
+      return std::span{start, size_t(it - start)};
+   }
+
+   template <auto Opts>
+      requires(not Opts.comments)
+   GLZ_ALWAYS_INLINE void skip_value<JSON>::op(is_context auto&& ctx, auto&& it, auto&& end) noexcept
    {
-      if constexpr (!Opts.force_conformance) {
-         if constexpr (!Opts.ws_handled) {
-            GLZ_SKIP_WS;
+      using namespace glz::detail;
+
+      if constexpr (not check_validate_skipped(Opts)) {
+         if constexpr (not check_ws_handled(Opts)) {
+            if (skip_ws<Opts>(ctx, it, end)) {
+               return;
+            }
          }
          while (true) {
             switch (*it) {
             case '{':
                ++it;
+               if constexpr (not Opts.null_terminated) {
+                  if (it == end) [[unlikely]] {
+                     ctx.error = error_code::unexpected_end;
+                     return;
+                  }
+               }
                skip_until_closed<Opts, '{', '}'>(ctx, it, end);
                if (bool(ctx.error)) [[unlikely]]
                   return;
                break;
             case '[':
                ++it;
+               if constexpr (not Opts.null_terminated) {
+                  if (it == end) [[unlikely]] {
+                     ctx.error = error_code::unexpected_end;
+                     return;
+                  }
+               }
                skip_until_closed<Opts, '[', ']'>(ctx, it, end);
                if (bool(ctx.error)) [[unlikely]]
                   return;
@@ -97,11 +239,6 @@ namespace glz::detail
                if (bool(ctx.error)) [[unlikely]]
                   return;
                break;
-            case '/':
-               skip_comment(ctx, it, end);
-               if (bool(ctx.error)) [[unlikely]]
-                  return;
-               continue;
             case ',':
             case '}':
             case ']':
@@ -111,6 +248,12 @@ namespace glz::detail
                return;
             default: {
                ++it;
+               if constexpr (not Opts.null_terminated) {
+                  if (it == end) [[unlikely]] {
+                     ctx.error = error_code::unexpected_end;
+                     return;
+                  }
+               }
                continue;
             }
             }
@@ -119,8 +262,10 @@ namespace glz::detail
          }
       }
       else {
-         if constexpr (!Opts.ws_handled) {
-            GLZ_SKIP_WS;
+         if constexpr (not check_ws_handled(Opts)) {
+            if (skip_ws<Opts>(ctx, it, end)) {
+               return;
+            }
          }
          switch (*it) {
          case '{': {
@@ -161,12 +306,58 @@ namespace glz::detail
       }
    }
 
-   // expects opening whitespace to be handled
-   template <opts Opts>
-   GLZ_ALWAYS_INLINE auto parse_value(is_context auto&& ctx, auto&& it, auto&& end) noexcept
+   template <auto Opts>
+      requires(bool(Opts.comments))
+   GLZ_ALWAYS_INLINE void skip_value<JSON>::op(is_context auto&& ctx, auto&& it, auto&& end) noexcept
    {
-      auto start = it;
-      skip_value<Opts>(ctx, it, end);
-      return std::span{start, size_t(it - start)};
+      using namespace glz::detail;
+
+      if constexpr (not check_ws_handled(Opts)) {
+         if (skip_ws<Opts>(ctx, it, end)) {
+            return;
+         }
+      }
+      switch (*it) {
+      case '{': {
+         skip_object<Opts>(ctx, it, end);
+         break;
+      }
+      case '[': {
+         skip_array<Opts>(ctx, it, end);
+         break;
+      }
+      case '"': {
+         skip_string<Opts>(ctx, it, end);
+         break;
+      }
+      case '/': {
+         skip_comment(ctx, it, end);
+         if (bool(ctx.error)) [[unlikely]]
+            return;
+         break;
+      }
+      case 'n': {
+         ++it;
+         match<"ull", Opts>(ctx, it, end);
+         break;
+      }
+      case 'f': {
+         ++it;
+         match<"alse", Opts>(ctx, it, end);
+         break;
+      }
+      case 't': {
+         ++it;
+         match<"rue", Opts>(ctx, it, end);
+         break;
+      }
+      case '\0': {
+         ctx.error = error_code::unexpected_end;
+         break;
+      }
+      default: {
+         skip_number<Opts>(ctx, it, end);
+      }
+      }
    }
 }
diff --git a/deps/saucer/include/glaze/json/study.hpp b/deps/saucer/include/glaze/json/study.hpp
index 31e7e3a..41543f2 100644
--- a/deps/saucer/include/glaze/json/study.hpp
+++ b/deps/saucer/include/glaze/json/study.hpp
@@ -106,7 +106,7 @@ namespace glz
 
          std::size_t size() const { return max_index; }
 
-         [[nodiscard]] expected<State, error_code> generate(const size_t i) noexcept
+         [[nodiscard]] expected<State, error_code> generate(const size_t i)
          {
             size_t deconst_index = i;
             for (auto& param_set : param_sets) {
@@ -149,7 +149,7 @@ namespace glz
             param_set param_set;
 
             error_ctx pe{};
-            bool found = detail::seek_impl(
+            bool found = seek(
                [&](auto&& val) {
                   if constexpr (std::is_assignable_v<basic, std::decay_t<decltype(val)>>) {
                      param_set.param_ptr = &val;
@@ -341,7 +341,7 @@ namespace glz
             random_param result{};
 
             error_ctx pe{};
-            bool found = detail::seek_impl(
+            bool found = seek(
                [&](auto&& val) {
                   if constexpr (std::is_assignable_v<basic, std::decay_t<decltype(val)>>) {
                      result.param_ptr = &val;
diff --git a/deps/saucer/include/glaze/json/wrappers.hpp b/deps/saucer/include/glaze/json/wrappers.hpp
index 54d9d8f..525db6c 100644
--- a/deps/saucer/include/glaze/json/wrappers.hpp
+++ b/deps/saucer/include/glaze/json/wrappers.hpp
@@ -5,6 +5,7 @@
 
 #include <type_traits>
 
+#include "glaze/core/custom.hpp"
 #include "glaze/core/opts.hpp"
 #include "glaze/core/wrappers.hpp"
 #include "glaze/json/read.hpp"
@@ -12,74 +13,65 @@
 
 namespace glz
 {
-   // treat a value as quoted to avoid double parsing into a value
    template <class T>
-   struct quoted_t
+   struct from<JSON, quoted_t<T>>
    {
-      static constexpr bool glaze_wrapper = true;
-      using value_type = T;
-      T& val;
-   };
-
-   namespace detail
-   {
-      template <class T>
-      struct from_json<quoted_t<T>>
-      {
-         template <auto Opts>
-         GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, auto&&... args) noexcept
-         {
-            static thread_local std::string s{};
-            read<json>::op<Opts>(s, ctx, args...);
-            auto pe = glz::read<Opts>(value.val, s);
-            if (pe) {
-               ctx.error = pe.ec;
-            }
-         }
-      };
-
-      template <class T>
-      struct to_json<quoted_t<T>>
+      template <auto Opts>
+      static void op(auto&& value, is_context auto&& ctx, auto&&... args)
       {
-         template <auto Opts>
-         GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, auto&&... args) noexcept
-         {
-            static thread_local std::string s(128, ' ');
-            size_t ix = 0; // overwrite index
-            write<json>::op<Opts>(value.val, ctx, s, ix);
-            s.resize(ix);
-            write<json>::op<Opts>(s, ctx, args...);
+         static thread_local std::string s{};
+         parse<JSON>::op<Opts>(s, ctx, args...);
+         auto pe = glz::read<Opts>(value.val, s);
+         if (pe) [[unlikely]] {
+            ctx.error = pe.ec;
          }
-      };
+      }
+   };
 
-      template <is_opts_wrapper T>
-      struct from_json<T>
+   template <class T>
+   struct to<JSON, quoted_t<T>>
+   {
+      template <auto Opts>
+      static void op(auto&& value, is_context auto&& ctx, auto&& b, auto&& ix)
       {
-         template <auto Opts>
-         GLZ_ALWAYS_INLINE static void op(auto&& value, auto&&... args) noexcept
-         {
-            read<json>::op<opt_true<Opts, T::opts_member>>(value.val, args...);
-         }
-      };
+         static thread_local std::string s(128, ' ');
+         size_t oix = 0; // overwrite index
+         using Value = core_t<decltype(value.val)>;
+         to<JSON, Value>::template op<Opts>(value.val, ctx, s, oix);
+         s.resize(oix);
+         using S = core_t<decltype(s)>;
+         to<JSON, S>::template op<Opts>(s, ctx, b, ix);
+      }
+   };
 
-      template <is_opts_wrapper T>
-      struct to_json<T>
+   template <is_opts_wrapper T>
+   struct from<JSON, T>
+   {
+      template <auto Opts>
+      GLZ_ALWAYS_INLINE static void op(auto&& value, auto&&... args)
       {
-         template <auto Opts>
-         GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, auto&&... args) noexcept
-         {
-            write<json>::op<opt_true<Opts, T::opts_member>>(value.val, ctx, args...);
-         }
-      };
+         parse<JSON>::op<opt_true<Opts, T::opts_member>>(value.val, args...);
+      }
+   };
 
-      template <auto MemPtr>
-      inline constexpr decltype(auto) quoted_impl() noexcept
+   template <is_opts_wrapper T>
+   struct to<JSON, T>
+   {
+      template <auto Opts>
+      GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, auto&&... args)
       {
-         return [](auto&& val) { return quoted_t<std::remove_reference_t<decltype(val.*MemPtr)>>{val.*MemPtr}; };
+         using Value = core_t<decltype(value.val)>;
+         to<JSON, Value>::template op<opt_true<Opts, T::opts_member>>(value.val, ctx, args...);
       }
+   };
+
+   template <auto MemPtr>
+   inline constexpr decltype(auto) quoted_impl() noexcept
+   {
+      return [](auto&& val) { return quoted_t<std::remove_reference_t<decltype(val.*MemPtr)>>{val.*MemPtr}; };
    }
 
    // Read a value as a string and unescape, to avoid the user having to parse twice
    template <auto MemPtr>
-   constexpr auto quoted = detail::quoted_impl<MemPtr>();
+   constexpr auto quoted = quoted_impl<MemPtr>();
 }
diff --git a/deps/saucer/include/glaze/json/write.hpp b/deps/saucer/include/glaze/json/write.hpp
index 72ed1e7..3125fae 100644
--- a/deps/saucer/include/glaze/json/write.hpp
+++ b/deps/saucer/include/glaze/json/write.hpp
@@ -8,1096 +8,1650 @@
 #include <ostream>
 #include <variant>
 
+#if !defined(GLZ_DISABLE_SIMD) && (defined(__x86_64__) || defined(_M_X64))
+#if defined(_MSC_VER)
+#include <intrin.h>
+#pragma warning(push)
+#pragma warning( \
+   disable : 4702) // disable "unreachable code" warnings, which are often invalid due to constexpr branching
+#else
+#include <immintrin.h>
+#endif
+
+#if defined(__AVX2__)
+#define GLZ_USE_AVX2
+#endif
+#endif
+
 #include "glaze/core/opts.hpp"
-#include "glaze/core/reflection_tuple.hpp"
+#include "glaze/core/reflect.hpp"
+#include "glaze/core/to.hpp"
 #include "glaze/core/write.hpp"
 #include "glaze/core/write_chars.hpp"
 #include "glaze/json/ptr.hpp"
-#include "glaze/reflection/reflect.hpp"
 #include "glaze/util/dump.hpp"
 #include "glaze/util/for_each.hpp"
 #include "glaze/util/itoa.hpp"
 
 namespace glz
 {
-   namespace detail
+   // This serialize<JSON> indirection only exists to call std::remove_cvref_t on the type
+   // so that type matching doesn't depend on qualifiers.
+   // It is recommended to directly call to<JSON, std::remove_cvref_t<T>> to reduce compilation overhead.
+   // TODO: Long term this can probably be [[deprecated]]
+   // but it is useful for when getting the value type would be verbose
+   template <>
+   struct serialize<JSON>
    {
-      template <>
-      struct write<json>
+      template <auto Opts, class T, is_context Ctx, class B, class IX>
+      GLZ_ALWAYS_INLINE static void op(T&& value, Ctx&& ctx, B&& b, IX&& ix)
       {
-         template <auto Opts, class T, is_context Ctx, class B, class IX>
-         GLZ_ALWAYS_INLINE static void op(T&& value, Ctx&& ctx, B&& b, IX&& ix) noexcept
-         {
-            to_json<std::remove_cvref_t<T>>::template op<Opts>(std::forward<T>(value), std::forward<Ctx>(ctx),
-                                                               std::forward<B>(b), std::forward<IX>(ix));
-         }
-      };
+         to<JSON, std::remove_cvref_t<T>>::template op<Opts>(std::forward<T>(value), std::forward<Ctx>(ctx),
+                                                             std::forward<B>(b), std::forward<IX>(ix));
+      }
+   };
 
-      template <class T>
-         requires(glaze_value_t<T> && !custom_write<T>)
-      struct to_json<T>
+   template <auto& Partial, auto Opts, class T, class Ctx, class B, class IX>
+   concept write_json_partial_invocable = requires(T&& value, Ctx&& ctx, B&& b, IX&& ix) {
+      to_partial<JSON, std::remove_cvref_t<T>>::template op<Partial, Opts>(
+         std::forward<T>(value), std::forward<Ctx>(ctx), std::forward<B>(b), std::forward<IX>(ix));
+   };
+
+   template <>
+   struct serialize_partial<JSON>
+   {
+      template <auto& Partial, auto Opts, class T, is_context Ctx, class B, class IX>
+      GLZ_ALWAYS_INLINE static void op(T&& value, Ctx&& ctx, B&& b, IX&& ix)
       {
-         template <auto Opts, class Value, is_context Ctx, class B, class IX>
-         GLZ_ALWAYS_INLINE static void op(Value&& value, Ctx&& ctx, B&& b, IX&& ix) noexcept
-         {
-            using V = std::remove_cvref_t<decltype(get_member(std::declval<Value>(), meta_wrapper_v<T>))>;
-            to_json<V>::template op<Opts>(get_member(std::forward<Value>(value), meta_wrapper_v<T>),
-                                          std::forward<Ctx>(ctx), std::forward<B>(b), std::forward<IX>(ix));
+         if constexpr (std::count(Partial.begin(), Partial.end(), "") > 0) {
+            serialize<JSON>::op<Opts>(value, ctx, b, ix);
          }
-      };
-
-      template <class T>
-      concept optional_like = nullable_t<T> && (!is_expected<T> && !std::is_array_v<T>);
+         else if constexpr (write_json_partial_invocable<Partial, Opts, T, Ctx, B, IX>) {
+            to_partial<JSON, std::remove_cvref_t<T>>::template op<Partial, Opts>(
+               std::forward<T>(value), std::forward<Ctx>(ctx), std::forward<B>(b), std::forward<IX>(ix));
+         }
+         else {
+            static_assert(false_v<T>, "Glaze metadata is probably needed for your type");
+         }
+      }
+   };
 
-      template <class T>
-      concept supports_unchecked_write =
-         complex_t<T> || boolean_like<T> || num_t<T> || optional_like<T> || always_null_t<T>;
+   template <auto Opts, bool minified_check = true, class B>
+      requires(Opts.format == JSON || Opts.format == NDJSON)
+   GLZ_ALWAYS_INLINE void write_object_entry_separator(is_context auto&& ctx, B&& b, auto&& ix)
+   {
+      if constexpr (Opts.prettify) {
+         if constexpr (vector_like<B>) {
+            if (const auto k = ix + ctx.indentation_level + write_padding_bytes; k > b.size()) [[unlikely]] {
+               b.resize(2 * k);
+            }
+         }
+         std::memcpy(&b[ix], ",\n", 2);
+         ix += 2;
+         std::memset(&b[ix], Opts.indentation_char, ctx.indentation_level);
+         ix += ctx.indentation_level;
+      }
+      else {
+         if constexpr (vector_like<B>) {
+            if constexpr (minified_check) {
+               if (ix >= b.size()) [[unlikely]] {
+                  b.resize(2 * ix);
+               }
+            }
+         }
+         std::memcpy(&b[ix], ",", 1);
+         ++ix;
+      }
+   }
 
-      template <is_bitset T>
-      struct to_json<T>
+   // Only object types are supported for partial
+   template <class T>
+      requires(glaze_object_t<T> || writable_map_t<T> || reflectable<T>)
+   struct to_partial<JSON, T> final
+   {
+      template <auto& Partial, auto Opts, class... Args>
+      static void op(auto&& value, is_context auto&& ctx, auto&& b, auto&& ix)
       {
-         template <auto Opts>
-         GLZ_ALWAYS_INLINE static void op(auto&& value, auto&&, auto&& b, auto&& ix) noexcept
-         {
-            dump<'"'>(b, ix);
-            for (size_t i = value.size(); i > 0; --i) {
-               value[i - 1] ? dump<'1'>(b, ix) : dump<'0'>(b, ix);
+         if constexpr (!check_opening_handled(Opts)) {
+            dump<'{'>(b, ix);
+            if constexpr (Opts.prettify) {
+               ctx.indentation_level += Opts.indentation_width;
+               dump<'\n'>(b, ix);
+               dumpn<Opts.indentation_char>(ctx.indentation_level, b, ix);
             }
-            dump<'"'>(b, ix);
          }
-      };
 
-      template <glaze_flags_t T>
-      struct to_json<T>
-      {
-         template <auto Opts>
-         GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&&, auto&& b, auto&& ix) noexcept
-         {
-            static constexpr auto N = glz::tuple_size_v<meta_t<T>>;
+         static constexpr auto sorted = sort_json_ptrs(Partial);
+         static constexpr auto groups = glz::group_json_ptrs<sorted>();
+         static constexpr auto N = glz::tuple_size_v<std::decay_t<decltype(groups)>>;
 
-            dump<'['>(b, ix);
+         static constexpr auto num_members = reflect<T>::size;
 
-            for_each<N>([&](auto I) {
-               static constexpr auto item = glz::get<I>(meta_v<T>);
+         if constexpr ((num_members > 0) && (glaze_object_t<T> || reflectable<T>)) {
+            for_each<N>([&]<size_t I>() {
+               if (bool(ctx.error)) [[unlikely]] {
+                  return;
+               }
 
-               if (get_member(value, glz::get<1>(item))) {
-                  dump<'"'>(b, ix);
-                  dump_maybe_empty(glz::get<0>(item), b, ix);
-                  dump<"\",">(b, ix);
+               static constexpr auto group = glz::get<I>(groups);
+
+               static constexpr auto key = get<0>(group);
+               static constexpr auto quoted_key = quoted_key_v<key, Opts.prettify>;
+               dump<quoted_key>(b, ix);
+
+               static constexpr auto sub_partial = get<1>(group);
+               static constexpr auto index = key_index<T>(key);
+               static_assert(index < num_members, "Invalid key passed to partial write");
+               if constexpr (glaze_object_t<T>) {
+                  static constexpr auto member = get<index>(reflect<T>::values);
+
+                  serialize_partial<JSON>::op<sub_partial, Opts>(get_member(value, member), ctx, b, ix);
+                  if constexpr (I != N - 1) {
+                     write_object_entry_separator<Opts>(ctx, b, ix);
+                  }
+               }
+               else {
+                  serialize_partial<JSON>::op<sub_partial, Opts>(get_member(value, get<index>(to_tie(value))), ctx, b,
+                                                                 ix);
+                  if constexpr (I != N - 1) {
+                     write_object_entry_separator<Opts>(ctx, b, ix);
+                  }
+               }
+            });
+         }
+         else if constexpr (writable_map_t<T>) {
+            for_each<N>([&]<size_t I>() {
+               if (bool(ctx.error)) [[unlikely]] {
+                  return;
+               }
+
+               static constexpr auto group = glz::get<I>(groups);
+
+               static constexpr auto key = std::get<0>(group);
+               static constexpr auto quoted_key = quoted_key_v<key, Opts.prettify>;
+               dump<key>(b, ix);
+
+               static constexpr auto sub_partial = std::get<1>(group);
+               if constexpr (findable<std::decay_t<T>, decltype(key)>) {
+                  auto it = value.find(key);
+                  if (it != value.end()) {
+                     serialize_partial<JSON>::op<sub_partial, Opts>(it->second, ctx, b, ix);
+                  }
+                  else {
+                     ctx.error = error_code::invalid_partial_key;
+                     return;
+                  }
+               }
+               else {
+                  static thread_local auto k = typename std::decay_t<T>::key_type(key);
+                  auto it = value.find(k);
+                  if (it != value.end()) {
+                     serialize_partial<JSON>::op<sub_partial, Opts>(it->second, ctx, b, ix);
+                  }
+                  else {
+                     ctx.error = error_code::invalid_partial_key;
+                     return;
+                  }
+               }
+               if constexpr (I != N - 1) {
+                  write_object_entry_separator<Opts>(ctx, b, ix);
                }
             });
+         }
+
+         if (not bool(ctx.error)) [[likely]] {
+            dump<'}'>(b, ix);
+         }
+      }
+   };
 
-            if (b[ix - 1] == ',') {
-               b[ix - 1] = ']';
+   template <class T>
+      requires(glaze_value_t<T> && !custom_write<T>)
+   struct to<JSON, T>
+   {
+      template <auto Opts, class Value, is_context Ctx, class B, class IX>
+      GLZ_ALWAYS_INLINE static void op(Value&& value, Ctx&& ctx, B&& b, IX&& ix)
+      {
+         using V = std::remove_cvref_t<decltype(get_member(std::declval<Value>(), meta_wrapper_v<T>))>;
+         to<JSON, V>::template op<Opts>(get_member(std::forward<Value>(value), meta_wrapper_v<T>),
+                                        std::forward<Ctx>(ctx), std::forward<B>(b), std::forward<IX>(ix));
+      }
+   };
+
+   // Returns 0 if we cannot determine the required padding,
+   // in which case the `to` specialization must allocate buffer space
+   // Some types like numbers must have space to be quoted
+   // All types must have space for a trailing comma
+   template <class T>
+   constexpr size_t required_padding()
+   {
+      constexpr auto value = []() -> size_t {
+         if constexpr (boolean_like<T>) {
+            return 8;
+         }
+         else if constexpr (num_t<T>) {
+            if constexpr (std::floating_point<T>) {
+               if constexpr (sizeof(T) > 8) {
+                  return 64;
+               }
+               else if constexpr (sizeof(T) > 4) {
+                  return 32;
+               }
+               else {
+                  return 24;
+               }
+            }
+            else if constexpr (sizeof(T) > 4) {
+               return 24;
+            }
+            else if constexpr (sizeof(T) > 2) {
+               return 16;
             }
             else {
-               dump<']'>(b, ix);
+               return 8;
+            }
+         }
+         else if constexpr (nullable_like<T>) {
+            if constexpr (has_value_type<T>) {
+               return required_padding<typename T::value_type>();
             }
+            else if constexpr (has_element_type<T>) {
+               return required_padding<typename T::element_type>();
+            }
+            else {
+               return 0;
+            }
+         }
+         else if constexpr (always_null_t<T>) {
+            return 8;
          }
-      };
+         else {
+            return 0;
+         }
+      }();
+
+      if constexpr (value >= (write_padding_bytes - 16)) {
+         // we always require 16 bytes available from write_padding_bytes
+         // for opening and closing characters
+         return 0;
+      }
+      return value;
+   }
 
-      template <>
-      struct to_json<hidden>
+   template <is_bitset T>
+   struct to<JSON, T>
+   {
+      template <auto Opts, class B>
+      static void op(auto&& value, auto&&, B&& b, auto&& ix)
       {
-         template <auto Opts>
-         GLZ_ALWAYS_INLINE static void op(auto&&, is_context auto&&, auto&&... args) noexcept
-         {
-            dump(R"("hidden type should not have been written")", args...);
+         if constexpr (vector_like<B>) {
+            const auto n = ix + 2 + value.size(); // 2 quotes + spaces for character
+            if (n >= b.size()) [[unlikely]] {
+               b.resize(2 * n);
+            }
+         }
+
+         std::memcpy(&b[ix], "\"", 1);
+         ++ix;
+         for (size_t i = value.size(); i > 0; --i) {
+            if (value[i - 1]) {
+               std::memcpy(&b[ix], "1", 1);
+            }
+            else {
+               std::memcpy(&b[ix], "0", 1);
+            }
+            ++ix;
          }
-      };
+         std::memcpy(&b[ix], "\"", 1);
+         ++ix;
+      }
+   };
 
-      template <>
-      struct to_json<skip>
+   template <glaze_flags_t T>
+   struct to<JSON, T>
+   {
+      template <auto Opts, class B>
+      static void op(auto&& value, is_context auto&&, B&& b, auto&& ix)
       {
-         template <auto Opts>
-         GLZ_ALWAYS_INLINE static void op(auto&& value, auto&&...) noexcept
-         {
-            static_assert(false_v<decltype(value)>, "skip type should not be written");
+         static constexpr auto N = reflect<T>::size;
+
+         static constexpr auto max_length = [] {
+            size_t length{};
+            [&]<size_t... I>(std::index_sequence<I...>) {
+               ((length += reflect<T>::keys[I].size()), ...);
+            }(std::make_index_sequence<N>{});
+            return length;
+         }() + 4 + 4 * N; // add extra characters
+
+         if constexpr (vector_like<B>) {
+            if (const auto n = ix + max_length; n > b.size()) [[unlikely]] {
+               b.resize(2 * n);
+            }
+         }
+
+         std::memcpy(&b[ix], "[", 1);
+         ++ix;
+
+         for_each<N>([&]<size_t I>() {
+            if (get_member(value, get<I>(reflect<T>::values))) {
+               std::memcpy(&b[ix], "\"", 1);
+               ++ix;
+               constexpr auto& key = reflect<T>::keys[I];
+               if constexpr (not key.empty()) {
+                  constexpr auto n = key.size();
+                  std::memcpy(&b[ix], key.data(), n);
+                  ix += n;
+               }
+               std::memcpy(&b[ix], "\",", 2);
+               ix += 2;
+            }
+         });
+
+         if (b[ix - 1] == ',') {
+            b[ix - 1] = ']';
+         }
+         else {
+            std::memcpy(&b[ix], "]", 1);
+            ++ix;
          }
-      };
+      }
+   };
 
-      template <is_member_function_pointer T>
-      struct to_json<T>
+   template <is_member_function_pointer T>
+   struct to<JSON, T>
+   {
+      template <auto Opts>
+      static void op(auto&&, is_context auto&&, auto&&...) noexcept
+      {}
+   };
+
+   template <is_reference_wrapper T>
+   struct to<JSON, T>
+   {
+      template <auto Opts, class... Args>
+      GLZ_ALWAYS_INLINE static void op(auto&& value, Args&&... args)
       {
-         template <auto Opts>
-         GLZ_ALWAYS_INLINE static void op(auto&&, is_context auto&&, auto&&...) noexcept
-         {}
-      };
+         using V = std::remove_cvref_t<decltype(value.get())>;
+         to<JSON, V>::template op<Opts>(value.get(), std::forward<Args>(args)...);
+      }
+   };
 
-      template <is_reference_wrapper T>
-      struct to_json<T>
+   template <complex_t T>
+   struct to<JSON, T>
+   {
+      template <auto Opts, class B>
+      GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, B&& b, auto&& ix)
       {
-         template <auto Opts, class... Args>
-         GLZ_ALWAYS_INLINE static void op(auto&& value, Args&&... args) noexcept
-         {
-            using V = std::remove_cvref_t<decltype(value.get())>;
-            to_json<V>::template op<Opts>(value.get(), std::forward<Args>(args)...);
+         static_assert(num_t<typename T::value_type>);
+         // we need to know it is a number type to allocate buffer space
+
+         if constexpr (vector_like<B>) {
+            static constexpr size_t max_length = 256;
+            if (const auto n = ix + max_length; n > b.size()) [[unlikely]] {
+               b.resize(2 * n);
+            }
          }
-      };
 
-      template <complex_t T>
-      struct to_json<T>
+         static constexpr auto O = write_unchecked_on<Opts>();
+
+         std::memcpy(&b[ix], "[", 1);
+         ++ix;
+         using Value = core_t<typename T::value_type>;
+         to<JSON, Value>::template op<O>(value.real(), ctx, b, ix);
+         std::memcpy(&b[ix], ",", 1);
+         ++ix;
+         to<JSON, Value>::template op<O>(value.imag(), ctx, b, ix);
+         std::memcpy(&b[ix], "]", 1);
+         ++ix;
+      }
+   };
+
+   template <boolean_like T>
+   struct to<JSON, T>
+   {
+      template <auto Opts, class B>
+      GLZ_ALWAYS_INLINE static void op(const bool value, is_context auto&&, B&& b, auto&& ix)
       {
-         template <auto Opts, class B>
-         GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, B&& b, auto&& ix) noexcept
-         {
-            if constexpr (Opts.write_unchecked && (sizeof(typename T::value_type) <= 8)) {
-               dump_unchecked<'['>(b, ix);
-               write<json>::op<Opts>(value.real(), ctx, b, ix);
-               dump_unchecked<','>(b, ix);
-               write<json>::op<Opts>(value.imag(), ctx, b, ix);
-               dump_unchecked<']'>(b, ix);
+         static constexpr auto checked = not check_write_unchecked(Opts);
+         if constexpr (checked && vector_like<B>) {
+            if (const auto n = ix + 8; n > b.size()) [[unlikely]] {
+               b.resize(2 * n);
+            }
+         }
+
+         if constexpr (Opts.bools_as_numbers) {
+            if (value) {
+               std::memcpy(&b[ix], "1", 1);
             }
             else {
-               dump<'['>(b, ix);
-               write<json>::op<Opts>(value.real(), ctx, b, ix);
-               dump<','>(b, ix);
-               write<json>::op<Opts>(value.imag(), ctx, b, ix);
-               dump<']'>(b, ix);
+               std::memcpy(&b[ix], "0", 1);
             }
+            ++ix;
          }
-      };
+         else {
+            if (value) {
+               std::memcpy(&b[ix], "true", 4);
+               ix += 4;
+            }
+            else {
+               std::memcpy(&b[ix], "false", 5);
+               ix += 5;
+            }
+         }
+      }
+   };
 
-      template <boolean_like T>
-      struct to_json<T>
+   template <num_t T>
+   struct to<JSON, T>
+   {
+      template <auto Opts, class B>
+      GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, B&& b, auto&& ix)
       {
-         template <auto Opts, class... Args>
-         GLZ_ALWAYS_INLINE static void op(const bool value, is_context auto&&, Args&&... args) noexcept
-         {
-            if constexpr (Opts.bools_as_numbers) {
-               if constexpr (Opts.write_unchecked) {
-                  if (value) {
-                     dump_unchecked<"1">(std::forward<Args>(args)...);
-                  }
-                  else {
-                     dump_unchecked<"0">(std::forward<Args>(args)...);
+         if constexpr (not check_write_unchecked(Opts) && vector_like<B>) {
+            static_assert(required_padding<T>());
+            if (const auto n = ix + required_padding<T>(); n > b.size()) [[unlikely]] {
+               b.resize(2 * n);
+            }
+         }
+
+         static constexpr auto O = write_unchecked_on<Opts>();
+
+         if constexpr (Opts.quoted_num) {
+            std::memcpy(&b[ix], "\"", 1);
+            ++ix;
+            write_chars::op<O>(value, ctx, b, ix);
+            std::memcpy(&b[ix], "\"", 1);
+            ++ix;
+         }
+         else {
+            write_chars::op<O>(value, ctx, b, ix);
+         }
+      }
+   };
+
+   inline constexpr std::array<uint16_t, 256> char_escape_table = [] {
+      auto combine = [](const char chars[2]) -> uint16_t { return uint16_t(chars[0]) | (uint16_t(chars[1]) << 8); };
+
+      std::array<uint16_t, 256> t{};
+      t['\b'] = combine(R"(\b)");
+      t['\t'] = combine(R"(\t)");
+      t['\n'] = combine(R"(\n)");
+      t['\f'] = combine(R"(\f)");
+      t['\r'] = combine(R"(\r)");
+      t['\"'] = combine(R"(\")");
+      t['\\'] = combine(R"(\\)");
+      return t;
+   }();
+
+   template <class T>
+      requires str_t<T> || char_t<T>
+   struct to<JSON, T>
+   {
+      template <auto Opts, class B>
+      static void op(auto&& value, is_context auto&&, B&& b, auto&& ix)
+      {
+         if constexpr (Opts.number) {
+            dump_maybe_empty(value, b, ix);
+         }
+         else if constexpr (char_t<T>) {
+            if constexpr (Opts.raw) {
+               dump(value, b, ix);
+            }
+            else {
+               if constexpr (resizable<B>) {
+                  const auto k = ix + 8; // 4 characters is enough for quotes and escaped character
+                  if (k > b.size()) [[unlikely]] {
+                     b.resize(2 * k);
                   }
                }
-               else {
-                  if (value) {
-                     dump<"1">(std::forward<Args>(args)...);
-                  }
-                  else {
-                     dump<"0">(std::forward<Args>(args)...);
-                  }
+
+               std::memcpy(&b[ix], "\"", 1);
+               ++ix;
+               if (const auto escaped = char_escape_table[uint8_t(value)]; escaped) {
+                  std::memcpy(&b[ix], &escaped, 2);
+                  ix += 2;
                }
-            }
-            else {
-               if constexpr (Opts.write_unchecked) {
-                  if (value) {
-                     dump_unchecked<"true">(std::forward<Args>(args)...);
+               else if (value == '\0') {
+                  // null character treated as empty string
+               }
+               else if constexpr (check_escape_control_characters(Opts)) {
+                  if (uint8_t(value) < 0x20) {
+                     // Write as \uXXXX format
+                     char unicode_escape[6] = {'\\', 'u', '0', '0', '0', '0'};
+                     constexpr char hex_digits[] = "0123456789ABCDEF";
+                     unicode_escape[4] = hex_digits[(value >> 4) & 0xF];
+                     unicode_escape[5] = hex_digits[value & 0xF];
+                     std::memcpy(&b[ix], unicode_escape, 6);
+                     ix += 6;
                   }
                   else {
-                     dump_unchecked<"false">(std::forward<Args>(args)...);
+                     std::memcpy(&b[ix], &value, 1);
+                     ++ix;
                   }
                }
                else {
-                  if (value) {
-                     dump<"true">(std::forward<Args>(args)...);
-                  }
-                  else {
-                     dump<"false">(std::forward<Args>(args)...);
-                  }
+                  std::memcpy(&b[ix], &value, 1);
+                  ++ix;
                }
+               std::memcpy(&b[ix], "\"", 1);
+               ++ix;
             }
          }
-      };
+         else {
+            if constexpr (Opts.raw_string) {
+               const sv str = [&]() -> const sv {
+                  if constexpr (!char_array_t<T> && std::is_pointer_v<std::decay_t<T>>) {
+                     return value ? value : "";
+                  }
+                  else {
+                     return value;
+                  }
+               }();
 
-      template <num_t T>
-      struct to_json<T>
-      {
-         template <auto Opts, class B>
-         GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, B&& b, auto&& ix) noexcept
-         {
-            if constexpr (Opts.write_unchecked) {
-               if constexpr (Opts.quoted_num) {
-                  dump_unchecked<'"'>(b, ix);
+               // We need space for quotes and the string length: 2 + n.
+               // Use +8 for extra buffer
+               if constexpr (resizable<B>) {
+                  const auto n = str.size();
+                  const auto k = ix + 8 + n;
+                  if (k > b.size()) [[unlikely]] {
+                     b.resize(2 * k);
+                  }
                }
-               write_chars::op<Opts>(value, ctx, b, ix);
-               if constexpr (Opts.quoted_num) {
-                  dump_unchecked<'"'>(b, ix);
+               // now we don't have to check writing
+
+               std::memcpy(&b[ix], "\"", 1);
+               ++ix;
+               if (str.size()) [[likely]] {
+                  const auto n = str.size();
+                  std::memcpy(&b[ix], str.data(), n);
+                  ix += n;
                }
+               std::memcpy(&b[ix], "\"", 1);
+               ++ix;
             }
             else {
-               if constexpr (Opts.quoted_num) {
-                  dump<'"'>(b, ix);
-               }
-               write_chars::op<Opts>(value, ctx, b, ix);
-               if constexpr (Opts.quoted_num) {
-                  dump<'"'>(b, ix);
-               }
-            }
-         }
-      };
-
-      constexpr std::array<uint16_t, 256> char_escape_table = [] {
-         auto combine = [](const char chars[2]) -> uint16_t { return uint16_t(chars[0]) | (uint16_t(chars[1]) << 8); };
-
-         std::array<uint16_t, 256> t{};
-         t['\b'] = combine(R"(\b)");
-         t['\t'] = combine(R"(\t)");
-         t['\n'] = combine(R"(\n)");
-         t['\f'] = combine(R"(\f)");
-         t['\r'] = combine(R"(\r)");
-         t['\"'] = combine(R"(\")");
-         t['\\'] = combine(R"(\\)");
-         return t;
-      }();
-
-      template <class T>
-         requires str_t<T> || char_t<T>
-      struct to_json<T>
-      {
-         template <auto Opts, class B>
-         static void op(auto&& value, is_context auto&&, B&& b, auto&& ix) noexcept
-         {
-            if constexpr (Opts.number) {
-               dump_maybe_empty(value, b, ix);
-            }
-            else if constexpr (char_t<T>) {
-               if constexpr (Opts.raw) {
-                  dump(value, b, ix);
-               }
-               else {
-                  if constexpr (resizable<B>) {
-                     const auto k = ix + 4; // 4 characters is enough for quotes and escaped character
-                     if (k >= b.size()) [[unlikely]] {
-                        b.resize((std::max)(b.size() * 2, k));
-                     }
-                  }
-
-                  dump_unchecked<'"'>(b, ix);
-                  if (const auto escaped = char_escape_table[uint8_t(value)]; escaped) {
-                     std::memcpy(data_ptr(b) + ix, &escaped, 2);
-                     ix += 2;
+               const sv str = [&]() -> const sv {
+                  if constexpr (!char_array_t<T> && std::is_pointer_v<std::decay_t<T>>) {
+                     return value ? value : "";
                   }
-                  else if (value == '\0') {
-                     // null character treated as empty string
+                  else if constexpr (array_char_t<T>) {
+                     return *value.data() ? sv{value.data()} : "";
                   }
                   else {
-                     dump_unchecked(value, b, ix);
+                     return value;
                   }
-                  dump_unchecked<'"'>(b, ix);
-               }
-            }
-            else {
-               if constexpr (Opts.raw_string) {
-                  const sv str = [&]() -> const sv {
-                     if constexpr (!char_array_t<T> && std::is_pointer_v<std::decay_t<T>>) {
-                        return value ? value : "";
-                     }
-                     else {
-                        return value;
-                     }
-                  }();
+               }();
+               const auto n = str.size();
 
-                  // We need space for quotes and the string length: 2 + n.
+               // In the case n == 0 we need two characters for quotes.
+               // For each individual character we need room for two characters to handle escapes.
+               // When using Unicode escapes, we might need up to 6 characters (\uXXXX) per character
+               if constexpr (check_escape_control_characters(Opts)) {
                   if constexpr (resizable<B>) {
-                     const auto n = str.size();
-                     const auto k = ix + 2 + n;
-                     if (k >= b.size()) [[unlikely]] {
-                        b.resize((std::max)(b.size() * 2, k));
+                     // We need 2 + 6 * n characters in the worst case (all control chars)
+                     const auto k = ix + 10 + 6 * n;
+                     if (k > b.size()) [[unlikely]] {
+                        b.resize(2 * k);
                      }
                   }
-                  // now we don't have to check writing
-
-                  dump_unchecked<'"'>(b, ix);
-                  if (str.size()) [[likely]] {
-                     dump_unchecked(str, b, ix);
-                  }
-                  dump_unchecked<'"'>(b, ix);
                }
                else {
-                  const sv str = [&]() -> const sv {
-                     if constexpr (!char_array_t<T> && std::is_pointer_v<std::decay_t<T>>) {
-                        return value ? value : "";
-                     }
-                     else {
-                        return value;
-                     }
-                  }();
-                  const auto n = str.size();
-
-                  // In the case n == 0 we need two characters for quotes.
-                  // For each individual character we need room for two characters to handle escapes.
-                  // So, we need 2 + 2 * n characters to handle all cases.
-                  // We add another 8 characters to support SWAR
+                  // Using the original sizing
                   if constexpr (resizable<B>) {
                      const auto k = ix + 10 + 2 * n;
-                     if (k >= b.size()) [[unlikely]] {
-                        b.resize((std::max)(b.size() * 2, k));
+                     if (k > b.size()) [[unlikely]] {
+                        b.resize(2 * k);
                      }
                   }
-                  // now we don't have to check writing
+               }
+               // now we don't have to check writing
 
-                  if constexpr (Opts.raw) {
-                     if (str.size()) [[likely]] {
-                        dump_unchecked(str, b, ix);
-                     }
+               if constexpr (Opts.raw) {
+                  if (n) {
+                     std::memcpy(&b[ix], str.data(), n);
+                     ix += n;
                   }
-                  else {
-                     dump_unchecked<'"'>(b, ix);
-
-                     const auto* c = str.data();
-                     const auto* const e = c + n;
-                     const auto start = data_ptr(b) + ix;
-                     auto data = start;
-
-                     // We don't check for writing out invalid characters as this can be tested by the user if
-                     // necessary. In the case of invalid JSON characters we write out null characters to
-                     // showcase the error and make the JSON invalid. These would then be detected upon reading
-                     // the JSON.
-
-                     if (n > 7) {
-                        for (const auto end_m7 = e - 7; c < end_m7;) {
-                           std::memcpy(data, c, 8);
-                           uint64_t swar;
-                           std::memcpy(&swar, c, 8);
-
-                           constexpr uint64_t high_mask = repeat_byte8(0b10000000);
-                           constexpr uint64_t lo7_mask = repeat_byte8(0b01111111);
-                           const uint64_t hi = swar & high_mask;
-                           uint64_t next;
-                           if (hi == high_mask) {
-                              // unescaped unicode has all high bits set
-                              data += 8;
-                              c += 8;
-                              continue;
-                           }
-                           else if (hi == 0) {
-                              // we have only ascii
-                              const uint64_t quote = (swar ^ repeat_byte8('"')) + lo7_mask;
-                              const uint64_t backslash = (swar ^ repeat_byte8('\\')) + lo7_mask;
-                              const uint64_t less_32 = (swar & repeat_byte8(0b01100000)) + lo7_mask;
-                              next = ~(quote & backslash & less_32);
+               }
+               else {
+                  std::memcpy(&b[ix], "\"", 1);
+                  ++ix;
+
+                  const auto* c = str.data();
+                  const auto* const e = c + n;
+                  const auto start = &b[ix];
+                  auto data = start;
+
+                  // We don't check for writing out invalid characters as this can be tested by the user if
+                  // necessary. In the case of invalid JSON characters we write out null characters to
+                  // showcase the error and make the JSON invalid. These would then be detected upon reading
+                  // the JSON.
+
+#if defined(GLZ_USE_AVX2)
+                  // Optimization for systems with AVX2 support
+                  if (n > 31) {
+                     const __m256i lo7_mask = _mm256_set1_epi8(0b01111111);
+                     const __m256i quote_char = _mm256_set1_epi8('"');
+                     const __m256i backslash_char = _mm256_set1_epi8('\\');
+                     const __m256i less_32_mask = _mm256_set1_epi8(0b01100000);
+                     const __m256i high_bit_mask = _mm256_set1_epi8(static_cast<int8_t>(0b10000000));
+
+                     for (const char* end_m31 = e - 31; c < end_m31;) {
+                        __m256i v = _mm256_loadu_si256(reinterpret_cast<const __m256i*>(c));
+
+                        _mm256_storeu_si256(reinterpret_cast<__m256i*>(data), v);
+
+                        const __m256i lo7 = _mm256_and_si256(v, lo7_mask);
+                        const __m256i quote = _mm256_add_epi8(_mm256_xor_si256(lo7, quote_char), lo7_mask);
+                        const __m256i backslash = _mm256_add_epi8(_mm256_xor_si256(lo7, backslash_char), lo7_mask);
+                        const __m256i less_32 = _mm256_add_epi8(_mm256_and_si256(v, less_32_mask), lo7_mask);
+
+                        __m256i temp = _mm256_and_si256(quote, backslash);
+                        temp = _mm256_and_si256(temp, less_32);
+                        temp = _mm256_or_si256(temp, v);
+                        __m256i next = _mm256_andnot_si256(temp, _mm256_set1_epi8(-1)); // Equivalent to ~temp
+                        next = _mm256_and_si256(next, high_bit_mask);
+
+                        uint32_t mask = _mm256_movemask_epi8(next);
+
+                        if (mask == 0) {
+                           data += 32;
+                           c += 32;
+                           continue;
+                        }
+
+                        uint32_t length = countr_zero(mask);
+
+                        c += length;
+                        data += length;
+
+                        if constexpr (check_escape_control_characters(Opts)) {
+                           if (const auto escaped = char_escape_table[uint8_t(*c)]; escaped) {
+                              std::memcpy(data, &escaped, 2);
+                              data += 2;
                            }
                            else {
-                              const uint64_t lo7 = swar & lo7_mask;
-                              const uint64_t quote = (lo7 ^ repeat_byte8('"')) + lo7_mask;
-                              const uint64_t backslash = (lo7 ^ repeat_byte8('\\')) + lo7_mask;
-                              const uint64_t less_32 = (swar & repeat_byte8(0b01100000)) + lo7_mask;
-                              next = ~((quote & backslash & less_32) | swar);
+                              // Write as \uXXXX format for control characters
+                              char unicode_escape[6] = {'\\', 'u', '0', '0', '0', '0'};
+                              constexpr char hex_digits[] = "0123456789ABCDEF";
+                              unicode_escape[4] = hex_digits[(uint8_t(*c) >> 4) & 0xF];
+                              unicode_escape[5] = hex_digits[uint8_t(*c) & 0xF];
+                              std::memcpy(data, unicode_escape, 6);
+                              data += 6;
                            }
+                        }
+                        else {
+                           std::memcpy(data, &char_escape_table[uint8_t(*c)], 2);
+                           data += 2;
+                        }
+                        ++c;
+                     }
+                  }
+#endif
+
+                  if (n > 7) {
+                     for (const auto end_m7 = e - 7; c < end_m7;) {
+                        std::memcpy(data, c, 8);
+                        uint64_t swar;
+                        std::memcpy(&swar, c, 8);
+
+                        constexpr uint64_t lo7_mask = repeat_byte8(0b01111111);
+                        const uint64_t lo7 = swar & lo7_mask;
+                        const uint64_t quote = (lo7 ^ repeat_byte8('"')) + lo7_mask;
+                        const uint64_t backslash = (lo7 ^ repeat_byte8('\\')) + lo7_mask;
+                        const uint64_t less_32 = (swar & repeat_byte8(0b01100000)) + lo7_mask;
+                        uint64_t next = ~((quote & backslash & less_32) | swar);
+
+                        next &= repeat_byte8(0b10000000);
+                        if (next == 0) {
+                           data += 8;
+                           c += 8;
+                           continue;
+                        }
 
-                           next &= repeat_byte8(0b10000000);
-                           if (next) {
-                              const auto length = (countr_zero(next) >> 3);
-                              c += length;
-                              data += length;
+                        const auto length = (countr_zero(next) >> 3);
+                        c += length;
+                        data += length;
 
-                              std::memcpy(data, &char_escape_table[uint8_t(*c)], 2);
+                        if constexpr (check_escape_control_characters(Opts)) {
+                           if (const auto escaped = char_escape_table[uint8_t(*c)]; escaped) {
+                              std::memcpy(data, &escaped, 2);
                               data += 2;
-                              ++c;
                            }
                            else {
-                              data += 8;
-                              c += 8;
+                              // Write as \uXXXX format for control characters
+                              char unicode_escape[6] = {'\\', 'u', '0', '0', '0', '0'};
+                              constexpr char hex_digits[] = "0123456789ABCDEF";
+                              unicode_escape[4] = hex_digits[(uint8_t(*c) >> 4) & 0xF];
+                              unicode_escape[5] = hex_digits[uint8_t(*c) & 0xF];
+                              std::memcpy(data, unicode_escape, 6);
+                              data += 6;
                            }
                         }
+                        else {
+                           std::memcpy(data, &char_escape_table[uint8_t(*c)], 2);
+                           data += 2;
+                        }
+                        ++c;
                      }
+                  }
 
-                     // Tail end of buffer. Uncommon for long strings.
-                     for (; c < e; ++c) {
-                        if (const auto escaped = char_escape_table[uint8_t(*c)]; escaped) {
-                           std::memcpy(data, &escaped, 2);
-                           data += 2;
+                  // Tail end of buffer. Uncommon for long strings.
+                  for (; c < e; ++c) {
+                     if (const auto escaped = char_escape_table[uint8_t(*c)]; escaped) {
+                        std::memcpy(data, &escaped, 2);
+                        data += 2;
+                     }
+                     else if constexpr (check_escape_control_characters(Opts)) {
+                        if (uint8_t(*c) < 0x20) {
+                           // Write as \uXXXX format for control characters
+                           char unicode_escape[6] = {'\\', 'u', '0', '0', '0', '0'};
+                           constexpr char hex_digits[] = "0123456789ABCDEF";
+                           unicode_escape[4] = hex_digits[(uint8_t(*c) >> 4) & 0xF];
+                           unicode_escape[5] = hex_digits[uint8_t(*c) & 0xF];
+                           std::memcpy(data, unicode_escape, 6);
+                           data += 6;
                         }
                         else {
                            std::memcpy(data, c, 1);
                            ++data;
                         }
                      }
+                     else {
+                        std::memcpy(data, c, 1);
+                        ++data;
+                     }
+                  }
 
-                     ix += size_t(data - start);
+                  ix += size_t(data - start);
 
-                     dump_unchecked<'"'>(b, ix);
-                  }
+                  std::memcpy(&b[ix], "\"", 1);
+                  ++ix;
                }
             }
          }
-      };
-
-      template <filesystem_path T>
-      struct to_json<T>
-      {
-         template <auto Opts, class... Args>
-         GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, Args&&... args) noexcept
-         {
-            to_json<decltype(value.string())>::template op<Opts>(value.string(), ctx, args...);
-         }
-      };
+      }
+   };
 
-      template <class T>
-         requires(glaze_enum_t<T> && !custom_write<T>)
-      struct to_json<T>
+   template <class T>
+      requires((glaze_enum_t<T> || (meta_keys<T> && std::is_enum_v<std::decay_t<T>>)) && not custom_write<T>)
+   struct to<JSON, T>
+   {
+      template <auto Opts, class... Args>
+      GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, Args&&... args)
       {
-         template <auto Opts, class... Args>
-         GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, Args&&... args) noexcept
-         {
-            using key_t = std::underlying_type_t<T>;
-            static constexpr auto frozen_map = detail::make_enum_to_string_map<T>();
-            const auto& member_it = frozen_map.find(static_cast<key_t>(value));
-            if (member_it != frozen_map.end()) {
-               const sv str = {member_it->second.data(), member_it->second.size()};
-               // TODO: Assumes people dont use strings with chars that need to be escaped for their enum names
-               // TODO: Could create a pre quoted map for better performance
-               if constexpr (not Opts.raw) {
-                  dump<'"'>(args...);
-               }
-               dump_maybe_empty(str, args...);
-               if constexpr (not Opts.raw) {
-                  dump<'"'>(args...);
-               }
+         // TODO: Use new hashing approach for better performance
+         // TODO: Check if sequenced and use the value as the index if so
+         using key_t = std::underlying_type_t<T>;
+         static constexpr auto frozen_map = make_enum_to_string_map<T>();
+         const auto& member_it = frozen_map.find(static_cast<key_t>(value));
+         if (member_it != frozen_map.end()) {
+            const sv str = {member_it->second.data(), member_it->second.size()};
+            // TODO: Assumes people dont use strings with chars that need to be escaped for their enum names
+            // TODO: Could create a pre quoted map for better performance
+            if constexpr (not Opts.raw) {
+               dump<'"'>(args...);
             }
-            else [[unlikely]] {
-               // What do we want to happen if the value doesnt have a mapped string
-               write<json>::op<Opts>(static_cast<std::underlying_type_t<T>>(value), ctx, std::forward<Args>(args)...);
+            dump_maybe_empty(str, args...);
+            if constexpr (not Opts.raw) {
+               dump<'"'>(args...);
             }
          }
-      };
-
-      template <class T>
-         requires(std::is_enum_v<std::decay_t<T>> && !glaze_enum_t<T> && !custom_write<T>)
-      struct to_json<T>
-      {
-         template <auto Opts, class... Args>
-         GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, Args&&... args) noexcept
-         {
-            write<json>::op<Opts>(static_cast<std::underlying_type_t<std::decay_t<T>>>(value), ctx,
-                                  std::forward<Args>(args)...);
+         else [[unlikely]] {
+            // What do we want to happen if the value doesn't have a mapped string
+            serialize<JSON>::op<Opts>(static_cast<std::underlying_type_t<T>>(value), ctx, std::forward<Args>(args)...);
          }
-      };
+      }
+   };
 
-      template <func_t T>
-      struct to_json<T>
+   template <class T>
+      requires(!meta_keys<T> && std::is_enum_v<std::decay_t<T>> && !glaze_enum_t<T> && !custom_write<T>)
+   struct to<JSON, T>
+   {
+      template <auto Opts, class... Args>
+      GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, Args&&... args)
       {
-         template <auto Opts, class... Args>
-         GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&&, Args&&... args) noexcept
-         {
-            dump<'"'>(args...);
-            dump_maybe_empty(name_v<std::decay_t<decltype(value)>>, args...);
-            dump<'"'>(args...);
-         }
-      };
+         // serialize as underlying number
+         serialize<JSON>::op<Opts>(static_cast<std::underlying_type_t<std::decay_t<T>>>(value), ctx,
+                                   std::forward<Args>(args)...);
+      }
+   };
 
-      template <class T>
-      struct to_json<basic_raw_json<T>>
+   template <func_t T>
+   struct to<JSON, T>
+   {
+      template <auto Opts, class B>
+      GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&&, B&& b, auto&& ix)
       {
-         template <auto Opts>
-         GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&&, auto&& b, auto&& ix) noexcept
-         {
-            dump_maybe_empty(value.str, b, ix);
+         static constexpr auto name = name_v<std::decay_t<decltype(value)>>;
+         constexpr auto n = name.size();
+
+         if constexpr (vector_like<B>) {
+            if (const auto k = ix + 8 + n; k > b.size()) [[unlikely]] {
+               b.resize(2 * k);
+            }
          }
-      };
 
-      template <class T>
-      struct to_json<basic_text<T>>
-      {
-         template <auto Opts>
-         GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&&, auto&& b, auto&& ix) noexcept
-         {
-            dump_maybe_empty(value.str, b, ix);
+         std::memcpy(&b[ix], "\"", 1);
+         ++ix;
+         if constexpr (not name.empty()) {
+            std::memcpy(&b[ix], name.data(), n);
+            ix += n;
          }
-      };
+         std::memcpy(&b[ix], "\"", 1);
+         ++ix;
+      }
+   };
 
-      template <opts Opts, class B, class Ix>
-      GLZ_ALWAYS_INLINE void write_entry_separator(is_context auto&& ctx, B&& b, Ix&& ix) noexcept
+   template <class T>
+   struct to<JSON, basic_raw_json<T>>
+   {
+      template <auto Opts, class B>
+      GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&&, B&& b, auto&& ix)
       {
-         if constexpr (Opts.prettify) {
+         const auto n = value.str.size();
+         if (n) {
             if constexpr (vector_like<B>) {
-               if (const auto k = ix + ctx.indentation_level + write_padding_bytes; k > b.size()) [[unlikely]] {
-                  b.resize((std::max)(b.size() * 2, k));
+               if (const auto k = ix + n + write_padding_bytes; k > b.size()) [[unlikely]] {
+                  b.resize(2 * k);
                }
             }
-            dump_unchecked<",\n">(b, ix);
-            dumpn_unchecked<Opts.indentation_char>(ctx.indentation_level, b, ix);
-         }
-         else {
-            dump<','>(b, ix);
+
+            std::memcpy(&b[ix], value.str.data(), n);
+            ix += n;
          }
       }
+   };
 
-      template <opts Opts>
-      GLZ_ALWAYS_INLINE void write_array_to_json(auto&& value, is_context auto&& ctx, auto&&... args)
+   template <class T>
+   struct to<JSON, basic_text<T>>
+   {
+      template <auto Opts, class B>
+      GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&&, B&& b, auto&& ix)
       {
-         dump<'['>(args...);
-
-         if (!empty_range(value)) {
-            if constexpr (Opts.prettify) {
-               ctx.indentation_level += Opts.indentation_width;
-               dump_newline_indent<Opts.indentation_char>(ctx.indentation_level, args...);
+         const auto n = value.str.size();
+         if (n) {
+            if constexpr (vector_like<B>) {
+               if (const auto k = ix + n + write_padding_bytes; k > b.size()) [[unlikely]] {
+                  b.resize(2 * k);
+               }
             }
 
-            auto it = std::begin(value);
-            write<json>::op<Opts>(*it, ctx, args...);
-            ++it;
-            for (const auto fin = std::end(value); it != fin; ++it) {
-               write_entry_separator<Opts>(ctx, args...);
-               write<json>::op<Opts>(*it, ctx, args...);
-            }
-            if constexpr (Opts.prettify) {
-               ctx.indentation_level -= Opts.indentation_width;
-               dump_newline_indent<Opts.indentation_char>(ctx.indentation_level, args...);
-            }
+            std::memcpy(&b[ix], value.str.data(), n);
+            ix += n;
          }
-
-         dump<']'>(args...);
       }
+   };
 
-      template <writable_array_t T>
-      struct to_json<T>
-      {
-         template <auto Opts>
-         GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, auto&&... args) noexcept
-         {
-            write_array_to_json<Opts>(value, ctx, args...);
+   template <auto Opts, bool minified_check = true, class B>
+   GLZ_ALWAYS_INLINE void write_array_entry_separator(is_context auto&& ctx, B&& b, auto&& ix)
+   {
+      if constexpr (Opts.prettify) {
+         if constexpr (vector_like<B>) {
+            if (const auto k = ix + ctx.indentation_level + write_padding_bytes; k > b.size()) [[unlikely]] {
+               b.resize(2 * k);
+            }
          }
-      };
-
-      template <opts Opts, class Key, class Value, is_context Ctx>
-      GLZ_ALWAYS_INLINE void write_pair_content(const Key& key, Value&& value, Ctx& ctx, auto&&... args) noexcept
-      {
-         if constexpr (str_t<Key> || char_t<Key> || glaze_enum_t<Key> || Opts.quoted_num) {
-            write<json>::op<Opts>(key, ctx, args...);
+         if constexpr (Opts.new_lines_in_arrays) {
+            std::memcpy(&b[ix], ",\n", 2);
+            ix += 2;
+            std::memset(&b[ix], Opts.indentation_char, ctx.indentation_level);
+            ix += ctx.indentation_level;
          }
          else {
-            write<json>::op<opt_false<Opts, &opts::raw_string>>(quoted_t<const Key>{key}, ctx, args...);
-         }
-         if constexpr (Opts.prettify) {
-            dump<": ">(args...);
+            std::memcpy(&b[ix], ", ", 2);
+            ix += 2;
          }
-         else {
-            dump<':'>(args...);
+      }
+      else {
+         if constexpr (vector_like<B>) {
+            if constexpr (minified_check) {
+               if (ix >= b.size()) [[unlikely]] {
+                  b.resize(2 * ix);
+               }
+            }
          }
+         std::memcpy(&b[ix], ",", 1);
+         ++ix;
+      }
+   }
 
-         write<json>::op<opening_and_closing_handled_off<Opts>()>(std::forward<Value>(value), ctx, args...);
+   // "key":value pair output
+   template <auto Opts, class Key, class Value, is_context Ctx, class B>
+   GLZ_ALWAYS_INLINE void write_pair_content(const Key& key, Value&& value, Ctx& ctx, B&& b, auto&& ix)
+   {
+      if constexpr (str_t<Key> || char_t<Key> || glaze_enum_t<Key> || Opts.quoted_num) {
+         to<JSON, core_t<Key>>::template op<Opts>(key, ctx, b, ix);
+      }
+      else if constexpr (num_t<Key>) {
+         serialize<JSON>::op<opt_true<Opts, &opts::quoted_num>>(key, ctx, b, ix);
       }
+      else {
+         serialize<JSON>::op<opt_false<Opts, &opts::raw_string>>(quoted_t<const Key>{key}, ctx, b, ix);
+      }
+      if constexpr (Opts.prettify) {
+         dump<": ">(b, ix);
+      }
+      else {
+         dump<':'>(b, ix);
+      }
+
+      using V = core_t<decltype(value)>;
+      to<JSON, V>::template op<opening_and_closing_handled_off<Opts>()>(value, ctx, b, ix);
+   }
+
+   template <class T>
+   concept array_padding_known =
+      requires { typename T::value_type; } && (required_padding<typename T::value_type>() > 0);
+
+   template <class T>
+      requires(writable_array_t<T> || writable_map_t<T>)
+   struct to<JSON, T>
+   {
+      static constexpr bool map_like_array = writable_array_t<T> && pair_t<range_value_t<T>>;
 
-      template <opts Opts, class Value>
-      [[nodiscard]] GLZ_ALWAYS_INLINE constexpr bool skip_member(const Value& value) noexcept
+      template <auto Opts, class B>
+         requires(writable_array_t<T> && (map_like_array ? check_concatenate(Opts) == false : true))
+      GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, B&& b, auto&& ix)
       {
-         if constexpr (null_t<Value> && Opts.skip_null_members) {
-            if constexpr (always_null_t<Value>)
-               return true;
-            else {
-               return !bool(value);
-            }
+         if (empty_range(value)) {
+            dump<"[]">(b, ix);
          }
          else {
-            return false;
-         }
-      }
+            if constexpr (has_size<T> && array_padding_known<T>) {
+               const auto n = value.size();
 
-      template <pair_t T>
-      struct to_json<T>
-      {
-         template <glz::opts Opts, class B, class Ix>
-         static void op(const T& value, is_context auto&& ctx, B&& b, Ix&& ix) noexcept
-         {
-            const auto& [key, val] = value;
-            if (skip_member<Opts>(val)) {
-               return dump<"{}">(b, ix);
-            }
+               static constexpr auto value_padding = required_padding<typename T::value_type>();
 
-            if constexpr (Opts.prettify) {
-               ctx.indentation_level += Opts.indentation_width;
-               if constexpr (vector_like<B>) {
-                  if (const auto k = ix + ctx.indentation_level + 2; k > b.size()) [[unlikely]] {
-                     b.resize((std::max)(b.size() * 2, k));
+               if constexpr (Opts.prettify) {
+                  if constexpr (Opts.new_lines_in_arrays) {
+                     ctx.indentation_level += Opts.indentation_width;
+                  }
+
+                  if constexpr (vector_like<B>) {
+                     // add space for '\n' and ',' characters for each element, hence `+ 2`
+                     // use n + 1 because we put the end array character after the last element with whitespace
+                     if (const auto k =
+                            ix + (n + 1) * (value_padding + ctx.indentation_level + 2) + write_padding_bytes;
+                         k > b.size()) {
+                        b.resize(2 * k);
+                     }
+                  }
+
+                  if constexpr (Opts.new_lines_in_arrays) {
+                     std::memcpy(&b[ix], "[\n", 2);
+                     ix += 2;
+                     std::memset(&b[ix], Opts.indentation_char, ctx.indentation_level);
+                     ix += ctx.indentation_level;
+                  }
+                  else {
+                     std::memcpy(&b[ix], "[", 1);
+                     ++ix;
                   }
                }
-               dump_unchecked<"{\n">(b, ix);
-               dumpn_unchecked<Opts.indentation_char>(ctx.indentation_level, b, ix);
-            }
-            else {
-               dump<'{'>(b, ix);
-            }
+               else {
+                  if constexpr (vector_like<B>) {
+                     static constexpr auto comma_padding = 1;
+                     if (const auto k = ix + n * (value_padding + comma_padding) + write_padding_bytes; k > b.size())
+                        [[unlikely]] {
+                        b.resize(2 * k);
+                     }
+                  }
+                  std::memcpy(&b[ix], "[", 1);
+                  ++ix;
+               }
 
-            write_pair_content<Opts>(key, val, ctx, b, ix);
+               auto it = std::begin(value);
+               using val_t = std::remove_cvref_t<decltype(*it)>;
+               to<JSON, val_t>::template op<write_unchecked_on<Opts>()>(*it, ctx, b, ix);
 
-            if constexpr (Opts.prettify) {
-               ctx.indentation_level -= Opts.indentation_width;
-               dump_newline_indent<Opts.indentation_char>(ctx.indentation_level, b, ix);
-               dump_unchecked<'}'>(b, ix);
-            }
-            else {
-               dump<'}'>(b, ix);
-            }
-         }
-      };
+               ++it;
+               for (const auto fin = std::end(value); it != fin; ++it) {
+                  if constexpr (Opts.prettify) {
+                     if constexpr (Opts.new_lines_in_arrays) {
+                        std::memcpy(&b[ix], ",\n", 2);
+                        ix += 2;
+                        std::memset(&b[ix], Opts.indentation_char, ctx.indentation_level);
+                        ix += ctx.indentation_level;
+                     }
+                     else {
+                        std::memcpy(&b[ix], ", ", 2);
+                        ix += 2;
+                     }
+                  }
+                  else {
+                     std::memcpy(&b[ix], ",", 1);
+                     ++ix;
+                  }
 
-      template <writable_map_t T>
-      struct to_json<T>
-      {
-         template <glz::opts Opts, class... Args>
-            requires(!Opts.concatenate)
-         GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, Args&&... args) noexcept
-         {
-            write_array_to_json<Opts>(value, ctx, args...);
-         }
+                  to<JSON, val_t>::template op<write_unchecked_on<Opts>()>(*it, ctx, b, ix);
+               }
+               if constexpr (Opts.prettify && Opts.new_lines_in_arrays) {
+                  ctx.indentation_level -= Opts.indentation_width;
+                  std::memcpy(&b[ix], "\n", 1);
+                  ++ix;
+                  std::memset(&b[ix], Opts.indentation_char, ctx.indentation_level);
+                  ix += ctx.indentation_level;
+               }
 
-         template <glz::opts Opts, class... Args>
-            requires(Opts.concatenate)
-         static void op(auto&& value, is_context auto&& ctx, Args&&... args) noexcept
-         {
-            if constexpr (!Opts.opening_handled) {
-               dump<'{'>(args...);
+               std::memcpy(&b[ix], "]", 1);
+               ++ix;
             }
+            else {
+               // we either can't get the size (std::forward_list) or we cannot compute the allocation size
 
-            if (!empty_range(value)) {
-               if constexpr (!Opts.opening_handled) {
-                  if constexpr (Opts.prettify) {
+               if constexpr (Opts.prettify) {
+                  if constexpr (Opts.new_lines_in_arrays) {
                      ctx.indentation_level += Opts.indentation_width;
-                     dump_newline_indent<Opts.indentation_char>(ctx.indentation_level, args...);
                   }
-               }
 
-               auto write_first_entry = [&ctx, &args...](auto&& it) {
-                  if constexpr (requires {
-                                   it->first;
-                                   it->second;
-                                }) {
-                     // Allow non-const access, unlike ranges
-                     if (skip_member<Opts>(it->second)) {
-                        return true;
+                  if constexpr (vector_like<B>) {
+                     if (const auto k = ix + ctx.indentation_level + write_padding_bytes; k > b.size()) [[unlikely]] {
+                        b.resize(2 * k);
                      }
-                     write_pair_content<Opts>(it->first, it->second, ctx, args...);
-                     return false;
+                  }
+
+                  if constexpr (Opts.new_lines_in_arrays) {
+                     std::memcpy(&b[ix], "[\n", 2);
+                     ix += 2;
+                     std::memset(&b[ix], Opts.indentation_char, ctx.indentation_level);
+                     ix += ctx.indentation_level;
                   }
                   else {
-                     const auto& [key, entry_val] = *it;
-                     if (skip_member<Opts>(entry_val)) {
-                        return true;
+                     std::memcpy(&b[ix], "[", 1);
+                     ++ix;
+                  }
+               }
+               else {
+                  if constexpr (vector_like<B>) {
+                     if (const auto k = ix + write_padding_bytes; k > b.size()) [[unlikely]] {
+                        b.resize(2 * k);
                      }
-                     write_pair_content<Opts>(key, entry_val, ctx, args...);
-                     return false;
                   }
-               };
+                  std::memcpy(&b[ix], "[", 1);
+                  ++ix;
+               }
 
                auto it = std::begin(value);
-               [[maybe_unused]] bool starting = write_first_entry(it);
-               for (++it; it != std::end(value); ++it) {
-                  // I couldn't find an easy way around this code duplication
-                  // Ranges need to be decomposed with const auto& [...],
-                  // but we don't want to const qualify our maps for the sake of reflection writing
-                  // we need to be able to populate the tuple of pointers when writing with reflection
-                  if constexpr (requires {
-                                   it->first;
-                                   it->second;
-                                }) {
-                     if (skip_member<Opts>(it->second)) {
-                        continue;
+               using val_t = std::remove_cvref_t<decltype(*it)>;
+               if constexpr (required_padding<val_t>()) {
+                  to<JSON, val_t>::template op<write_unchecked_on<Opts>()>(*it, ctx, b, ix);
+               }
+               else {
+                  to<JSON, val_t>::template op<Opts>(*it, ctx, b, ix);
+               }
+
+               ++it;
+               for (const auto fin = std::end(value); it != fin; ++it) {
+                  if constexpr (required_padding<val_t>()) {
+                     if constexpr (vector_like<B>) {
+                        if constexpr (Opts.prettify) {
+                           if (const auto k = ix + ctx.indentation_level + write_padding_bytes; k > b.size())
+                              [[unlikely]] {
+                              b.resize(2 * k);
+                           }
+                        }
+                        else {
+                           if (const auto k = ix + write_padding_bytes; k > b.size()) [[unlikely]] {
+                              b.resize(2 * k);
+                           }
+                        }
                      }
 
-                     // When Opts.skip_null_members, *any* entry may be skipped, meaning separator dumping must be
-                     // conditional for every entry. Avoid this branch when not skipping null members.
-                     // Alternatively, write separator after each entry except last but then branch is permanent
-                     if constexpr (Opts.skip_null_members) {
-                        if (!starting) {
-                           write_entry_separator<Opts>(ctx, args...);
+                     if constexpr (Opts.prettify) {
+                        if constexpr (Opts.new_lines_in_arrays) {
+                           std::memcpy(&b[ix], ",\n", 2);
+                           ix += 2;
+                           std::memset(&b[ix], Opts.indentation_char, ctx.indentation_level);
+                           ix += ctx.indentation_level;
+                        }
+                        else {
+                           std::memcpy(&b[ix], ", ", 2);
+                           ix += 2;
                         }
                      }
                      else {
-                        write_entry_separator<Opts>(ctx, args...);
+                        std::memcpy(&b[ix], ",", 1);
+                        ++ix;
                      }
 
-                     write_pair_content<Opts>(it->first, it->second, ctx, args...);
+                     to<JSON, val_t>::template op<write_unchecked_on<Opts>()>(*it, ctx, b, ix);
                   }
                   else {
-                     const auto& [key, entry_val] = *it;
+                     write_array_entry_separator<Opts>(ctx, b, ix);
+                     to<JSON, val_t>::template op<Opts>(*it, ctx, b, ix);
+                  }
+               }
+               if constexpr (Opts.prettify && Opts.new_lines_in_arrays) {
+                  ctx.indentation_level -= Opts.indentation_width;
+                  dump_newline_indent<Opts.indentation_char>(ctx.indentation_level, b, ix);
+               }
+
+               dump<']'>(b, ix);
+            }
+         }
+      }
+
+      template <auto Opts, class B>
+         requires(writable_map_t<T> || (map_like_array && check_concatenate(Opts) == true))
+      static void op(auto&& value, is_context auto&& ctx, B&& b, auto&& ix)
+      {
+         if constexpr (not check_opening_handled(Opts)) {
+            dump<'{'>(b, ix);
+         }
+
+         if (!empty_range(value)) {
+            if constexpr (!check_opening_handled(Opts)) {
+               if constexpr (Opts.prettify) {
+                  ctx.indentation_level += Opts.indentation_width;
+                  if constexpr (vector_like<B>) {
+                     if (const auto k = ix + ctx.indentation_level + write_padding_bytes; k > b.size()) [[unlikely]] {
+                        b.resize(2 * k);
+                     }
+                  }
+                  std::memcpy(&b[ix], "\n", 1);
+                  ++ix;
+                  std::memset(&b[ix], Opts.indentation_char, ctx.indentation_level);
+                  ix += ctx.indentation_level;
+               }
+            }
+
+            using val_t = detail::iterator_second_type<T>; // the type of value in each [key, value] pair
+
+            if constexpr (not always_skipped<val_t>) {
+               if constexpr (null_t<val_t> && Opts.skip_null_members) {
+                  auto write_first_entry = [&](auto&& it) {
+                     auto&& [key, entry_val] = *it;
+                     if (skip_member<Opts>(entry_val)) {
+                        return true;
+                     }
+                     write_pair_content<Opts>(key, entry_val, ctx, b, ix);
+                     return false;
+                  };
+
+                  auto it = std::begin(value);
+                  bool first = write_first_entry(it);
+                  ++it;
+                  for (const auto end = std::end(value); it != end; ++it) {
+                     auto&& [key, entry_val] = *it;
                      if (skip_member<Opts>(entry_val)) {
                         continue;
                      }
 
                      // When Opts.skip_null_members, *any* entry may be skipped, meaning separator dumping must be
-                     // conditional for every entry. Avoid this branch when not skipping null members.
+                     // conditional for every entry.
                      // Alternatively, write separator after each entry except last but then branch is permanent
-                     if constexpr (Opts.skip_null_members) {
-                        if (!starting) {
-                           write_entry_separator<Opts>(ctx, args...);
-                        }
-                     }
-                     else {
-                        write_entry_separator<Opts>(ctx, args...);
+                     if (not first) {
+                        write_object_entry_separator<Opts>(ctx, b, ix);
                      }
 
-                     write_pair_content<Opts>(key, entry_val, ctx, args...);
-                  }
+                     write_pair_content<Opts>(key, entry_val, ctx, b, ix);
 
-                  starting = false;
+                     first = false;
+                  }
                }
-
-               if constexpr (!Opts.closing_handled) {
-                  if constexpr (Opts.prettify) {
-                     ctx.indentation_level -= Opts.indentation_width;
-                     dump_newline_indent<Opts.indentation_char>(ctx.indentation_level, args...);
+               else {
+                  auto write_first_entry = [&](auto&& it) {
+                     auto&& [key, entry_val] = *it;
+                     write_pair_content<Opts>(key, entry_val, ctx, b, ix);
+                  };
+
+                  auto it = std::begin(value);
+                  write_first_entry(it);
+                  ++it;
+                  for (const auto end = std::end(value); it != end; ++it) {
+                     auto&& [key, entry_val] = *it;
+                     write_object_entry_separator<Opts>(ctx, b, ix);
+                     write_pair_content<Opts>(key, entry_val, ctx, b, ix);
                   }
                }
             }
 
-            if constexpr (!Opts.closing_handled) {
-               dump<'}'>(args...);
+            if constexpr (!check_closing_handled(Opts)) {
+               if constexpr (Opts.prettify) {
+                  ctx.indentation_level -= Opts.indentation_width;
+                  if constexpr (vector_like<B>) {
+                     if (const auto k = ix + ctx.indentation_level + write_padding_bytes; k > b.size()) [[unlikely]] {
+                        b.resize(2 * k);
+                     }
+                  }
+                  std::memcpy(&b[ix], "\n", 1);
+                  ++ix;
+                  std::memset(&b[ix], Opts.indentation_char, ctx.indentation_level);
+                  ix += ctx.indentation_level;
+               }
             }
          }
-      };
 
-      template <is_expected T>
-      struct to_json<T>
+         if constexpr (!check_closing_handled(Opts)) {
+            dump<'}'>(b, ix);
+         }
+      }
+   };
+
+   template <pair_t T>
+   struct to<JSON, T>
+   {
+      template <auto Opts, class B, class Ix>
+      static void op(const T& value, is_context auto&& ctx, B&& b, Ix&& ix)
       {
-         template <auto Opts, class... Args>
-         GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, Args&&... args) noexcept
-         {
-            if (value) {
-               write<json>::op<Opts>(*value, ctx, std::forward<Args>(args)...);
-            }
-            else {
-               write<json>::op<Opts>(unexpected_wrapper{&value.error()}, ctx, std::forward<Args>(args)...);
+         const auto& [key, val] = value;
+         if (skip_member<Opts>(val)) {
+            return dump<"{}">(b, ix);
+         }
+
+         if constexpr (Opts.prettify) {
+            ctx.indentation_level += Opts.indentation_width;
+            if constexpr (vector_like<B>) {
+               if (const auto k = ix + ctx.indentation_level + 2; k > b.size()) [[unlikely]] {
+                  b.resize(2 * k);
+               }
             }
+            dump<"{\n", false>(b, ix);
+            std::memset(&b[ix], Opts.indentation_char, ctx.indentation_level);
+            ix += ctx.indentation_level;
+         }
+         else {
+            dump<'{'>(b, ix);
+         }
+
+         write_pair_content<Opts>(key, val, ctx, b, ix);
+
+         if constexpr (Opts.prettify) {
+            ctx.indentation_level -= Opts.indentation_width;
+            dump_newline_indent<Opts.indentation_char>(ctx.indentation_level, b, ix);
+            dump<'}', false>(b, ix);
+         }
+         else {
+            dump<'}'>(b, ix);
          }
-      };
+      }
+   };
 
-      // for C style arrays
-      template <nullable_t T>
-         requires(std::is_array_v<T>)
-      struct to_json<T>
+   template <is_expected T>
+   struct to<JSON, T>
+   {
+      template <auto Opts, class... Args>
+      GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, Args&&... args)
       {
-         template <auto Opts, class V, size_t N, class... Args>
-         GLZ_ALWAYS_INLINE static void op(const V (&value)[N], is_context auto&& ctx, Args&&... args) noexcept
-         {
-            write<json>::op<Opts>(std::span{value, N}, ctx, std::forward<Args>(args)...);
+         if (value) {
+            serialize<JSON>::op<Opts>(*value, ctx, std::forward<Args>(args)...);
          }
-      };
+         else {
+            serialize<JSON>::op<Opts>(unexpected_wrapper{&value.error()}, ctx, std::forward<Args>(args)...);
+         }
+      }
+   };
 
-      template <optional_like T>
-      struct to_json<T>
+   // for C style arrays
+   template <nullable_t T>
+      requires(std::is_array_v<T>)
+   struct to<JSON, T>
+   {
+      template <auto Opts, class V, size_t N, class... Args>
+      GLZ_ALWAYS_INLINE static void op(const V (&value)[N], is_context auto&& ctx, Args&&... args)
       {
-         template <auto Opts, class... Args>
-         GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, Args&&... args) noexcept
-         {
-            if (value) {
-               if constexpr (
-                  requires { requires supports_unchecked_write<typename T::value_type>; } ||
-                  requires { requires supports_unchecked_write<typename T::element_type>; }) {
-                  write<json>::op<Opts>(*value, ctx, std::forward<Args>(args)...);
-               }
-               else {
-                  write<json>::op<opt_false<Opts, &opts::write_unchecked>>(*value, ctx, std::forward<Args>(args)...);
-               }
+         serialize<JSON>::op<Opts>(std::span{value, N}, ctx, std::forward<Args>(args)...);
+      }
+   };
+
+   template <nullable_like T>
+   struct to<JSON, T>
+   {
+      template <auto Opts>
+      GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, auto&& b, auto&& ix)
+      {
+         if (value) {
+            if constexpr (required_padding<T>()) {
+               serialize<JSON>::op<Opts>(*value, ctx, b, ix);
             }
             else {
-               if constexpr (Opts.write_unchecked) {
-                  dump_unchecked<"null">(std::forward<Args>(args)...);
-               }
-               else {
-                  dump<"null">(std::forward<Args>(args)...);
-               }
+               serialize<JSON>::op<write_unchecked_off<Opts>()>(*value, ctx, b, ix);
             }
          }
-      };
+         else {
+            dump<"null", not check_write_unchecked(Opts)>(b, ix);
+         }
+      }
+   };
 
-      template <always_null_t T>
-      struct to_json<T>
+   template <class T>
+      requires(nullable_value_t<T> && not nullable_like<T> && not is_expected<T>)
+   struct to<JSON, T>
+   {
+      template <auto Opts>
+      GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, auto&& b, auto&& ix)
       {
-         template <auto Opts>
-         GLZ_ALWAYS_INLINE static void op(auto&&, is_context auto&&, auto&&... args) noexcept
-         {
-            if constexpr (Opts.write_unchecked) {
-               dump_unchecked<"null">(args...);
-            }
-            else {
-               dump<"null">(args...);
+         if (value.has_value()) {
+            serialize<JSON>::op<Opts>(value.value(), ctx, b, ix);
+         }
+         else {
+            dump<"null">(b, ix);
+         }
+      }
+   };
+
+   template <always_null_t T>
+   struct to<JSON, T>
+   {
+      template <auto Opts, class B>
+      GLZ_ALWAYS_INLINE static void op(auto&&, is_context auto&&, B&& b, auto&& ix)
+      {
+         if constexpr (not check_write_unchecked(Opts)) {
+            if (const auto k = ix + 4; k > b.size()) [[unlikely]] {
+               b.resize(2 * k);
             }
          }
-      };
+         static constexpr uint32_t null_v = 1819047278;
+         std::memcpy(&b[ix], &null_v, 4);
+         ix += 4;
+      }
+   };
 
-      template <is_variant T>
-      struct to_json<T>
+   template <is_variant T>
+   struct to<JSON, T>
+   {
+      template <auto Opts, class B>
+      static void op(auto&& value, is_context auto&& ctx, B&& b, auto&& ix)
       {
-         template <auto Opts, class... Args>
-         static void op(auto&& value, is_context auto&& ctx, Args&&... args) noexcept
-         {
-            std::visit(
-               [&](auto&& val) {
-                  using V = std::decay_t<decltype(val)>;
+         std::visit(
+            [&](auto&& val) {
+               using V = std::decay_t<decltype(val)>;
 
-                  if constexpr (Opts.write_type_info && !tag_v<T>.empty() && glaze_object_t<V>) {
-                     constexpr auto num_members = glz::tuple_size_v<meta_t<V>>;
+               if constexpr (check_write_type_info(Opts) && not tag_v<T>.empty() && glaze_object_t<V>) {
+                  constexpr auto N = reflect<V>::size;
 
-                     // must first write out type
-                     if constexpr (Opts.prettify) {
-                        dump<"{\n">(args...);
-                        ctx.indentation_level += Opts.indentation_width;
-                        dumpn<Opts.indentation_char>(ctx.indentation_level, args...);
-                        dump<'"'>(args...);
-                        dump_maybe_empty(tag_v<T>, args...);
-                        dump<"\": \"">(args...);
-                        dump_maybe_empty(ids_v<T>[value.index()], args...);
-                        if constexpr (num_members == 0) {
-                           dump<"\"\n">(args...);
+                  // must first write out type
+                  if constexpr (Opts.prettify) {
+                     dump<"{\n">(b, ix);
+                     ctx.indentation_level += Opts.indentation_width;
+                     dumpn<Opts.indentation_char>(ctx.indentation_level, b, ix);
+                     dump<'"'>(b, ix);
+                     dump_maybe_empty(tag_v<T>, b, ix);
+
+                     using id_type = std::decay_t<decltype(ids_v<T>[value.index()])>;
+
+                     if constexpr (std::integral<id_type>) {
+                        dump<"\": ">(b, ix);
+                        serialize<JSON>::op<Opts>(ids_v<T>[value.index()], ctx, b, ix);
+                        if constexpr (N == 0) {
+                           dump<"\n">(b, ix);
                         }
                         else {
-                           dump<"\",\n">(args...);
+                           dump<",\n">(b, ix);
                         }
-                        dumpn<Opts.indentation_char>(ctx.indentation_level, args...);
+                        dumpn<Opts.indentation_char>(ctx.indentation_level, b, ix);
                      }
                      else {
-                        dump<"{\"">(args...);
-                        dump_maybe_empty(tag_v<T>, args...);
-                        dump<"\":\"">(args...);
-                        dump_maybe_empty(ids_v<T>[value.index()], args...);
-                        if constexpr (num_members == 0) {
-                           dump<R"(")">(args...);
+                        dump<"\": \"">(b, ix);
+                        dump_maybe_empty(ids_v<T>[value.index()], b, ix);
+                        if constexpr (N == 0) {
+                           dump<"\"\n">(b, ix);
                         }
                         else {
-                           dump<R"(",)">(args...);
+                           dump<"\",\n">(b, ix);
                         }
+                        dumpn<Opts.indentation_char>(ctx.indentation_level, b, ix);
                      }
-                     write<json>::op<opening_handled<Opts>()>(val, ctx, args...);
                   }
                   else {
-                     write<json>::op<Opts>(val, ctx, args...);
+                     using id_type = std::decay_t<decltype(ids_v<T>[value.index()])>;
+
+                     dump<"{\"">(b, ix);
+                     dump_maybe_empty(tag_v<T>, b, ix);
+
+                     if constexpr (std::integral<id_type>) {
+                        dump<"\":">(b, ix);
+                        serialize<JSON>::op<Opts>(ids_v<T>[value.index()], ctx, b, ix);
+                        if constexpr (N > 0) {
+                           dump<R"(,)">(b, ix);
+                        }
+                     }
+                     else {
+                        dump<"\":\"">(b, ix);
+                        dump_maybe_empty(ids_v<T>[value.index()], b, ix);
+                        if constexpr (N == 0) {
+                           dump<R"(")">(b, ix);
+                        }
+                        else {
+                           dump<R"(",)">(b, ix);
+                        }
+                     }
+                  }
+                  to<JSON, V>::template op<opening_and_closing_handled<Opts>()>(val, ctx, b, ix);
+                  // If we skip everything then we may have an extra comma, which we want to revert
+                  if constexpr (Opts.skip_null_members) {
+                     if (b[ix - 1] == ',') {
+                        --ix;
+                     }
                   }
-               },
-               value);
+
+                  if constexpr (Opts.prettify) {
+                     ctx.indentation_level -= Opts.indentation_width;
+                     if constexpr (vector_like<B>) {
+                        if (const auto k = ix + ctx.indentation_level + write_padding_bytes; k > b.size())
+                           [[unlikely]] {
+                           b.resize(2 * k);
+                        }
+                     }
+                     std::memcpy(&b[ix], "\n", 1);
+                     ++ix;
+                     std::memset(&b[ix], Opts.indentation_char, ctx.indentation_level);
+                     ix += ctx.indentation_level;
+                     std::memcpy(&b[ix], "}", 1);
+                     ++ix;
+                  }
+                  else {
+                     dump<'}'>(b, ix);
+                  }
+               }
+               else {
+                  to<JSON, V>::template op<Opts>(val, ctx, b, ix);
+               }
+            },
+            value);
+      }
+   };
+
+   template <class T>
+   struct to<JSON, array_variant_wrapper<T>>
+   {
+      template <auto Opts, class... Args>
+      static void op(auto&& wrapper, is_context auto&& ctx, Args&&... args)
+      {
+         auto& value = wrapper.value;
+         dump<'['>(args...);
+         if constexpr (Opts.prettify) {
+            ctx.indentation_level += Opts.indentation_width;
+            dump_newline_indent<Opts.indentation_char>(ctx.indentation_level, args...);
+         }
+         dump<'"'>(args...);
+         dump_maybe_empty(ids_v<T>[value.index()], args...);
+         dump<"\",">(args...);
+         if constexpr (Opts.prettify) {
+            dump_newline_indent<Opts.indentation_char>(ctx.indentation_level, args...);
+         }
+         std::visit([&](auto&& v) { serialize<JSON>::op<Opts>(v, ctx, args...); }, value);
+         if constexpr (Opts.prettify) {
+            ctx.indentation_level -= Opts.indentation_width;
+            dump_newline_indent<Opts.indentation_char>(ctx.indentation_level, args...);
          }
-      };
+         dump<']'>(args...);
+      }
+   };
 
-      template <class T>
-      struct to_json<array_variant_wrapper<T>>
+   template <class T>
+      requires is_specialization_v<T, arr>
+   struct to<JSON, T>
+   {
+      template <auto Opts, class... Args>
+      static void op(auto&& value, is_context auto&& ctx, Args&&... args)
       {
-         template <auto Opts, class... Args>
-         static void op(auto&& wrapper, is_context auto&& ctx, Args&&... args) noexcept
-         {
-            auto& value = wrapper.value;
-            dump<'['>(args...);
-            if constexpr (Opts.prettify) {
+         using V = std::decay_t<decltype(value.value)>;
+         static constexpr auto N = glz::tuple_size_v<V>;
+
+         dump<'['>(args...);
+         if constexpr (N > 0 && Opts.prettify) {
+            if constexpr (Opts.new_lines_in_arrays) {
                ctx.indentation_level += Opts.indentation_width;
                dump_newline_indent<Opts.indentation_char>(ctx.indentation_level, args...);
             }
-            dump<'"'>(args...);
-            dump_maybe_empty(ids_v<T>[value.index()], args...);
-            dump<"\",">(args...);
-            if constexpr (Opts.prettify) {
-               dump_newline_indent<Opts.indentation_char>(ctx.indentation_level, args...);
+         }
+         for_each<N>([&]<size_t I>() {
+            if constexpr (glaze_array_t<V>) {
+               serialize<JSON>::op<Opts>(get_member(value.value, glz::get<I>(meta_v<T>)), ctx, args...);
             }
-            std::visit([&](auto&& v) { write<json>::op<Opts>(v, ctx, args...); }, value);
-            if constexpr (Opts.prettify) {
-               ctx.indentation_level -= Opts.indentation_width;
-               dump_newline_indent<Opts.indentation_char>(ctx.indentation_level, args...);
+            else {
+               serialize<JSON>::op<Opts>(glz::get<I>(value.value), ctx, args...);
             }
-            dump<']'>(args...);
-         }
-      };
-
-      template <class T>
-         requires is_specialization_v<T, arr>
-      struct to_json<T>
-      {
-         template <auto Opts, class... Args>
-         static void op(auto&& value, is_context auto&& ctx, Args&&... args) noexcept
-         {
-            using V = std::decay_t<decltype(value.value)>;
-            static constexpr auto N = glz::tuple_size_v<V>;
-
-            dump<'['>(args...);
-            if constexpr (N > 0 && Opts.prettify) {
-               ctx.indentation_level += Opts.indentation_width;
-               dump_newline_indent<Opts.indentation_char>(ctx.indentation_level, args...);
+            constexpr bool needs_comma = I < N - 1;
+            if constexpr (needs_comma) {
+               write_array_entry_separator<Opts>(ctx, args...);
             }
-            for_each<N>([&](auto I) {
-               if constexpr (glaze_array_t<V>) {
-                  write<json>::op<Opts>(get_member(value.value, glz::get<I>(meta_v<T>)), ctx, args...);
-               }
-               else {
-                  write<json>::op<Opts>(glz::get<I>(value.value), ctx, args...);
-               }
-               constexpr bool needs_comma = I < N - 1;
-               if constexpr (needs_comma) {
-                  write_entry_separator<Opts>(ctx, args...);
-               }
-            });
-            if constexpr (N > 0 && Opts.prettify) {
+         });
+         if constexpr (N > 0 && Opts.prettify) {
+            if constexpr (Opts.new_lines_in_arrays) {
                ctx.indentation_level -= Opts.indentation_width;
                dump_newline_indent<Opts.indentation_char>(ctx.indentation_level, args...);
             }
-            dump<']'>(args...);
          }
-      };
+         dump<']'>(args...);
+      }
+   };
 
-      template <class T>
-         requires glaze_array_t<T> || tuple_t<std::decay_t<T>> || is_std_tuple<T>
-      struct to_json<T>
+   template <class T>
+      requires glaze_array_t<T> || tuple_t<std::decay_t<T>> || is_std_tuple<T>
+   struct to<JSON, T>
+   {
+      template <auto Opts, class... Args>
+      static void op(auto&& value, is_context auto&& ctx, Args&&... args)
       {
-         template <auto Opts, class... Args>
-         static void op(auto&& value, is_context auto&& ctx, Args&&... args) noexcept
-         {
-            static constexpr auto N = []() constexpr {
-               if constexpr (glaze_array_t<std::decay_t<T>>) {
-                  return glz::tuple_size_v<meta_t<std::decay_t<T>>>;
-               }
-               else {
-                  return glz::tuple_size_v<std::decay_t<T>>;
-               }
-            }();
+         static constexpr auto N = []() constexpr {
+            if constexpr (glaze_array_t<std::decay_t<T>>) {
+               return glz::tuple_size_v<meta_t<std::decay_t<T>>>;
+            }
+            else {
+               return glz::tuple_size_v<std::decay_t<T>>;
+            }
+         }();
 
-            dump<'['>(args...);
-            if constexpr (N > 0 && Opts.prettify) {
+         dump<'['>(args...);
+         if constexpr (N > 0 && Opts.prettify) {
+            if constexpr (Opts.new_lines_in_arrays) {
                ctx.indentation_level += Opts.indentation_width;
                dump_newline_indent<Opts.indentation_char>(ctx.indentation_level, args...);
             }
-            using V = std::decay_t<T>;
-            for_each<N>([&](auto I) {
-               if constexpr (glaze_array_t<V>) {
-                  write<json>::op<Opts>(get_member(value, glz::get<I>(meta_v<T>)), ctx, args...);
-               }
-               else if constexpr (is_std_tuple<T>) {
-                  write<json>::op<Opts>(std::get<I>(value), ctx, args...);
-               }
-               else {
-                  write<json>::op<Opts>(glz::get<I>(value), ctx, args...);
-               }
-               constexpr bool needs_comma = I < N - 1;
-               if constexpr (needs_comma) {
-                  write_entry_separator<Opts>(ctx, args...);
-               }
-            });
-            if constexpr (N > 0 && Opts.prettify) {
+         }
+         using V = std::decay_t<T>;
+         for_each<N>([&]<size_t I>() {
+            if constexpr (glaze_array_t<V>) {
+               serialize<JSON>::op<Opts>(get_member(value, glz::get<I>(meta_v<T>)), ctx, args...);
+            }
+            else if constexpr (is_std_tuple<T>) {
+               using Value = core_t<decltype(std::get<I>(value))>;
+               to<JSON, Value>::template op<Opts>(std::get<I>(value), ctx, args...);
+            }
+            else {
+               using Value = core_t<decltype(glz::get<I>(value))>;
+               to<JSON, Value>::template op<Opts>(glz::get<I>(value), ctx, args...);
+            }
+            constexpr bool needs_comma = I < N - 1;
+            if constexpr (needs_comma) {
+               write_array_entry_separator<Opts>(ctx, args...);
+            }
+         });
+         if constexpr (N > 0 && Opts.prettify) {
+            if constexpr (Opts.new_lines_in_arrays) {
                ctx.indentation_level -= Opts.indentation_width;
                dump_newline_indent<Opts.indentation_char>(ctx.indentation_level, args...);
             }
-            dump<']'>(args...);
-         }
-      };
-
-      template <is_includer T>
-      struct to_json<T>
-      {
-         template <auto Opts, class... Args>
-         GLZ_ALWAYS_INLINE static void op(auto&&, is_context auto&&, Args&&... args) noexcept
-         {
-            dump<R"("")">(args...); // dump an empty string
          }
-      };
-
-      template <const std::string_view& S>
-      GLZ_ALWAYS_INLINE constexpr auto array_from_sv() noexcept
-      {
-         constexpr auto N = S.size();
-         std::array<char, N> arr;
-         std::copy_n(S.data(), N, arr.data());
-         return arr;
+         dump<']'>(args...);
       }
+   };
 
-      GLZ_ALWAYS_INLINE constexpr bool needs_escaping(const auto& S) noexcept
+   template <is_includer T>
+   struct to<JSON, T>
+   {
+      template <auto Opts, class... Args>
+      GLZ_ALWAYS_INLINE static void op(auto&&, is_context auto&&, Args&&... args)
       {
-         for (const auto& c : S) {
-            if (c == '"') {
-               return true;
-            }
-         }
-         return false;
+         dump<R"("")">(args...); // dump an empty string
       }
+   };
 
-      template <class T>
-         requires is_specialization_v<T, glz::obj> || is_specialization_v<T, glz::obj_copy>
-      struct to_json<T>
+   template <const std::string_view& S>
+   GLZ_ALWAYS_INLINE constexpr auto array_from_sv() noexcept
+   {
+      constexpr auto N = S.size();
+      std::array<char, N> arr;
+      std::copy_n(S.data(), N, arr.data());
+      return arr;
+   }
+
+   template <class T>
+      requires is_specialization_v<T, glz::obj> || is_specialization_v<T, glz::obj_copy>
+   struct to<JSON, T>
+   {
+      template <auto Options>
+      static void op(auto&& value, is_context auto&& ctx, auto&& b, auto&& ix)
       {
-         template <auto Options>
-         static void op(auto&& value, is_context auto&& ctx, auto&& b, auto&& ix) noexcept
-         {
-            if constexpr (!Options.opening_handled) {
-               dump<'{'>(b, ix);
-               if constexpr (Options.prettify) {
-                  ctx.indentation_level += Options.indentation_width;
-                  dump<'\n'>(b, ix);
-                  dumpn<Options.indentation_char>(ctx.indentation_level, b, ix);
-               }
+         if constexpr (!check_opening_handled(Options)) {
+            dump<'{'>(b, ix);
+            if constexpr (Options.prettify) {
+               ctx.indentation_level += Options.indentation_width;
+               dump<'\n'>(b, ix);
+               dumpn<Options.indentation_char>(ctx.indentation_level, b, ix);
             }
+         }
 
-            using V = std::decay_t<decltype(value.value)>;
-            static constexpr auto N = glz::tuple_size_v<V> / 2;
+         using V = std::decay_t<decltype(value.value)>;
+         static constexpr auto N = glz::tuple_size_v<V> / 2;
 
-            bool first = true;
-            for_each<N>([&](auto I) {
-               constexpr auto Opts = opening_and_closing_handled_off<ws_handled_off<Options>()>();
-               decltype(auto) item = glz::get<2 * I + 1>(value.value);
-               using val_t = std::decay_t<decltype(item)>;
+         bool first = true;
+         for_each<N>([&]<size_t I>() {
+            constexpr auto Opts = opening_and_closing_handled_off<ws_handled_off<Options>()>();
+            decltype(auto) item = glz::get<2 * I + 1>(value.value);
+            using val_t = std::decay_t<decltype(item)>;
 
-               if (skip_member<Opts>(item)) {
-                  return;
-               }
+            if (skip_member<Opts>(item)) {
+               return;
+            }
 
-               // skip
-               if constexpr (is_includer<val_t> || std::is_same_v<val_t, hidden> || std::same_as<val_t, skip>) {
-                  return;
+            // skip
+            if constexpr (always_skipped<val_t>) {
+               return;
+            }
+            else {
+               if (first) {
+                  first = false;
                }
                else {
-                  if (first) {
-                     first = false;
-                  }
-                  else {
-                     // Null members may be skipped so we cant just write it out for all but the last member unless
-                     // trailing commas are allowed
-                     write_entry_separator<Opts>(ctx, b, ix);
-                  }
+                  // Null members may be skipped so we can't just write it out for all but the last member unless
+                  // trailing commas are allowed
+                  write_object_entry_separator<Opts>(ctx, b, ix);
+               }
 
-                  using Key = typename std::decay_t<glz::tuple_element_t<2 * I, V>>;
+               using Key = typename std::decay_t<glz::tuple_element_t<2 * I, V>>;
 
-                  if constexpr (str_t<Key> || char_t<Key>) {
-                     const sv key = glz::get<2 * I>(value.value);
-                     write<json>::op<Opts>(key, ctx, b, ix);
-                     dump<':'>(b, ix);
-                     if constexpr (Opts.prettify) {
-                        dump<' '>(b, ix);
-                     }
-                  }
-                  else {
-                     dump<'"'>(b, ix);
-                     write<json>::op<Opts>(item, ctx, b, ix);
-                     dump_not_empty(Opts.prettify ? "\": " : "\":", b, ix);
+               if constexpr (str_t<Key> || char_t<Key>) {
+                  const sv key = glz::get<2 * I>(value.value);
+                  to<JSON, decltype(key)>::template op<Opts>(key, ctx, b, ix);
+                  dump<':'>(b, ix);
+                  if constexpr (Opts.prettify) {
+                     dump<' '>(b, ix);
                   }
-
-                  write<json>::op<Opts>(item, ctx, b, ix);
                }
-            });
-
-            if constexpr (!Options.closing_handled) {
-               if constexpr (Options.prettify) {
-                  ctx.indentation_level -= Options.indentation_width;
-                  dump<'\n'>(b, ix);
-                  dumpn<Options.indentation_char>(ctx.indentation_level, b, ix);
+               else {
+                  dump<'"'>(b, ix);
+                  to<JSON, val_t>::template op<Opts>(item, ctx, b, ix);
+                  dump_not_empty(Opts.prettify ? "\": " : "\":", b, ix);
                }
-               dump<'}'>(b, ix);
-            }
-         }
-      };
 
-      template <class T>
-         requires is_specialization_v<T, glz::merge>
-      struct to_json<T>
-      {
-         template <auto Options>
-         static void op(auto&& value, is_context auto&& ctx, auto&& b, auto&& ix) noexcept
-         {
-            if constexpr (!Options.opening_handled) {
-               dump<'{'>(b, ix);
-               if constexpr (Options.prettify) {
-                  ctx.indentation_level += Options.indentation_width;
-                  dump<'\n'>(b, ix);
-                  dumpn<Options.indentation_char>(ctx.indentation_level, b, ix);
-               }
+               to<JSON, val_t>::template op<Opts>(item, ctx, b, ix);
             }
+         });
 
-            using V = std::decay_t<decltype(value.value)>;
-            static constexpr auto N = glz::tuple_size_v<V>;
-
-            for_each<N>([&](auto I) {
-               write<json>::op<opening_and_closing_handled<Options>()>(glz::get<I>(value.value), ctx, b, ix);
-               if constexpr (I < N - 1) {
-                  dump<','>(b, ix);
-               }
-            });
-
+         if constexpr (!check_closing_handled(Options)) {
             if constexpr (Options.prettify) {
                ctx.indentation_level -= Options.indentation_width;
                dump<'\n'>(b, ix);
@@ -1105,450 +1659,376 @@ namespace glz
             }
             dump<'}'>(b, ix);
          }
-      };
+      }
+   };
+
+   template <class T>
+      requires is_specialization_v<T, glz::merge>
+   struct to<JSON, T>
+   {
+      template <auto Options>
+      static void op(auto&& value, is_context auto&& ctx, auto&& b, auto&& ix)
+      {
+         if constexpr (!check_opening_handled(Options)) {
+            dump<'{'>(b, ix);
+            if constexpr (Options.prettify) {
+               ctx.indentation_level += Options.indentation_width;
+               dump<'\n'>(b, ix);
+               dumpn<Options.indentation_char>(ctx.indentation_level, b, ix);
+            }
+         }
+
+         using V = std::decay_t<decltype(value.value)>;
+         static constexpr auto N = glz::tuple_size_v<V>;
+
+         [[maybe_unused]] static constexpr auto Opts = opening_and_closing_handled<Options>();
+
+         // When merging it is possible that objects are completed empty
+         // and therefore behave like skipped members even when skip_null_members is off
+
+         for_each<N>([&]<size_t I>() {
+            // We don't want to dump a comma when nothing is written
+            const auto ix_start = ix;
+            using Value = core_t<decltype(get<I>(value.value))>;
+            to<JSON, Value>::template op<Opts>(get<I>(value.value), ctx, b, ix);
+            if (ix > ix_start) // we wrote something
+            {
+               dump<','>(b, ix);
+            }
+         });
+
+         // we may have a trailing comma, which needs to be removed
+         if (b[ix - 1] == ',') {
+            --ix;
+         }
+
+         if constexpr (Options.prettify) {
+            ctx.indentation_level -= Options.indentation_width;
+            dump<'\n'>(b, ix);
+            dumpn<Options.indentation_char>(ctx.indentation_level, b, ix);
+         }
+         dump<'}'>(b, ix);
+      }
+   };
+
+   // Only use this if you are not prettifying
+   // Returns zero if the fixed size cannot be determined
+   template <class T>
+   inline constexpr size_t fixed_padding = [] {
+      constexpr auto N = reflect<T>::size;
+      size_t fixed = 2 + 16; // {} + extra padding
+      for_each_short_circuit<N>([&]<auto I>() -> bool {
+         using val_t = field_t<T, I>;
+         if constexpr (required_padding<val_t>()) {
+            fixed += required_padding<val_t>();
+            fixed += reflect<T>::keys[I].size() + 2; // quoted key length
+            fixed += 2; // colon and comma
+            return false; // continue
+         }
+         else {
+            fixed = 0;
+            return true; // break
+         }
+      });
+      if (fixed) {
+         fixed = round_up_to_nearest_16(fixed);
+      }
+      return fixed;
+   }();
 
-      template <class T>
-         requires glaze_object_t<T> || reflectable<T>
-      struct to_json<T>
+   template <class T>
+      requires((glaze_object_t<T> || reflectable<T>) && not custom_write<T>)
+   struct to<JSON, T>
+   {
+      template <auto Options, class V, class B>
+         requires(not std::is_pointer_v<std::remove_cvref_t<V>>)
+      static void op(V&& value, is_context auto&& ctx, B&& b, auto&& ix)
       {
-         template <auto Options, class V>
-         static void op(V&& value, is_context auto&& ctx, auto&& b, auto&& ix) noexcept
-         {
-            using ValueType = std::decay_t<V>;
-            if constexpr (detail::has_unknown_writer<ValueType> && Options.write_unknown) {
-               constexpr auto& writer = meta_unknown_write_v<ValueType>;
-
-               using WriterType = meta_unknown_write_t<ValueType>;
-               if constexpr (std::is_member_object_pointer_v<WriterType>) {
+         using ValueType = std::decay_t<V>;
+         if constexpr (has_unknown_writer<ValueType> && not check_disable_write_unknown(Options)) {
+            constexpr auto& writer = meta_unknown_write_v<ValueType>;
+
+            using WriterType = meta_unknown_write_t<ValueType>;
+            if constexpr (std::is_member_object_pointer_v<WriterType>) {
+               decltype(auto) unknown_writer = value.*writer;
+               if (unknown_writer.size() > 0) {
                   // TODO: This intermediate is added to get GCC 14 to build
-                  decltype(auto) merged = glz::merge{value, value.*writer};
-                  write<json>::op<write_unknown_off<Options>()>(std::move(merged), ctx, b, ix);
+                  decltype(auto) merged = glz::merge{value, unknown_writer};
+                  serialize<JSON>::op<disable_write_unknown_on<Options>()>(std::move(merged), ctx, b, ix);
+               }
+               else {
+                  serialize<JSON>::op<disable_write_unknown_on<Options>()>(value, ctx, b, ix);
                }
-               else if constexpr (std::is_member_function_pointer_v<WriterType>) {
+            }
+            else if constexpr (std::is_member_function_pointer_v<WriterType>) {
+               decltype(auto) unknown_writer = (value.*writer)();
+               if (unknown_writer.size() > 0) {
                   // TODO: This intermediate is added to get GCC 14 to build
-                  decltype(auto) merged = glz::merge{value, (value.*writer)()};
-                  write<json>::op<write_unknown_off<Options>()>(std::move(merged), ctx, b, ix);
+                  decltype(auto) merged = glz::merge{value, unknown_writer};
+                  serialize<JSON>::op<disable_write_unknown_on<Options>()>(std::move(merged), ctx, b, ix);
                }
                else {
-                  static_assert(false_v<T>, "unknown_write type not handled");
+                  serialize<JSON>::op<disable_write_unknown_on<Options>()>(value, ctx, b, ix);
                }
             }
             else {
-               op_base<write_unknown_on<Options>()>(std::forward<V>(value), ctx, b, ix);
+               static_assert(false_v<T>, "unknown_write type not handled");
             }
          }
+         else {
+            // handles glaze_object_t without extra unknown fields
+            static constexpr auto Opts =
+               disable_write_unknown_off<opening_and_closing_handled_off<ws_handled_off<Options>()>()>();
 
-         // handles glaze_object_t without extra unknown fields
-         template <auto Options, class B>
-         static void op_base(auto&& value, is_context auto&& ctx, B&& b, auto&& ix) noexcept
-         {
-            if constexpr (!Options.opening_handled) {
+            if constexpr (not check_opening_handled(Options)) {
                if constexpr (Options.prettify) {
                   ctx.indentation_level += Options.indentation_width;
                   if constexpr (vector_like<B>) {
                      if (const auto k = ix + ctx.indentation_level + write_padding_bytes; k > b.size()) [[unlikely]] {
-                        b.resize((std::max)(b.size() * 2, k));
+                        b.resize(2 * k);
                      }
                   }
-                  dump_unchecked<"{\n">(b, ix);
-                  dumpn_unchecked<Options.indentation_char>(ctx.indentation_level, b, ix);
+                  std::memcpy(&b[ix], "{\n", 2);
+                  ix += 2;
+                  std::memset(&b[ix], Opts.indentation_char, ctx.indentation_level);
+                  ix += ctx.indentation_level;
                }
                else {
                   dump<'{'>(b, ix);
                }
             }
 
-            using Info = object_type_info<Options, T>;
-
-            static constexpr auto N = Info::N;
-
-            [[maybe_unused]] decltype(auto) t = reflection_tuple<T>(value);
-            [[maybe_unused]] bool first = true;
-            static constexpr auto first_is_written = Info::first_will_be_written;
-            static constexpr auto maybe_skipped = Info::maybe_skipped;
-            for_each<N>([&](auto I) {
-               constexpr auto Opts = opening_and_closing_handled_off<ws_handled_off<Options>()>();
+            static constexpr auto N = reflect<T>::size;
 
-               using Element = glaze_tuple_element<I, N, T>;
-               static constexpr size_t member_index = Element::member_index;
-               static constexpr bool use_reflection = Element::use_reflection;
-               using val_t = std::remove_cvref_t<typename Element::type>;
-
-               decltype(auto) member = [&]() -> decltype(auto) {
-                  if constexpr (reflectable<T>) {
-                     return std::get<I>(t);
-                  }
-                  else {
-                     return get<member_index>(get<I>(meta_v<std::decay_t<T>>));
-                  }
-               }();
+            decltype(auto) t = [&]() -> decltype(auto) {
+               if constexpr (reflectable<T>) {
+                  return to_tie(value);
+               }
+               else {
+                  return nullptr;
+               }
+            }();
 
-               auto write_key = [&] {
-                  static constexpr sv key = key_name<I, T, use_reflection>;
-                  if constexpr (needs_escaping(key)) {
-                     // TODO: do compile time escaping
-                     write<json>::op<Opts>(key, ctx, b, ix);
-                     maybe_pad<write_padding_bytes>(b, ix);
-                     if constexpr (Opts.prettify) {
-                        dump_unchecked<": ">(b, ix);
-                     }
-                     else {
-                        dump_unchecked<':'>(b, ix);
-                     }
-                  }
-                  else {
-                     static constexpr auto quoted_key = join_v < chars<"\"">, key,
-                                           Opts.prettify ? chars<"\": "> : chars < "\":" >>
-                        ;
-                     if constexpr (quoted_key.size() < 128) {
-                        // Using the same padding constant alows the compiler
-                        // to not need to load different lengths into the register
-                        maybe_pad<write_padding_bytes>(b, ix);
-                     }
-                     else {
-                        maybe_pad<quoted_key.size() + write_padding_bytes>(b);
-                     }
-                     dump_unchecked<quoted_key>(b, ix);
-                  }
-               };
+            static constexpr auto padding = round_up_to_nearest_16(maximum_key_size<T> + write_padding_bytes);
+            if constexpr (maybe_skipped<Opts, T>) {
+               bool first = true;
+               for_each<N>([&]<size_t I>() {
+                  using val_t = field_t<T, I>;
 
-               if constexpr (maybe_skipped) {
-                  if constexpr (null_t<val_t>) {
-                     if constexpr (always_null_t<T>)
-                        return;
-                     else {
-                        auto is_null = [&]() {
-                           if constexpr (nullable_wrapper<val_t>) {
-                              return !bool(member(value).val);
-                           }
-                           else {
-                              return !bool(get_member(value, member));
-                           }
-                        }();
-                        if (is_null) return;
-                     }
+                  if constexpr (meta_has_skip<T>) {
+                     static constexpr meta_context mctx{.op = operation::serialize};
+                     if constexpr (meta<T>::skip(reflect<T>::keys[I], mctx)) return;
                   }
 
-                  if constexpr (is_includer<val_t> || std::same_as<val_t, hidden> || std::same_as<val_t, skip>) {
+                  if constexpr (always_skipped<val_t>) {
                      return;
                   }
                   else {
-                     if constexpr (first_is_written && I > 0) {
-                        write_entry_separator<Opts>(ctx, b, ix);
-                     }
-                     else {
-                        if (first) {
-                           first = false;
-                        }
+                     if constexpr (null_t<val_t> && Opts.skip_null_members) {
+                        if constexpr (always_null_t<val_t>)
+                           return;
                         else {
-                           // Null members may be skipped so we cant just write it out for all but the last member
-                           write_entry_separator<Opts>(ctx, b, ix);
+                           const auto is_null = [&]() {
+                              decltype(auto) element = [&]() -> decltype(auto) {
+                                 if constexpr (reflectable<T>) {
+                                    return get<I>(t);
+                                 }
+                                 else {
+                                    return get<I>(reflect<T>::values);
+                                 }
+                              };
+
+                              if constexpr (nullable_wrapper<val_t>) {
+                                 return !bool(element()(value).val);
+                              }
+                              else if constexpr (nullable_value_t<val_t>) {
+                                 return !get_member(value, element()).has_value();
+                              }
+                              else {
+                                 return !bool(get_member(value, element()));
+                              }
+                           }();
+                           if (is_null) return;
                         }
                      }
 
-                     write_key();
-                     if constexpr (supports_unchecked_write<val_t>) {
-                        write<json>::op<opt_true<Opts, &opts::write_unchecked>>(get_member(value, member), ctx, b, ix);
+                     if constexpr (Opts.prettify) {
+                        maybe_pad(padding + ctx.indentation_level, b, ix);
                      }
                      else {
-                        write<json>::op<Opts>(get_member(value, member), ctx, b, ix);
+                        maybe_pad<padding>(b, ix);
                      }
 
-                     // MSVC ICE bugs cause this code to be duplicated
-                     static constexpr size_t comment_index = member_index + 1;
-                     static constexpr auto S = glz::tuple_size_v<typename Element::Item>;
-                     if constexpr (Opts.comments && S > comment_index) {
-                        static constexpr auto i = glz::get<I>(meta_v<std::decay_t<T>>);
-                        if constexpr (std::is_convertible_v<decltype(get<comment_index>(i)), sv>) {
-                           static constexpr sv comment = get<comment_index>(i);
-                           if constexpr (comment.size() > 0) {
-                              if constexpr (Opts.prettify) {
-                                 dump<' '>(b, ix);
-                              }
-                              dump<"/*">(b, ix);
-                              dump_not_empty(comment, b, ix);
-                              dump<"*/">(b, ix);
-                           }
+                     if (first) {
+                        first = false;
+                     }
+                     else {
+                        // Null members may be skipped so we can't just write it out for all but the last member
+                        if constexpr (Opts.prettify) {
+                           std::memcpy(&b[ix], ",\n", 2);
+                           ix += 2;
+                           std::memset(&b[ix], Opts.indentation_char, ctx.indentation_level);
+                           ix += ctx.indentation_level;
+                        }
+                        else {
+                           std::memcpy(&b[ix], ",", 1);
+                           ++ix;
                         }
                      }
-                  }
-               }
-               else {
-                  // in this case we don't have values that maybe skipped
-                  if constexpr (I > 0) {
-                     write_entry_separator<Opts>(ctx, b, ix);
-                  }
 
-                  write_key();
-                  if constexpr (supports_unchecked_write<val_t>) {
-                     write<json>::op<opt_true<Opts, &opts::write_unchecked>>(get_member(value, member), ctx, b, ix);
-                  }
-                  else {
-                     write<json>::op<Opts>(get_member(value, member), ctx, b, ix);
-                  }
+                     // MSVC requires get<I> rather than keys[I]
+                     static constexpr auto key = glz::get<I>(reflect<T>::keys); // GCC 14 requires auto here
+                     static constexpr auto quoted_key = quoted_key_v<key, Opts.prettify>;
+                     static constexpr auto n = quoted_key.size();
+                     std::memcpy(&b[ix], quoted_key.data(), n);
+                     ix += n;
 
-                  // MSVC ICE bugs cause this code to be duplicated
-                  static constexpr size_t comment_index = member_index + 1;
-                  static constexpr auto S = glz::tuple_size_v<typename Element::Item>;
-                  if constexpr (Opts.comments && S > comment_index) {
-                     static constexpr auto i = glz::get<I>(meta_v<std::decay_t<T>>);
-                     if constexpr (std::is_convertible_v<decltype(get<comment_index>(i)), sv>) {
-                        static constexpr sv comment = get<comment_index>(i);
-                        if constexpr (comment.size() > 0) {
-                           if constexpr (Opts.prettify) {
-                              dump<' '>(b, ix);
-                           }
-                           dump<"/*">(b, ix);
-                           dump_not_empty(comment, b, ix);
-                           dump<"*/">(b, ix);
-                        }
+                     static constexpr auto check_opts = required_padding<val_t>() ? write_unchecked_on<Opts>() : Opts;
+                     if constexpr (reflectable<T>) {
+                        to<JSON, val_t>::template op<check_opts>(get_member(value, get<I>(t)), ctx, b, ix);
                      }
-                  }
-               }
-            });
-            if constexpr (!Options.closing_handled) {
-               if constexpr (Options.prettify) {
-                  ctx.indentation_level -= Options.indentation_width;
-                  if constexpr (vector_like<B>) {
-                     if (const auto k = ix + ctx.indentation_level + write_padding_bytes; k > b.size()) [[unlikely]] {
-                        b.resize((std::max)(b.size() * 2, k));
+                     else {
+                        to<JSON, val_t>::template op<check_opts>(get_member(value, get<I>(reflect<T>::values)), ctx, b,
+                                                                 ix);
                      }
                   }
-                  dump_unchecked<'\n'>(b, ix);
-                  dumpn_unchecked<Options.indentation_char>(ctx.indentation_level, b, ix);
-                  dump_unchecked<'}'>(b, ix);
-               }
-               else {
-                  dump<'}'>(b, ix);
-               }
-            }
-         }
-      };
-
-      template <class T = void>
-      struct to_json_partial
-      {};
-
-      template <auto& Partial, auto Opts, class T, class Ctx, class B, class IX>
-      concept write_json_partial_invocable = requires(T&& value, Ctx&& ctx, B&& b, IX&& ix) {
-         to_json_partial<std::remove_cvref_t<T>>::template op<Partial, Opts>(
-            std::forward<T>(value), std::forward<Ctx>(ctx), std::forward<B>(b), std::forward<IX>(ix));
-      };
-
-      template <>
-      struct write_partial<json>
-      {
-         template <auto& Partial, auto Opts, class T, is_context Ctx, class B, class IX>
-         static void op(T&& value, Ctx&& ctx, B&& b, IX&& ix) noexcept
-         {
-            if constexpr (std::count(Partial.begin(), Partial.end(), "") > 0) {
-               detail::write<json>::op<Opts>(value, ctx, b, ix);
-            }
-            else if constexpr (write_json_partial_invocable<Partial, Opts, T, Ctx, B, IX>) {
-               to_json_partial<std::remove_cvref_t<T>>::template op<Partial, Opts>(
-                  std::forward<T>(value), std::forward<Ctx>(ctx), std::forward<B>(b), std::forward<IX>(ix));
+               });
             }
             else {
-               static_assert(false_v<T>, "Glaze metadata is probably needed for your type");
-            }
-         }
-      };
-
-      // Only object types are supported for partial
-      template <class T>
-         requires(glaze_object_t<T> || writable_map_t<T> || reflectable<T>)
-      struct to_json_partial<T> final
-      {
-         template <auto& Partial, auto Opts, class... Args>
-         static void op(auto&& value, is_context auto&& ctx, auto&& b, auto&& ix) noexcept
-         {
-            if constexpr (!Opts.opening_handled) {
-               dump<'{'>(b, ix);
-               if constexpr (Opts.prettify) {
-                  ctx.indentation_level += Opts.indentation_width;
-                  dump<'\n'>(b, ix);
-                  dumpn<Opts.indentation_char>(ctx.indentation_level, b, ix);
-               }
-            }
-
-            static constexpr auto sorted = sort_json_ptrs(Partial);
-            static constexpr auto groups = glz::group_json_ptrs<sorted>();
-            static constexpr auto N = glz::tuple_size_v<std::decay_t<decltype(groups)>>;
-
-            static constexpr auto num_members = reflection_count<T>;
-
-            if constexpr ((num_members > 0) && (glaze_object_t<T> || reflectable<T>)) {
-               if constexpr (glaze_object_t<T>) {
-                  for_each<N>([&](auto I) {
-                     if (bool(ctx.error)) [[unlikely]] {
-                        return;
-                     }
-
-                     static constexpr auto group = glz::get<I>(groups);
-
-                     static constexpr auto key = get<0>(group);
-                     static constexpr auto quoted_key = join_v < chars<"\"">, key,
-                                           Opts.prettify ? chars<"\": "> : chars < "\":" >>
-                        ;
-                     dump<quoted_key>(b, ix);
-
-                     static constexpr auto sub_partial = get<1>(group);
-                     static constexpr auto frozen_map = make_map<T>();
-                     static constexpr auto member_it = frozen_map.find(key);
-                     static_assert(member_it != frozen_map.end(), "Invalid key passed to partial write");
-                     static constexpr auto index = member_it->second.index();
-                     static constexpr decltype(auto) member_ptr = get<index>(member_it->second);
-
-                     write_partial<json>::op<sub_partial, Opts>(get_member(value, member_ptr), ctx, b, ix);
-                     if constexpr (I != N - 1) {
-                        write_entry_separator<Opts>(ctx, b, ix);
-                     }
-                  });
+               static constexpr size_t fixed_max_size = fixed_padding<T>;
+               if constexpr (fixed_max_size) {
+                  maybe_pad<fixed_max_size>(b, ix);
                }
-               else {
-#if ((defined _MSC_VER) && (!defined __clang__))
-                  static thread_local auto cmap = make_map<T, Opts.use_hash_comparison>();
-#else
-                  static thread_local constinit auto cmap = make_map<T, Opts.use_hash_comparison>();
-#endif
-                  populate_map(value, cmap); // Function required for MSVC to build
 
-                  static constexpr auto members = member_names<T>;
-
-                  for_each<N>([&](auto I) {
-                     if (bool(ctx.error)) [[unlikely]] {
-                        return;
+               for_each<N>([&]<size_t I>() {
+                  if constexpr (not fixed_max_size) {
+                     if constexpr (Opts.prettify) {
+                        maybe_pad(padding + ctx.indentation_level, b, ix);
                      }
-
-                     static constexpr auto group = glz::get<I>(groups);
-
-                     static constexpr auto key = get<0>(group);
-                     constexpr auto mem_it = std::find(members.begin(), members.end(), key);
-                     static_assert(mem_it != members.end(), "Invalid key passed to partial write");
-
-                     static constexpr auto quoted_key = join_v < chars<"\"">, key,
-                                           Opts.prettify ? chars<"\": "> : chars < "\":" >>
-                        ;
-                     dump<quoted_key>(b, ix);
-
-                     static constexpr auto sub_partial = get<1>(group);
-                     auto member_it = cmap.find(key); // we verified at compile time that this exists
-                     std::visit(
-                        [&](auto&& member_ptr) {
-                           if constexpr (std::count(sub_partial.begin(), sub_partial.end(), "") > 0) {
-                              detail::write<json>::op<Opts>(get_member(value, member_ptr), ctx, b, ix);
-                           }
-                           else {
-                              decltype(auto) member = get_member(value, member_ptr);
-                              using M = std::decay_t<decltype(member)>;
-                              if constexpr (glaze_object_t<M> || writable_map_t<M> || reflectable<M>) {
-                                 write_partial<json>::op<sub_partial, Opts>(member, ctx, b, ix);
-                              }
-                              else {
-                                 detail::write<json>::op<Opts>(member, ctx, b, ix);
-                              }
-                           }
-                        },
-                        member_it->second);
-                     if constexpr (I != N - 1) {
-                        write_entry_separator<Opts>(ctx, b, ix);
+                     else {
+                        maybe_pad<padding>(b, ix);
                      }
-                  });
-               }
-            }
-            else if constexpr (writable_map_t<T>) {
-               for_each<N>([&](auto I) {
-                  if (bool(ctx.error)) [[unlikely]] {
-                     return;
                   }
 
-                  static constexpr auto group = glz::get<I>(groups);
+                  if constexpr (I != 0 && Opts.prettify) {
+                     std::memcpy(&b[ix], ",\n", 2);
+                     ix += 2;
+                     std::memset(&b[ix], Opts.indentation_char, ctx.indentation_level);
+                     ix += ctx.indentation_level;
+                  }
 
-                  static constexpr auto key = std::get<0>(group);
-                  static constexpr auto quoted_key = join_v < chars<"\"">, key,
-                                        Opts.prettify ? chars<"\": "> : chars < "\":" >>
-                     ;
-                  dump<key>(b, ix);
+                  using val_t = field_t<T, I>;
 
-                  static constexpr auto sub_partial = std::get<1>(group);
-                  if constexpr (findable<std::decay_t<T>, decltype(key)>) {
-                     auto it = value.find(key);
-                     if (it != value.end()) {
-                        write_partial<json>::op<sub_partial, Opts>(it->second, ctx, b, ix);
+                  // MSVC requires get<I> rather than keys[I]
+                  static constexpr auto key = glz::get<I>(reflect<T>::keys); // GCC 14 requires auto here
+                  if constexpr (always_null_t<val_t>) {
+                     if constexpr (I == 0 || Opts.prettify) {
+                        static constexpr auto quoted_key = join_v<quoted_key_v<key, Opts.prettify>, chars<"null">>;
+                        static constexpr auto n = quoted_key.size();
+                        std::memcpy(&b[ix], quoted_key.data(), n);
+                        ix += n;
                      }
                      else {
-                        ctx.error = error_code::invalid_partial_key;
-                        return;
+                        static constexpr auto quoted_key = join_v<chars<",">, quoted_key_v<key>, chars<"null">>;
+                        static constexpr auto n = quoted_key.size();
+                        std::memcpy(&b[ix], quoted_key.data(), n);
+                        ix += n;
                      }
                   }
                   else {
-                     static thread_local auto k = typename std::decay_t<T>::key_type(key);
-                     auto it = value.find(k);
-                     if (it != value.end()) {
-                        write_partial<json>::op<sub_partial, Opts>(it->second, ctx, b, ix);
+                     if constexpr (I == 0 || Opts.prettify) {
+                        static constexpr auto quoted_key = quoted_key_v<key, Opts.prettify>;
+                        static constexpr auto n = quoted_key.size();
+                        std::memcpy(&b[ix], quoted_key.data(), n);
+                        ix += n;
                      }
                      else {
-                        ctx.error = error_code::invalid_partial_key;
-                        return;
+                        static constexpr auto quoted_key = join_v<chars<",">, quoted_key_v<key>>;
+                        static constexpr auto n = quoted_key.size();
+                        std::memcpy(&b[ix], quoted_key.data(), n);
+                        ix += n;
+                     }
+
+                     static constexpr auto check_opts = required_padding<val_t>() ? write_unchecked_on<Opts>() : Opts;
+                     if constexpr (reflectable<T>) {
+                        to<JSON, val_t>::template op<check_opts>(get_member(value, get<I>(t)), ctx, b, ix);
+                     }
+                     else {
+                        to<JSON, val_t>::template op<check_opts>(get_member(value, get<I>(reflect<T>::values)), ctx, b,
+                                                                 ix);
                      }
-                  }
-                  if constexpr (I != N - 1) {
-                     write_entry_separator<Opts>(ctx, b, ix);
                   }
                });
             }
 
-            if (not bool(ctx.error)) [[likely]] {
-               dump<'}'>(b, ix);
+            // Options is required here, because it must be the top level
+            if constexpr (not check_closing_handled(Options)) {
+               if constexpr (Options.prettify) {
+                  ctx.indentation_level -= Options.indentation_width;
+                  if constexpr (vector_like<B>) {
+                     if (const auto k = ix + ctx.indentation_level + write_padding_bytes; k > b.size()) [[unlikely]] {
+                        b.resize(2 * k);
+                     }
+                  }
+                  std::memcpy(&b[ix], "\n", 1);
+                  ++ix;
+                  std::memset(&b[ix], Opts.indentation_char, ctx.indentation_level);
+                  ix += ctx.indentation_level;
+                  std::memcpy(&b[ix], "}", 1);
+                  ++ix;
+               }
+               else {
+                  dump<'}'>(b, ix);
+               }
             }
          }
-      };
-   } // namespace detail
+      }
+   };
 
-   template <write_json_supported T, output_buffer Buffer>
-   [[nodiscard]] error_ctx write_json(T&& value, Buffer&& buffer) noexcept
+   template <write_supported<JSON> T, output_buffer Buffer>
+   [[nodiscard]] error_ctx write_json(T&& value, Buffer&& buffer)
    {
       return write<opts{}>(std::forward<T>(value), std::forward<Buffer>(buffer));
    }
 
-   template <write_json_supported T, raw_buffer Buffer>
-   [[nodiscard]] glz::expected<size_t, error_ctx> write_json(T&& value, Buffer&& buffer) noexcept
+   template <write_supported<JSON> T, raw_buffer Buffer>
+   [[nodiscard]] glz::expected<size_t, error_ctx> write_json(T&& value, Buffer&& buffer)
    {
       return write<opts{}>(std::forward<T>(value), std::forward<Buffer>(buffer));
    }
 
-   template <write_json_supported T>
-   [[nodiscard]] glz::expected<std::string, error_ctx> write_json(T&& value) noexcept
+   template <write_supported<JSON> T>
+   [[nodiscard]] glz::expected<std::string, error_ctx> write_json(T&& value)
    {
       return write<opts{}>(std::forward<T>(value));
    }
 
-   template <auto& Partial, write_json_supported T, output_buffer Buffer>
-   [[nodiscard]] error_ctx write_json(T&& value, Buffer&& buffer) noexcept
+   template <auto& Partial, write_supported<JSON> T, output_buffer Buffer>
+   [[nodiscard]] error_ctx write_json(T&& value, Buffer&& buffer)
    {
       return write<Partial, opts{}>(std::forward<T>(value), std::forward<Buffer>(buffer));
    }
 
-   template <auto& Partial, write_json_supported T, raw_buffer Buffer>
-   [[nodiscard]] glz::expected<size_t, error_ctx> write_json(T&& value, Buffer&& buffer) noexcept
+   template <auto& Partial, write_supported<JSON> T, raw_buffer Buffer>
+   [[nodiscard]] glz::expected<size_t, error_ctx> write_json(T&& value, Buffer&& buffer)
    {
       return write<Partial, opts{}>(std::forward<T>(value), std::forward<Buffer>(buffer));
    }
 
-   template <write_json_supported T, class Buffer>
-   [[nodiscard]] error_ctx write_jsonc(T&& value, Buffer&& buffer) noexcept
+   template <write_supported<JSON> T, class Buffer>
+   [[nodiscard]] error_ctx write_jsonc(T&& value, Buffer&& buffer)
    {
       return write<opts{.comments = true}>(std::forward<T>(value), std::forward<Buffer>(buffer));
    }
 
-   template <write_json_supported T>
-   [[nodiscard]] glz::expected<std::string, error_ctx> write_jsonc(T&& value) noexcept
+   template <write_supported<JSON> T>
+   [[nodiscard]] glz::expected<std::string, error_ctx> write_jsonc(T&& value)
    {
       return write<opts{.comments = true}>(std::forward<T>(value));
    }
 
-   template <opts Opts = opts{}, write_json_supported T>
-   [[nodiscard]] error_ctx write_file_json(T&& value, const sv file_name, auto&& buffer) noexcept
+   template <auto Opts = opts{}, write_supported<JSON> T>
+   [[nodiscard]] error_ctx write_file_json(T&& value, const sv file_name, auto&& buffer)
    {
       const auto ec = write<set_json<Opts>()>(std::forward<T>(value), buffer);
       if (bool(ec)) [[unlikely]] {
@@ -1557,3 +2037,7 @@ namespace glz
       return {buffer_to_file(buffer, file_name)};
    }
 }
+
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif
\ No newline at end of file
diff --git a/deps/saucer/include/glaze/net/cors.hpp b/deps/saucer/include/glaze/net/cors.hpp
new file mode 100644
index 0000000..9dcfe49
--- /dev/null
+++ b/deps/saucer/include/glaze/net/cors.hpp
@@ -0,0 +1,189 @@
+// CORS Support for Glaze Library
+// Add this to a new file: glaze/net/cors.hpp
+
+#pragma once
+
+#include <algorithm>
+#include <string>
+#include <unordered_set>
+#include <vector>
+
+#include "glaze/net/http_router.hpp"
+
+namespace glz
+{
+   /**
+    * @brief Configuration for CORS (Cross-Origin Resource Sharing) support
+    */
+   struct cors_config
+   {
+      /**
+       * @brief List of allowed origins
+       *
+       * Use "*" to allow all origins, or specify specific origins like "https://example.com"
+       * For credentials to work, you cannot use "*" - must specify exact origins
+       */
+      std::vector<std::string> allowed_origins = {"*"};
+
+      /**
+       * @brief List of allowed HTTP methods
+       */
+      std::vector<std::string> allowed_methods = {"GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"};
+
+      /**
+       * @brief List of allowed request headers
+       */
+      std::vector<std::string> allowed_headers = {"Content-Type", "Authorization", "X-Requested-With"};
+
+      /**
+       * @brief List of headers to expose to the client
+       */
+      std::vector<std::string> exposed_headers = {};
+
+      /**
+       * @brief Whether to allow credentials (cookies, authorization headers)
+       *
+       * When true, allowed_origins cannot contain "*"
+       */
+      bool allow_credentials = false;
+
+      /**
+       * @brief Maximum age for preflight cache (in seconds)
+       *
+       * Default is 24 hours (86400 seconds)
+       */
+      int max_age = 86400;
+
+      /**
+       * @brief Whether to automatically handle preflight OPTIONS requests
+       *
+       * When true, the middleware will respond to OPTIONS requests with appropriate headers
+       */
+      bool handle_preflight = true;
+   };
+
+   /**
+    * @brief Check if an origin is allowed based on the CORS configuration
+    *
+    * @param config The CORS configuration
+    * @param origin The origin to check
+    * @return true if the origin is allowed, false otherwise
+    */
+   inline bool is_origin_allowed(const cors_config& config, const std::string& origin)
+   {
+      // If no specific origins are configured or "*" is present, allow all
+      if (config.allowed_origins.empty() || std::find(config.allowed_origins.begin(), config.allowed_origins.end(),
+                                                      "*") != config.allowed_origins.end()) {
+         return true;
+      }
+
+      // Check if the origin is in the allowed list
+      return std::find(config.allowed_origins.begin(), config.allowed_origins.end(), origin) !=
+             config.allowed_origins.end();
+   }
+
+   /**
+    * @brief Join a vector of strings with a delimiter
+    *
+    * @param vec The vector of strings to join
+    * @param delimiter The delimiter to use
+    * @return The joined string
+    */
+   inline std::string join_strings(const std::vector<std::string>& vec, const std::string& delimiter)
+   {
+      if (vec.empty()) return "";
+
+      std::string result = vec[0];
+      for (size_t i = 1; i < vec.size(); ++i) {
+         result += delimiter + vec[i];
+      }
+      return result;
+   }
+
+   /**
+    * @brief Create a CORS middleware handler
+    *
+    * @param config The CORS configuration to use
+    * @return A middleware handler function
+    */
+   inline handler create_cors_middleware(const cors_config& config = {})
+   {
+      return [config](const request& req, response& res) {
+         // Get the origin from the request headers
+         std::string origin;
+         auto origin_it = req.headers.find("Origin");
+         if (origin_it != req.headers.end()) {
+            origin = origin_it->second;
+         }
+
+         // Check if this is a preflight request (OPTIONS method with specific headers)
+         bool is_preflight = (req.method == http_method::OPTIONS) &&
+                             (req.headers.find("Access-Control-Request-Method") != req.headers.end());
+
+         // Always add CORS headers if origin is allowed
+         if (!origin.empty() && is_origin_allowed(config, origin)) {
+            // Determine which origin to send back
+            std::string allowed_origin = "*";
+            if (config.allow_credentials || std::find(config.allowed_origins.begin(), config.allowed_origins.end(),
+                                                      "*") == config.allowed_origins.end()) {
+               allowed_origin = origin;
+            }
+
+            res.header("Access-Control-Allow-Origin", allowed_origin);
+
+            // Add credentials header if enabled
+            if (config.allow_credentials) {
+               res.header("Access-Control-Allow-Credentials", "true");
+            }
+
+            // Add exposed headers if any
+            if (!config.exposed_headers.empty()) {
+               res.header("Access-Control-Expose-Headers", join_strings(config.exposed_headers, ", "));
+            }
+
+            // Handle preflight requests
+            if (is_preflight && config.handle_preflight) {
+               // Add allowed methods
+               res.header("Access-Control-Allow-Methods", join_strings(config.allowed_methods, ", "));
+
+               // Add allowed headers
+               res.header("Access-Control-Allow-Headers", join_strings(config.allowed_headers, ", "));
+
+               // Add max age
+               res.header("Access-Control-Max-Age", std::to_string(config.max_age));
+
+               // Set status to 204 (No Content) for preflight response
+               res.status(204);
+            }
+         }
+         else if (is_preflight && config.handle_preflight) {
+            // Origin not allowed, but it's a preflight request - respond with 403
+            res.status(403).body("CORS: Origin not allowed");
+         }
+      };
+   }
+
+   /**
+    * @brief Simple CORS middleware with default configuration
+    *
+    * Allows all origins, methods, and headers - suitable for development
+    */
+   inline handler simple_cors() { return create_cors_middleware(); }
+
+   /**
+    * @brief Restrictive CORS middleware
+    *
+    * Only allows specific origins - suitable for production
+    *
+    * @param origins Vector of allowed origins
+    * @param allow_credentials Whether to allow credentials
+    * @return CORS middleware handler
+    */
+   inline handler restrictive_cors(const std::vector<std::string>& origins, bool allow_credentials = false)
+   {
+      cors_config config;
+      config.allowed_origins = origins;
+      config.allow_credentials = allow_credentials;
+      return create_cors_middleware(config);
+   }
+}
diff --git a/deps/saucer/include/glaze/net/http.hpp b/deps/saucer/include/glaze/net/http.hpp
new file mode 100644
index 0000000..8835b36
--- /dev/null
+++ b/deps/saucer/include/glaze/net/http.hpp
@@ -0,0 +1,150 @@
+// Glaze Library
+// For the license information refer to glaze.hpp
+
+#pragma once
+
+#include <algorithm>
+#include <charconv>
+#include <expected>
+#include <optional>
+#include <string>
+#include <string_view>
+#include <system_error>
+
+// To deconflict Windows.h
+#ifdef DELETE
+#undef DELETE
+#endif
+
+namespace glz
+{
+   enum struct http_method { GET, POST, PUT, DELETE, PATCH, HEAD, OPTIONS };
+
+   // Utility functions for HTTP methods
+   inline std::string_view to_string(http_method method)
+   {
+      using enum http_method;
+      switch (method) {
+      case GET:
+         return "GET";
+      case POST:
+         return "POST";
+      case PUT:
+         return "PUT";
+      case DELETE:
+         return "DELETE";
+      case PATCH:
+         return "PATCH";
+      case HEAD:
+         return "HEAD";
+      case OPTIONS:
+         return "OPTIONS";
+      default:
+         return "UNKNOWN";
+      }
+   }
+
+   inline std::optional<http_method> from_string(std::string_view method)
+   {
+      using enum http_method;
+      if (method == "GET") return GET;
+      if (method == "POST") return POST;
+      if (method == "PUT") return PUT;
+      if (method == "DELETE") return DELETE;
+      if (method == "PATCH") return PATCH;
+      if (method == "HEAD") return HEAD;
+      if (method == "OPTIONS") return OPTIONS;
+      return std::nullopt;
+   }
+
+   struct HttpStatusLine
+   {
+      std::string_view version{};
+      int status_code{};
+      std::string_view status_message{};
+   };
+
+   inline std::expected<HttpStatusLine, std::error_code> parse_http_status_line(std::string_view status_line)
+   {
+      if (status_line.empty()) {
+         return std::unexpected(std::make_error_code(std::errc::protocol_error));
+      }
+
+      constexpr std::string_view http_prefix = "HTTP/";
+      // Check if status line starts with HTTP/
+      if (status_line.size() <= http_prefix.size() || !status_line.starts_with(http_prefix)) {
+         return std::unexpected(std::make_error_code(std::errc::protocol_error));
+      }
+
+      // Find the positions of the spaces that separate the components
+      const size_t first_space = status_line.find(' ', http_prefix.length());
+      if (first_space == std::string_view::npos || first_space >= status_line.size() - 1) {
+         return std::unexpected(std::make_error_code(std::errc::protocol_error));
+      }
+
+      const size_t second_space = status_line.find(' ', first_space + 1);
+      const bool has_status_message = second_space != std::string_view::npos;
+
+      // Extract the components as views instead of creating new strings
+      std::string_view version = status_line.substr(http_prefix.length(), first_space - http_prefix.length());
+
+      std::string_view status_code_str = status_line.substr(
+         first_space + 1, has_status_message ? second_space - first_space - 1 : std::string_view::npos);
+
+      std::string_view status_message;
+      if (has_status_message && second_space < status_line.length() - 1) {
+         status_message = status_line.substr(second_space + 1);
+
+         // Trim leading and trailing whitespace (adapted for string_view)
+         const auto start = std::find_if(status_message.begin(), status_message.end(),
+                                         [](unsigned char ch) { return !std::isspace(ch); });
+
+         if (start == status_message.end()) {
+            // String is all whitespace
+            status_message = std::string_view();
+         }
+         else {
+            const auto end = std::find_if(status_message.rbegin(), status_message.rend(), [](unsigned char ch) {
+                                return !std::isspace(ch);
+                             }).base();
+            status_message = status_message.substr(start - status_message.begin(), end - start);
+         }
+      }
+
+      // Validate HTTP version (must be digits.digits)
+      const size_t dot_pos = version.find('.');
+      if (dot_pos == std::string_view::npos || dot_pos == 0 || dot_pos == version.length() - 1) {
+         return std::unexpected(std::make_error_code(std::errc::protocol_error));
+      }
+
+      // Check that characters before and after dot are digits
+      const bool valid_version =
+         std::all_of(version.begin(), version.begin() + dot_pos, [](unsigned char ch) { return std::isdigit(ch); }) &&
+         std::all_of(version.begin() + dot_pos + 1, version.end(), [](unsigned char ch) { return std::isdigit(ch); });
+
+      if (!valid_version) {
+         return std::unexpected(std::make_error_code(std::errc::protocol_error));
+      }
+
+      // Validate status code (must be all digits and not too long)
+      constexpr size_t max_status_code_length = 3; // HTTP status codes are 3 digits
+      if (status_code_str.empty() || status_code_str.length() > max_status_code_length ||
+          !std::all_of(status_code_str.begin(), status_code_str.end(),
+                       [](unsigned char ch) { return std::isdigit(ch); })) {
+         return std::unexpected(std::make_error_code(std::errc::protocol_error));
+      }
+
+      // Parse status code using from_chars for better error handling and performance
+      int status_code;
+      const auto [ptr, ec] =
+         std::from_chars(status_code_str.data(), status_code_str.data() + status_code_str.size(), status_code);
+
+      if (ec != std::errc() || status_code < 100 || status_code > 599) {
+         return std::unexpected(std::make_error_code(std::errc::protocol_error));
+      }
+
+      // Create and return the parsed status line structure
+      // No copying of strings is performed here as we're using views into the original string
+      return HttpStatusLine{.version = version, .status_code = status_code, .status_message = status_message};
+   }
+}
diff --git a/deps/saucer/include/glaze/net/http_client.hpp b/deps/saucer/include/glaze/net/http_client.hpp
new file mode 100644
index 0000000..42122d2
--- /dev/null
+++ b/deps/saucer/include/glaze/net/http_client.hpp
@@ -0,0 +1,1227 @@
+// Glaze Library
+// For the license information refer to glaze.hpp
+
+#pragma once
+
+#include <asio.hpp>
+#include <atomic>
+#include <chrono>
+#include <expected>
+#include <functional>
+#include <future>
+#include <glaze/glaze.hpp>
+#include <iostream>
+#include <memory>
+#include <mutex>
+#include <source_location>
+#include <thread>
+#include <unordered_map>
+#include <vector>
+
+#include "glaze/net/http_router.hpp"
+
+namespace glz
+{
+   inline int strncasecmp(const char* s1, const char* s2, size_t n)
+   {
+      for (size_t i = 0; i < n; ++i) {
+         unsigned char c1 = static_cast<unsigned char>(s1[i]);
+         unsigned char c2 = static_cast<unsigned char>(s2[i]);
+         if (c1 == '\0' || c2 == '\0') {
+            return c1 - c2;
+         }
+         int diff = std::tolower(c1) - std::tolower(c2);
+         if (diff != 0) {
+            return diff;
+         }
+      }
+      return 0;
+   }
+
+   // Streaming strategy options
+   enum class stream_read_strategy {
+      bulk_transfer, // Deliver larger chunks, better throughput (default)
+      immediate_delivery // Deliver smaller chunks immediately, lower latency
+   };
+
+   struct url_parts
+   {
+      std::string protocol;
+      std::string host;
+      uint16_t port;
+      std::string path;
+   };
+
+   inline std::expected<url_parts, std::error_code> parse_url(std::string_view url)
+   {
+      // Check minimum length
+      if (url.size() < 8) { // Minimum for "http://" + 1 char host
+         return std::unexpected(std::make_error_code(std::errc::invalid_argument));
+      }
+
+      // Find protocol
+      size_t protocol_end = url.find("://");
+      if (protocol_end == std::string_view::npos) {
+         return std::unexpected(std::make_error_code(std::errc::invalid_argument));
+      }
+
+      std::string protocol(url.substr(0, protocol_end));
+      if (protocol != "http" && protocol != "https") {
+         return std::unexpected(std::make_error_code(std::errc::invalid_argument));
+      }
+
+      // Process host, port and path
+      size_t host_start = protocol_end + 3;
+      if (host_start >= url.size()) {
+         return std::unexpected(std::make_error_code(std::errc::invalid_argument));
+      }
+
+      size_t host_end = url.find_first_of("/:", host_start);
+      std::string host;
+      std::string port_str;
+      std::string path = "/";
+
+      if (host_end == std::string_view::npos) {
+         host = std::string(url.substr(host_start));
+      }
+      else if (url[host_end] == ':') {
+         host = std::string(url.substr(host_start, host_end - host_start));
+         size_t port_start = host_end + 1;
+         size_t port_end = url.find('/', port_start);
+
+         if (port_end == std::string_view::npos) {
+            port_str = std::string(url.substr(port_start));
+         }
+         else {
+            port_str = std::string(url.substr(port_start, port_end - port_start));
+            path = std::string(url.substr(port_end));
+         }
+
+         if (!port_str.empty() && !std::all_of(port_str.begin(), port_str.end(), ::isdigit)) {
+            return std::unexpected(std::make_error_code(std::errc::invalid_argument));
+         }
+      }
+      else if (url[host_end] == '/') {
+         host = std::string(url.substr(host_start, host_end - host_start));
+         path = std::string(url.substr(host_end));
+      }
+
+      if (host.empty() || host.find_first_of(":/") != std::string::npos) {
+         return std::unexpected(std::make_error_code(std::errc::invalid_argument));
+      }
+
+      uint16_t port = 0;
+      if (port_str.empty()) {
+         port = (protocol == "https") ? 443 : 80;
+      }
+      else {
+         try {
+            long port_long = std::stol(port_str);
+            if (port_long <= 0 || port_long > 65535) {
+               return std::unexpected(std::make_error_code(std::errc::invalid_argument));
+            }
+            port = static_cast<uint16_t>(port_long);
+         }
+         catch (const std::exception&) {
+            return std::unexpected(std::make_error_code(std::errc::invalid_argument));
+         }
+      }
+
+      return url_parts{std::move(protocol), std::move(host), port, std::move(path)};
+   }
+
+   // HTTP connection pool for reusing sockets
+   struct http_connection_pool
+   {
+      struct connection_key
+      {
+         std::string host;
+         uint16_t port;
+
+         bool operator==(const connection_key& other) const { return host == other.host && port == other.port; }
+      };
+
+      struct connection_key_hash
+      {
+         size_t operator()(const connection_key& key) const
+         {
+            return std::hash<std::string>{}(key.host) ^ (std::hash<uint16_t>{}(key.port) << 1);
+         }
+      };
+
+      std::mutex mtx;
+      std::unordered_map<connection_key, std::vector<std::shared_ptr<asio::ip::tcp::socket>>, connection_key_hash>
+         available_connections;
+      std::shared_ptr<asio::io_context> io_context;
+
+      http_connection_pool(std::shared_ptr<asio::io_context> ctx) : io_context(ctx) {}
+
+      std::shared_ptr<asio::ip::tcp::socket> get_connection(const std::string& host, uint16_t port)
+      {
+         connection_key key{host, port};
+
+         {
+            std::lock_guard<std::mutex> lock(mtx);
+            auto it = available_connections.find(key);
+            if (it != available_connections.end() && !it->second.empty()) {
+               auto socket = it->second.back();
+               it->second.pop_back();
+
+               // Check if socket is still connected
+               if (socket && socket->is_open()) {
+                  // A simple check might not be enough for stale connections.
+                  // A more robust implementation might send a probe or check for readability.
+                  // For now, we assume is_open() is sufficient.
+                  return socket;
+               }
+            }
+         }
+
+         // Create new connection if none are available or they are closed
+         return std::make_shared<asio::ip::tcp::socket>(*io_context);
+      }
+
+      void return_connection(const std::string& host, uint16_t port, std::shared_ptr<asio::ip::tcp::socket> socket)
+      {
+         if (!socket || !socket->is_open()) {
+            return;
+         }
+
+         connection_key key{host, port};
+         std::lock_guard<std::mutex> lock(mtx);
+
+         auto& connections = available_connections[key];
+         if (connections.size() < 10) { // Limit pool size per host
+            connections.push_back(socket);
+         }
+         // else, the socket is just closed when the shared_ptr goes out of scope.
+      }
+   };
+
+   // Forward declaration for streaming connection
+   struct http_stream_connection;
+
+   // Handler function types for streaming
+   using http_data_handler = std::function<void(std::string_view data)>;
+   using http_error_handler = std::function<void(std::error_code ec)>;
+   using http_connect_handler = std::function<void(const response& headers)>;
+   using http_disconnect_handler = std::function<void()>;
+
+   // Streaming HTTP connection handle
+   struct http_stream_connection
+   {
+      std::shared_ptr<asio::ip::tcp::socket> socket;
+      std::shared_ptr<asio::steady_timer> timer;
+      std::shared_ptr<asio::streambuf> buffer; // Use unified streambuf for all reads
+      bool is_connected{false};
+      std::atomic<bool> should_stop{false};
+      stream_read_strategy strategy{stream_read_strategy::bulk_transfer}; // Default strategy
+
+      // Constructor with optional buffer size limit and strategy
+      http_stream_connection(size_t max_buffer_size = 1024 * 1024,
+                             stream_read_strategy read_strategy = stream_read_strategy::bulk_transfer)
+         : buffer(std::make_shared<asio::streambuf>(max_buffer_size)), strategy(read_strategy)
+      {}
+
+      // User-facing disconnect. Signals the internal loops to stop.
+      // The actual socket closing/pooling is handled by the internal disconnect handler.
+      void disconnect()
+      {
+         bool expected = false;
+         if (should_stop.compare_exchange_strong(expected, true)) {
+            if (socket && socket->is_open()) {
+               std::error_code ec;
+               // This cancels pending async operations on the socket, triggering their handlers
+               // with asio::error::operation_aborted.
+               socket->cancel(ec);
+            }
+            if (timer) {
+               timer->cancel();
+            }
+         }
+      }
+
+      ~http_stream_connection() { disconnect(); }
+   };
+
+   // Stream request parameters struct
+   struct stream_request_params
+   {
+      std::string url;
+      http_data_handler on_data;
+      http_error_handler on_error;
+      std::string method{};
+      std::string body{};
+      std::unordered_map<std::string, std::string> headers{};
+      http_connect_handler on_connect{};
+      http_disconnect_handler on_disconnect{};
+      std::chrono::seconds timeout{std::chrono::seconds{30}};
+      stream_read_strategy strategy{stream_read_strategy::bulk_transfer};
+   };
+
+   struct http_client
+   {
+      http_client()
+         : async_io_context(std::make_shared<asio::io_context>()),
+           connection_pool(std::make_shared<http_connection_pool>(async_io_context))
+      {
+         start_workers();
+      }
+
+      ~http_client() { stop_workers(); }
+
+      // Synchronous GET request - truly synchronous, no promises/futures
+      std::expected<response, std::error_code> get(std::string_view url,
+                                                   const std::unordered_map<std::string, std::string>& headers = {})
+      {
+         auto url_result = parse_url(url);
+         if (!url_result) {
+            return std::unexpected(url_result.error());
+         }
+
+         return perform_sync_request("GET", *url_result, "", headers);
+      }
+
+      // Synchronous POST request - truly synchronous, no promises/futures
+      std::expected<response, std::error_code> post(std::string_view url, const std::string& body,
+                                                    const std::unordered_map<std::string, std::string>& headers = {})
+      {
+         auto url_result = parse_url(url);
+         if (!url_result) {
+            return std::unexpected(url_result.error());
+         }
+
+         return perform_sync_request("POST", *url_result, body, headers);
+      }
+
+      // Synchronous JSON POST request
+      template <class T>
+      std::expected<response, std::error_code> post_json(
+         std::string_view url, const T& data, const std::unordered_map<std::string, std::string>& headers = {})
+      {
+         std::string json_str;
+         auto ec = glz::write_json(data, json_str);
+         if (ec) {
+            return std::unexpected(std::make_error_code(std::errc::invalid_argument));
+         }
+
+         auto merged_headers = headers;
+         merged_headers["Content-Type"] = "application/json";
+
+         return post(url, json_str, merged_headers);
+      }
+
+      // New unified streaming request method
+      std::shared_ptr<http_stream_connection> stream_request(const stream_request_params& params)
+      {
+         auto url_result = parse_url(params.url);
+         if (!url_result) {
+            asio::post(*async_io_context,
+                       [on_error = params.on_error, error = url_result.error()]() { on_error(error); });
+            return nullptr;
+         }
+
+         std::string method = params.method.empty() ? "GET" : params.method;
+
+         return perform_stream_request(method, *url_result, params.body, params.headers, params.timeout,
+                                       params.strategy, params.on_data, params.on_error, params.on_connect,
+                                       params.on_disconnect);
+      }
+
+      // Asynchronous GET request
+      template <typename CompletionHandler>
+      void get_async(std::string_view url, const std::unordered_map<std::string, std::string>& headers,
+                     CompletionHandler&& handler)
+      {
+         auto url_result = parse_url(url);
+         if (!url_result) {
+            asio::post(*async_io_context, [handler = std::forward<CompletionHandler>(handler),
+                                           error = url_result.error()] mutable { handler(std::unexpected(error)); });
+            return;
+         }
+
+         perform_request_async("GET", *url_result, "", headers, std::forward<CompletionHandler>(handler));
+      }
+
+      // Overload for get_async without completion handler (returns future)
+      std::future<std::expected<response, std::error_code>> get_async(
+         std::string_view url, const std::unordered_map<std::string, std::string>& headers = {})
+      {
+         std::promise<std::expected<response, std::error_code>> promise;
+         auto future = promise.get_future();
+
+         get_async(url, headers,
+                   [promise = std::move(promise)](std::expected<response, std::error_code> result) mutable {
+                      promise.set_value(std::move(result));
+                   });
+
+         return future;
+      }
+
+      // Asynchronous POST request
+      template <typename CompletionHandler>
+      void post_async(std::string_view url, const std::string& body,
+                      const std::unordered_map<std::string, std::string>& headers, CompletionHandler&& handler)
+      {
+         auto url_result = parse_url(url);
+         if (!url_result) {
+            asio::post(*async_io_context, [handler = std::forward<CompletionHandler>(handler),
+                                           error = url_result.error()] mutable { handler(std::unexpected(error)); });
+            return;
+         }
+
+         perform_request_async("POST", *url_result, body, headers, std::forward<CompletionHandler>(handler));
+      }
+
+      // Overload for post_async without completion handler (returns future)
+      std::future<std::expected<response, std::error_code>> post_async(
+         std::string_view url, const std::string& body,
+         const std::unordered_map<std::string, std::string>& headers = {})
+      {
+         std::promise<std::expected<response, std::error_code>> promise;
+         auto future = promise.get_future();
+
+         post_async(url, body, headers,
+                    [promise = std::move(promise)](std::expected<response, std::error_code> result) mutable {
+                       promise.set_value(std::move(result));
+                    });
+
+         return future;
+      }
+
+      // Async JSON POST request
+      template <class T, typename CompletionHandler>
+      void post_json_async(std::string_view url, const T& data,
+                           const std::unordered_map<std::string, std::string>& headers, CompletionHandler&& handler)
+      {
+         std::string json_str;
+         auto ec = glz::write_json(data, json_str);
+         if (ec) {
+            asio::post(*async_io_context, [handler = std::forward<CompletionHandler>(handler)]() {
+               handler(std::unexpected(std::make_error_code(std::errc::invalid_argument)));
+            });
+            return;
+         }
+
+         auto merged_headers = headers;
+         merged_headers["Content-Type"] = "application/json";
+
+         post_async(url, json_str, merged_headers, std::forward<CompletionHandler>(handler));
+      }
+
+      // Overload for post_json_async without completion handler (returns future)
+      template <class T>
+      std::future<std::expected<response, std::error_code>> post_json_async(
+         std::string_view url, const T& data, const std::unordered_map<std::string, std::string>& headers = {})
+      {
+         std::promise<std::expected<response, std::error_code>> promise;
+         auto future = promise.get_future();
+
+         post_json_async(url, data, headers,
+                         [promise = std::move(promise)](std::expected<response, std::error_code> result) mutable {
+                            promise.set_value(std::move(result));
+                         });
+
+         return future;
+      }
+
+     private:
+      std::shared_ptr<asio::io_context> async_io_context; // For async operations only
+      std::shared_ptr<http_connection_pool> connection_pool;
+      std::vector<std::thread> worker_threads;
+      std::atomic<bool> running{true};
+
+      void start_workers()
+      {
+         size_t num_threads = std::max(2u, std::thread::hardware_concurrency());
+         worker_threads.reserve(num_threads);
+
+         for (size_t i = 0; i < num_threads; ++i) {
+            worker_threads.emplace_back([this]() {
+               while (running) {
+                  try {
+                     async_io_context->run();
+                     // Reset context to allow it to be run again after being stopped
+                     if (async_io_context->stopped()) {
+                        async_io_context->restart();
+                     }
+                  }
+                  catch (const std::exception& e) {
+                     std::cerr << "HTTP client worker error: " << e.what() << std::endl;
+                  }
+               }
+            });
+         }
+      }
+
+      void stop_workers()
+      {
+         running = false;
+         async_io_context->stop();
+
+         for (auto& thread : worker_threads) {
+            if (thread.joinable()) {
+               thread.join();
+            }
+         }
+      }
+
+      std::shared_ptr<http_stream_connection> perform_stream_request(
+         const std::string& method, const url_parts& url, const std::string& body,
+         const std::unordered_map<std::string, std::string>& headers, std::chrono::seconds timeout,
+         stream_read_strategy strategy, http_data_handler on_data, http_error_handler on_error,
+         http_connect_handler on_connect, http_disconnect_handler on_disconnect)
+      {
+         auto connection = std::make_shared<http_stream_connection>(1024 * 1024, strategy);
+         connection->socket = connection_pool->get_connection(url.host, url.port);
+         connection->timer = std::make_shared<asio::steady_timer>(*async_io_context);
+
+         // Wrap the disconnect handler to return the socket to the pool
+         auto internal_on_disconnect = [this, user_on_disconnect = std::move(on_disconnect), connection, url]() {
+            connection->is_connected = false;
+            // Call the user's handler if provided
+            if (user_on_disconnect) {
+               user_on_disconnect();
+            }
+            // Return the connection to the pool for reuse
+            connection_pool->return_connection(url.host, url.port, connection->socket);
+         };
+
+         // Set connection timeout
+         connection->timer->expires_after(timeout);
+         connection->timer->async_wait([connection, on_error, internal_on_disconnect](std::error_code ec) {
+            if (!ec && !connection->is_connected && !connection->should_stop) {
+               // Mark for stop to prevent race conditions
+               connection->disconnect();
+               on_error(std::make_error_code(std::errc::timed_out));
+               internal_on_disconnect();
+            }
+         });
+
+         // Check if the socket is already open
+         if (connection->socket->is_open()) {
+            // If already connected, skip resolve and connect, and just send the request
+            asio::post(*async_io_context, [this, url, method, body, headers, connection, on_data = std::move(on_data),
+                                           on_error = std::move(on_error), on_connect = std::move(on_connect),
+                                           internal_on_disconnect = std::move(internal_on_disconnect)]() mutable {
+               send_stream_request(url, method, body, headers, connection, std::move(on_data), std::move(on_error),
+                                   std::move(on_connect), std::move(internal_on_disconnect));
+            });
+         }
+         else {
+            // If not connected, resolve and connect as before
+            auto resolver = std::make_shared<asio::ip::tcp::resolver>(*async_io_context);
+            resolver->async_resolve(
+               url.host, std::to_string(url.port),
+               [this, url, method, body, headers, connection, resolver, on_data = std::move(on_data),
+                on_error = std::move(on_error), on_connect = std::move(on_connect),
+                internal_on_disconnect = std::move(internal_on_disconnect)](
+                  std::error_code ec, asio::ip::tcp::resolver::results_type results) mutable {
+                  if (ec || connection->should_stop) {
+                     on_error(ec);
+                     internal_on_disconnect(); // Ensure cleanup on resolve error
+                     return;
+                  }
+
+                  asio::async_connect(*connection->socket, results,
+                                      [this, url, method, body, headers, connection, on_data = std::move(on_data),
+                                       on_error = std::move(on_error), on_connect = std::move(on_connect),
+                                       internal_on_disconnect = std::move(internal_on_disconnect)](
+                                         std::error_code ec, const asio::ip::tcp::endpoint&) mutable {
+                                         if (ec || connection->should_stop) {
+                                            on_error(ec);
+                                            internal_on_disconnect(); // Ensure cleanup on connect error
+                                            return;
+                                         }
+
+                                         send_stream_request(url, method, body, headers, connection, std::move(on_data),
+                                                             std::move(on_error), std::move(on_connect),
+                                                             std::move(internal_on_disconnect));
+                                      });
+               });
+         }
+
+         return connection;
+      }
+
+      // Needs to take the wrapped disconnect handler and use keep-alive
+      void send_stream_request(const url_parts& url, const std::string& method, const std::string& body,
+                               const std::unordered_map<std::string, std::string>& headers,
+                               std::shared_ptr<http_stream_connection> connection, http_data_handler on_data,
+                               http_error_handler on_error, http_connect_handler on_connect,
+                               http_disconnect_handler on_disconnect)
+      {
+         std::string request_str;
+         request_str.reserve(512 + body.size());
+
+         request_str.append(method);
+         request_str.append(" ");
+         request_str.append(url.path);
+         request_str.append(" HTTP/1.1\r\n");
+         request_str.append("Host: ");
+         request_str.append(url.host);
+         request_str.append("\r\n");
+         // Use keep-alive to allow the connection to be pooled
+         request_str.append("Connection: keep-alive\r\n");
+
+         if (!body.empty()) {
+            request_str.append("Content-Length: ");
+            request_str.append(std::to_string(body.size()));
+            request_str.append("\r\n");
+         }
+
+         for (const auto& [name, value] : headers) {
+            request_str.append(name);
+            request_str.append(": ");
+            request_str.append(value);
+            request_str.append("\r\n");
+         }
+         request_str.append("\r\n");
+         request_str.append(body);
+
+         auto request_buffer = std::make_shared<std::string>(std::move(request_str));
+
+         asio::async_write(*connection->socket, asio::buffer(*request_buffer),
+                           [this, connection, request_buffer, on_data = std::move(on_data),
+                            on_error = std::move(on_error), on_connect = std::move(on_connect),
+                            on_disconnect = std::move(on_disconnect)](std::error_code ec, std::size_t) mutable {
+                              if (ec || connection->should_stop) {
+                                 on_error(ec);
+                                 if (on_disconnect) on_disconnect();
+                                 return;
+                              }
+
+                              read_stream_response(connection, std::move(on_data), std::move(on_error),
+                                                   std::move(on_connect), std::move(on_disconnect));
+                           });
+      }
+
+      void read_stream_response(std::shared_ptr<http_stream_connection> connection, http_data_handler on_data,
+                                http_error_handler on_error, http_connect_handler on_connect,
+                                http_disconnect_handler on_disconnect)
+      {
+         // Use the connection's unified buffer
+         asio::async_read_until(
+            *connection->socket, *connection->buffer, "\r\n\r\n",
+            [this, connection, on_data = std::move(on_data), on_error = std::move(on_error),
+             on_connect = std::move(on_connect),
+             on_disconnect = std::move(on_disconnect)](std::error_code ec, std::size_t bytes_transferred) mutable {
+               if (ec || connection->should_stop) {
+                  on_error(ec);
+                  if (on_disconnect) on_disconnect();
+                  return;
+               }
+
+               // Create a zero-copy string_view of the received headers
+               std::string_view header_data{static_cast<const char*>(connection->buffer->data().data()),
+                                            bytes_transferred};
+
+               // Parse status line
+               auto line_end = header_data.find("\r\n");
+               if (line_end == std::string_view::npos) {
+                  on_error(std::make_error_code(std::errc::protocol_error));
+                  if (on_disconnect) on_disconnect();
+                  return;
+               }
+               std::string_view status_line = header_data.substr(0, line_end);
+               header_data.remove_prefix(line_end + 2);
+
+               auto parsed_status = parse_http_status_line(status_line);
+               if (!parsed_status) {
+                  on_error(parsed_status.error());
+                  if (on_disconnect) on_disconnect();
+                  return;
+               }
+
+               response response_headers;
+               response_headers.status_code = parsed_status->status_code;
+
+               // Parse header fields
+               while (!header_data.starts_with("\r\n")) {
+                  line_end = header_data.find("\r\n");
+                  if (line_end == std::string_view::npos) {
+                     on_error(std::make_error_code(std::errc::protocol_error));
+                     if (on_disconnect) on_disconnect();
+                     return;
+                  }
+
+                  std::string_view header_line = header_data.substr(0, line_end);
+                  header_data.remove_prefix(line_end + 2);
+
+                  auto colon_pos = header_line.find(':');
+                  if (colon_pos != std::string::npos) {
+                     std::string_view name = header_line.substr(0, colon_pos);
+                     // Skip past ':' and any whitespace
+                     size_t value_start = header_line.find_first_not_of(" \t", colon_pos + 1);
+                     std::string_view value = (value_start != std::string::npos) ? header_line.substr(value_start) : "";
+
+                     // Create strings only when inserting into the map
+                     response_headers.response_headers[std::string(name)] = std::string(value);
+                  }
+               }
+
+               // Consume all processed header data from the streambuf
+               connection->buffer->consume(bytes_transferred);
+
+               connection->is_connected = true;
+               connection->timer->cancel();
+
+               if (on_connect) {
+                  on_connect(response_headers);
+               }
+
+               if (parsed_status->status_code >= 400) {
+                  // Status code indicates an error, so we report it and end the stream.
+                  on_error(std::make_error_code(std::errc::connection_refused)); // Generic error for now
+                  if (on_disconnect) on_disconnect();
+                  return;
+               }
+
+               bool is_chunked = false;
+               auto it = response_headers.response_headers.find("Transfer-Encoding");
+               if (it != response_headers.response_headers.end()) {
+                  if (it->second.find("chunked") != std::string::npos) {
+                     is_chunked = true;
+                  }
+               }
+
+               if (is_chunked) {
+                  start_chunked_reading(connection, std::move(on_data), std::move(on_error), std::move(on_disconnect));
+               }
+               else {
+                  start_stream_reading(connection, std::move(on_data), std::move(on_error), std::move(on_disconnect));
+               }
+            });
+      }
+
+      void start_chunked_reading(std::shared_ptr<http_stream_connection> connection, http_data_handler on_data,
+                                 http_error_handler on_error, http_disconnect_handler on_disconnect)
+      {
+         // Begin the chunk parsing loop.
+         // The buffer may already contain the first chunk size line or more data.
+         read_chunk_size(connection, std::move(on_data), std::move(on_error), std::move(on_disconnect));
+      }
+
+      void read_chunk_size(std::shared_ptr<http_stream_connection> connection, http_data_handler on_data,
+                           http_error_handler on_error, http_disconnect_handler on_disconnect)
+      {
+         asio::async_read_until(
+            *connection->socket, *connection->buffer, "\r\n",
+            [this, connection, on_data = std::move(on_data), on_error = std::move(on_error),
+             on_disconnect = std::move(on_disconnect)](std::error_code ec, std::size_t bytes_transferred) mutable {
+               if (ec || connection->should_stop) {
+                  if (ec != asio::error::eof && ec != asio::error::operation_aborted && !connection->should_stop)
+                     on_error(ec);
+                  if (on_disconnect) on_disconnect();
+                  return;
+               }
+
+               std::string_view line_view{static_cast<const char*>(connection->buffer->data().data()),
+                                          bytes_transferred - 2}; // -2 to exclude CRLF
+
+               // Ignore chunk extensions
+               auto semi_pos = line_view.find(';');
+               if (semi_pos != std::string_view::npos) {
+                  line_view = line_view.substr(0, semi_pos);
+               }
+
+               size_t chunk_size;
+               auto [ptr, parse_ec] =
+                  std::from_chars(line_view.data(), line_view.data() + line_view.size(), chunk_size, 16);
+
+               if (parse_ec != std::errc{}) {
+                  on_error(std::make_error_code(std::errc::protocol_error));
+                  if (on_disconnect) on_disconnect();
+                  return;
+               }
+
+               // Consume the size line and CRLF from the buffer
+               connection->buffer->consume(bytes_transferred);
+
+               if (chunk_size == 0) {
+                  // Last chunk
+                  if (on_disconnect) on_disconnect();
+                  return;
+               }
+
+               read_chunk_body(connection, chunk_size, std::move(on_data), std::move(on_error),
+                               std::move(on_disconnect));
+            });
+      }
+
+      void read_chunk_body(std::shared_ptr<http_stream_connection> connection, size_t chunk_size,
+                           http_data_handler on_data, http_error_handler on_error,
+                           http_disconnect_handler on_disconnect)
+      {
+         // We need to read 'chunk_size' bytes of data, plus 2 bytes for the trailing CRLF.
+         size_t total_to_read = chunk_size + 2;
+
+         // Check if we have enough data in the buffer already.
+         if (connection->buffer->size() >= total_to_read) {
+            std::string_view data{static_cast<const char*>(connection->buffer->data().data()), chunk_size};
+            on_data(data);
+            connection->buffer->consume(total_to_read);
+
+            // Post the next read to avoid deep recursion
+            asio::post(connection->socket->get_executor(), [this, connection, on_data = std::move(on_data),
+                                                            on_error = std::move(on_error),
+                                                            on_disconnect = std::move(on_disconnect)]() mutable {
+               read_chunk_size(connection, std::move(on_data), std::move(on_error), std::move(on_disconnect));
+            });
+            return;
+         }
+
+         // We need to read more from the socket.
+         asio::async_read(
+            *connection->socket, *connection->buffer,
+            asio::transfer_exactly(total_to_read - connection->buffer->size()),
+            [this, connection, chunk_size, on_data = std::move(on_data), on_error = std::move(on_error),
+             on_disconnect = std::move(on_disconnect)](std::error_code ec, std::size_t) mutable {
+               if (ec || connection->should_stop) {
+                  if (ec != asio::error::eof && ec != asio::error::operation_aborted && !connection->should_stop)
+                     on_error(ec);
+                  if (on_disconnect) on_disconnect();
+                  return;
+               }
+
+               std::string_view data{static_cast<const char*>(connection->buffer->data().data()), chunk_size};
+               on_data(data);
+               connection->buffer->consume(chunk_size + 2); // Consume data + trailing CRLF
+
+               read_chunk_size(connection, std::move(on_data), std::move(on_error), std::move(on_disconnect));
+            });
+      }
+
+      void start_stream_reading(std::shared_ptr<http_stream_connection> connection, http_data_handler on_data,
+                                http_error_handler on_error, http_disconnect_handler on_disconnect)
+      {
+         // Dispatch to the appropriate strategy
+         switch (connection->strategy) {
+         case stream_read_strategy::bulk_transfer:
+            start_stream_reading_bulk(connection, std::move(on_data), std::move(on_error), std::move(on_disconnect));
+            break;
+         case stream_read_strategy::immediate_delivery:
+            start_stream_reading_immediate(connection, std::move(on_data), std::move(on_error),
+                                           std::move(on_disconnect));
+            break;
+         }
+      }
+
+      void start_stream_reading_bulk(std::shared_ptr<http_stream_connection> connection, http_data_handler on_data,
+                                     http_error_handler on_error, http_disconnect_handler on_disconnect)
+      {
+         // Process any existing data in buffer first
+         if (connection->buffer->size() > 0) {
+            std::string_view data{static_cast<const char*>(connection->buffer->data().data()),
+                                  connection->buffer->size()};
+            on_data(data);
+            connection->buffer->consume(connection->buffer->size());
+         }
+
+         if (connection->should_stop) {
+            if (on_disconnect) on_disconnect();
+            return;
+         }
+
+         // Use async_read with transfer_at_least(1) - may read more data for efficiency
+         asio::async_read(
+            *connection->socket, *connection->buffer, asio::transfer_at_least(1),
+            [this, connection, on_data, on_error, on_disconnect](std::error_code ec,
+                                                                 std::size_t /*bytes_transferred*/) {
+               if (ec || connection->should_stop) {
+                  if (ec != asio::error::eof && ec != asio::error::operation_aborted && !connection->should_stop) {
+                     on_error(ec);
+                  }
+                  if (on_disconnect) on_disconnect();
+                  return;
+               }
+
+               // Recurse to process the new data
+               start_stream_reading_bulk(connection, on_data, on_error, on_disconnect);
+            });
+      }
+
+      void start_stream_reading_immediate(std::shared_ptr<http_stream_connection> connection, http_data_handler on_data,
+                                          http_error_handler on_error, http_disconnect_handler on_disconnect)
+      {
+         // Process existing buffer content first
+         if (connection->buffer->size() > 0) {
+            std::string_view data{static_cast<const char*>(connection->buffer->data().data()),
+                                  connection->buffer->size()};
+            on_data(data);
+            connection->buffer->consume(connection->buffer->size());
+         }
+
+         if (connection->should_stop) {
+            if (on_disconnect) on_disconnect();
+            return;
+         }
+
+         // Use async_read_some for immediate delivery of available data
+         constexpr size_t read_size = 8192;
+         connection->socket->async_read_some(
+            connection->buffer->prepare(read_size),
+            [this, connection, on_data, on_error, on_disconnect](std::error_code ec, std::size_t bytes_transferred) {
+               if (ec || connection->should_stop) {
+                  if (ec != asio::error::eof && ec != asio::error::operation_aborted && !connection->should_stop) {
+                     on_error(ec);
+                  }
+                  if (on_disconnect) on_disconnect();
+                  return;
+               }
+
+               // Commit the received data and deliver immediately
+               connection->buffer->commit(bytes_transferred);
+
+               std::string_view data{static_cast<const char*>(connection->buffer->data().data()), bytes_transferred};
+               on_data(data);
+               connection->buffer->consume(bytes_transferred);
+
+               // Continue reading
+               start_stream_reading_immediate(connection, on_data, on_error, on_disconnect);
+            });
+      }
+
+      std::expected<response, std::error_code> perform_sync_request(
+         const std::string& method, const url_parts& url, const std::string& body,
+         const std::unordered_map<std::string, std::string>& headers)
+      {
+         auto socket = connection_pool->get_connection(url.host, url.port);
+
+         try {
+            // If socket is not connected, connect it synchronously
+            if (!socket->is_open()) {
+               asio::ip::tcp::resolver resolver(*async_io_context);
+               auto endpoints = resolver.resolve(url.host, std::to_string(url.port));
+               asio::connect(*socket, endpoints);
+            }
+
+            // Build HTTP request
+            std::string request_str;
+            request_str.append(method);
+            request_str.append(" ");
+            request_str.append(url.path);
+            request_str.append(" HTTP/1.1\r\n");
+            request_str.append("Host: ");
+            request_str.append(url.host);
+            request_str.append("\r\n");
+            request_str.append("Connection: keep-alive\r\n"); // Keep connection alive for reuse
+
+            if (!body.empty()) {
+               request_str.append("Content-Length: ");
+               request_str.append(std::to_string(body.size()));
+               request_str.append("\r\n");
+            }
+
+            for (const auto& [name, value] : headers) {
+               request_str.append(name);
+               request_str.append(": ");
+               request_str.append(value);
+               request_str.append("\r\n");
+            }
+
+            request_str.append("\r\n");
+            request_str.append(body);
+
+            // Send request synchronously
+            asio::write(*socket, asio::buffer(request_str));
+
+            // Read response headers synchronously
+            asio::streambuf response_buffer;
+            std::error_code ec;
+            size_t header_bytes = asio::read_until(*socket, response_buffer, "\r\n\r\n", ec);
+            if (ec) {
+               socket->close();
+               return std::unexpected(ec);
+            }
+
+            // Create a zero-copy view of the header data
+            std::string_view header_data{static_cast<const char*>(response_buffer.data().data()), header_bytes};
+
+            // Parse status line from the view
+            auto line_end = header_data.find("\r\n");
+            if (line_end == std::string_view::npos) {
+               return std::unexpected(std::make_error_code(std::errc::protocol_error));
+            }
+            std::string_view status_line = header_data.substr(0, line_end);
+            header_data.remove_prefix(line_end + 2); // Advance past status line
+
+            auto parsed_status = parse_http_status_line(status_line);
+            if (!parsed_status) {
+               return std::unexpected(parsed_status.error());
+            }
+
+            // Parse headers from the view
+            std::unordered_map<std::string, std::string> response_headers;
+            size_t content_length = 0;
+            bool connection_close = false;
+
+            while (!header_data.starts_with("\r\n")) {
+               line_end = header_data.find("\r\n");
+               if (line_end == std::string_view::npos) {
+                  return std::unexpected(std::make_error_code(std::errc::protocol_error));
+               }
+               std::string_view header_line = header_data.substr(0, line_end);
+               header_data.remove_prefix(line_end + 2);
+
+               auto colon_pos = header_line.find(':');
+               if (colon_pos != std::string::npos) {
+                  std::string_view name = header_line.substr(0, colon_pos);
+                  size_t value_start = header_line.find_first_not_of(" \t", colon_pos + 1);
+                  std::string_view value = (value_start != std::string::npos) ? header_line.substr(value_start) : "";
+
+                  if (name.length() == 14 && strncasecmp(name.data(), "Content-Length", 14) == 0) {
+                     std::from_chars(value.data(), value.data() + value.size(), content_length);
+                  }
+                  else if (name.length() == 10 && strncasecmp(name.data(), "Connection", 10) == 0) {
+                     if (value.find("close") != std::string_view::npos) {
+                        connection_close = true;
+                     }
+                  }
+
+                  response_headers.emplace(name, value);
+               }
+            }
+
+            // Consume header data, leaving only the over-read body part.
+            response_buffer.consume(header_bytes);
+
+            // Read the rest of the body if necessary
+            size_t body_in_buffer = response_buffer.size();
+            if (content_length > body_in_buffer) {
+               size_t remaining_to_read = content_length - body_in_buffer;
+               std::error_code read_ec;
+               asio::read(*socket, response_buffer, asio::transfer_exactly(remaining_to_read), read_ec);
+               if (read_ec) {
+                  socket->close(); // Don't reuse a failed connection
+                  return std::unexpected(read_ec);
+               }
+            }
+
+            // Create the body string from the buffer, respecting content_length.
+            std::string response_body(static_cast<const char*>(response_buffer.data().data()),
+                                      std::min(content_length, response_buffer.size()));
+
+            response resp;
+            resp.status_code = parsed_status->status_code;
+            resp.response_headers = std::move(response_headers);
+            resp.response_body = std::move(response_body);
+
+            if (!connection_close) {
+               connection_pool->return_connection(url.host, url.port, socket);
+            }
+            // else, the server will close the connection, so we don't return it to the pool.
+
+            return resp;
+         }
+         catch (const std::system_error& e) {
+            socket->close(); // Ensure socket is closed on error
+            return std::unexpected(e.code());
+         }
+         catch (...) {
+            socket->close(); // Ensure socket is closed on error
+            return std::unexpected(std::make_error_code(std::errc::connection_refused));
+         }
+      }
+
+      template <typename CompletionHandler>
+      void perform_request_async(const std::string& method, const url_parts& url, const std::string& body,
+                                 const std::unordered_map<std::string, std::string>& headers,
+                                 CompletionHandler&& handler)
+      {
+         auto socket = connection_pool->get_connection(url.host, url.port);
+
+         if (socket->is_open()) {
+            send_request(socket, method, url, body, headers, std::forward<CompletionHandler>(handler));
+         }
+         else {
+            auto resolver = std::make_shared<asio::ip::tcp::resolver>(*async_io_context);
+            resolver->async_resolve(
+               url.host, std::to_string(url.port),
+               [this, socket, resolver, method, url, body, headers, handler = std::forward<CompletionHandler>(handler)](
+                  std::error_code ec, asio::ip::tcp::resolver::results_type results) mutable {
+                  if (ec) {
+                     handler(std::unexpected(ec));
+                     return;
+                  }
+
+                  connect_and_send(socket, results, method, url, body, headers, std::move(handler));
+               });
+         }
+      }
+
+      template <typename CompletionHandler>
+      void connect_and_send(std::shared_ptr<asio::ip::tcp::socket> socket,
+                            asio::ip::tcp::resolver::results_type results, const std::string& method,
+                            const url_parts& url, const std::string& body,
+                            const std::unordered_map<std::string, std::string>& headers, CompletionHandler&& handler)
+      {
+         asio::async_connect(
+            *socket, results,
+            [this, socket, method, url, body, headers, handler = std::forward<CompletionHandler>(handler)](
+               std::error_code ec, const asio::ip::tcp::endpoint&) mutable {
+               if (ec) {
+                  handler(std::unexpected(ec));
+                  return;
+               }
+
+               send_request(socket, method, url, body, headers, std::move(handler));
+            });
+      }
+
+      template <typename CompletionHandler>
+      void send_request(std::shared_ptr<asio::ip::tcp::socket> socket, const std::string& method, const url_parts& url,
+                        const std::string& body, const std::unordered_map<std::string, std::string>& headers,
+                        CompletionHandler&& handler)
+      {
+         // Build HTTP request
+         std::string request_str;
+         request_str.append(method);
+         request_str.append(" ");
+         request_str.append(url.path);
+         request_str.append(" HTTP/1.1\r\n");
+         request_str.append("Host: ");
+         request_str.append(url.host);
+         request_str.append("\r\n");
+         request_str.append("Connection: keep-alive\r\n");
+
+         if (!body.empty()) {
+            request_str.append("Content-Length: ");
+            request_str.append(std::to_string(body.size()));
+            request_str.append("\r\n");
+         }
+
+         for (const auto& [name, value] : headers) {
+            request_str.append(name);
+            request_str.append(": ");
+            request_str.append(value);
+            request_str.append("\r\n");
+         }
+
+         request_str.append("\r\n");
+         request_str.append(body);
+
+         // Use shared_ptr to keep request string alive during async operation
+         auto request_str_ptr = std::make_shared<std::string>(std::move(request_str));
+         asio::async_write(*socket, asio::buffer(*request_str_ptr),
+                           [this, socket, request_str_ptr, url, handler = std::forward<CompletionHandler>(handler)](
+                              std::error_code ec, std::size_t) mutable {
+                              if (ec) {
+                                 handler(std::unexpected(ec));
+                                 return;
+                              }
+
+                              read_response(socket, url, std::move(handler));
+                           });
+      }
+
+      template <typename CompletionHandler>
+      void read_response(std::shared_ptr<asio::ip::tcp::socket> socket, const url_parts& url,
+                         CompletionHandler&& handler)
+      {
+         auto buffer = std::make_shared<asio::streambuf>();
+
+         asio::async_read_until(*socket, *buffer, "\r\n\r\n",
+                                [this, socket, buffer, url, handler = std::forward<CompletionHandler>(handler)](
+                                   std::error_code ec, std::size_t bytes_transferred) mutable {
+                                   if (ec) {
+                                      handler(std::unexpected(ec));
+                                      return;
+                                   }
+                                   // Pass the known header size to the parsing function
+                                   parse_and_read_body(socket, buffer, bytes_transferred, url, std::move(handler));
+                                });
+      }
+
+      template <typename CompletionHandler>
+      void parse_and_read_body(std::shared_ptr<asio::ip::tcp::socket> socket, std::shared_ptr<asio::streambuf> buffer,
+                               size_t header_size, // <-- NEW: The size of the header block from async_read_until
+                               const url_parts& url, CompletionHandler&& handler)
+      {
+         std::string_view header_section{static_cast<const char*>(buffer->data().data()), header_size};
+
+         // Parse the status line from the view.
+         auto line_end = header_section.find("\r\n");
+         if (line_end == std::string_view::npos) {
+            handler(std::unexpected(std::make_error_code(std::errc::protocol_error)));
+            return;
+         }
+         std::string_view status_line = header_section.substr(0, line_end);
+         header_section.remove_prefix(line_end + 2); // Move the view past the status line and its CRLF
+
+         auto parsed_status = parse_http_status_line(status_line);
+         if (!parsed_status) {
+            handler(std::unexpected(parsed_status.error()));
+            return;
+         }
+
+         // Parse all header fields from the view.
+         std::unordered_map<std::string, std::string> response_headers;
+         size_t content_length = 0;
+         // The header section ends with an empty line ("\r\n"), which means our view will start with it.
+         while (!header_section.starts_with("\r\n")) {
+            line_end = header_section.find("\r\n");
+            if (line_end == std::string_view::npos) {
+               handler(std::unexpected(std::make_error_code(std::errc::protocol_error)));
+               return;
+            }
+            std::string_view header_line = header_section.substr(0, line_end);
+            header_section.remove_prefix(line_end + 2);
+
+            auto colon_pos = header_line.find(':');
+            if (colon_pos != std::string::npos) {
+               std::string_view name = header_line.substr(0, colon_pos);
+               // Skip past ':' and any leading whitespace on the value.
+               size_t value_start = header_line.find_first_not_of(" \t", colon_pos + 1);
+               std::string_view value = (value_start != std::string::npos) ? header_line.substr(value_start) : "";
+
+               // A case-insensitive comparison is more robust for header names.
+               if (name.size() == 14 && (name[0] == 'C' || name[0] == 'c') &&
+                   glz::strncasecmp(name.data(), "Content-Length", 14) == 0) {
+                  std::from_chars(value.data(), value.data() + value.size(), content_length);
+               }
+               // Store the header, creating strings only at the last moment.
+               response_headers.emplace(name, value);
+            }
+         }
+
+         // Consume the entire header block from the streambuf.
+         // This efficiently discards the header data we've just parsed, leaving only body data.
+         buffer->consume(header_size);
+
+         // Read the rest of the body, if any is still needed.
+         size_t body_already_in_buffer = buffer->size();
+         size_t remaining_to_read =
+            (content_length > body_already_in_buffer) ? (content_length - body_already_in_buffer) : 0;
+
+         asio::async_read(
+            *socket, *buffer, asio::transfer_exactly(remaining_to_read),
+            [this, socket, buffer, url, status_code = parsed_status->status_code,
+             response_headers = std::move(response_headers),
+             handler = std::forward<CompletionHandler>(handler)](std::error_code ec, std::size_t) mutable {
+               // EOF is expected if the server closes the connection.
+               if (ec && ec != asio::error::eof) {
+                  handler(std::unexpected(ec));
+                  return;
+               }
+
+               // Directly construct the string from the buffer's contiguous memory.
+               std::string body(static_cast<const char*>(buffer->data().data()), buffer->size());
+
+               response resp;
+               resp.status_code = status_code;
+               resp.response_headers = std::move(response_headers);
+               resp.response_body = std::move(body);
+
+               // Return connection to pool if it's still usable
+               auto connection_header = resp.response_headers.find("Connection");
+               if (connection_header == resp.response_headers.end() ||
+                   connection_header->second.find("close") == std::string::npos) {
+                  connection_pool->return_connection(url.host, url.port, socket);
+               }
+
+               handler(std::move(resp));
+            });
+      }
+   };
+}
diff --git a/deps/saucer/include/glaze/net/http_router.hpp b/deps/saucer/include/glaze/net/http_router.hpp
new file mode 100644
index 0000000..de46bd2
--- /dev/null
+++ b/deps/saucer/include/glaze/net/http_router.hpp
@@ -0,0 +1,962 @@
+// Glaze Library
+// For the license information refer to glaze.hpp
+
+#pragma once
+
+#include <algorithm>
+#include <functional>
+#include <future>
+#include <iostream>
+#include <memory>
+#include <optional>
+#include <source_location>
+#include <string>
+#include <string_view>
+#include <unordered_map>
+#include <vector>
+
+#include "glaze/json/json_t.hpp"
+#include "glaze/net/http.hpp"
+
+namespace glz
+{
+   // Request context object
+   struct request
+   {
+      http_method method{};
+      std::string target{};
+      std::unordered_map<std::string, std::string> params{};
+      std::unordered_map<std::string, std::string> headers{};
+      std::string body{};
+      std::string remote_ip{};
+      uint16_t remote_port{};
+   };
+
+   // Response builder
+   struct response
+   {
+      int status_code = 200;
+      std::unordered_map<std::string, std::string> response_headers{};
+      std::string response_body{};
+
+      inline response& status(int code)
+      {
+         status_code = code;
+         return *this;
+      }
+
+      inline response& header(std::string_view name, std::string_view value)
+      {
+         response_headers[std::string(name)] = std::string(value);
+         return *this;
+      }
+
+      inline response& body(std::string_view content)
+      {
+         response_body = std::string(content);
+         return *this;
+      }
+
+      // Use glz::opts for format deduction and serialization
+      // my_response.res<Opts>(value);
+      template <auto Opts, class T>
+      response& body(T&& value)
+      {
+         if constexpr (Opts.format == JSON) {
+            content_type("application/json");
+         }
+         else if constexpr (Opts.format == BEVE) {
+            content_type("application/beve");
+         }
+         auto ec = glz::write<Opts>(std::forward<T>(value), response_body);
+         if (ec) {
+            // TODO serialize a struct into proper format for errors
+            response_body = R"({"error":"glz::write_json error"})"; // rare that this would ever happen
+         }
+         return *this;
+      }
+
+      inline response& content_type(std::string_view type) { return header("Content-Type", type); }
+
+      // JSON response helper using Glaze
+      template <class T = json_t>
+      response& json(T&& value)
+      {
+         content_type("application/json");
+         auto ec = glz::write_json(std::forward<T>(value), response_body);
+         if (ec) {
+            response_body = R"({"error":"glz::write_json error"})"; // rare that this would ever happen
+         }
+         return *this;
+      }
+   };
+
+   using handler = std::function<void(const request&, response&)>;
+   using async_handler = std::function<std::future<void>(const request&, response&)>;
+   using error_handler = std::function<void(std::error_code, std::source_location)>;
+
+   /**
+    * @brief Parameter constraint for route validation
+    *
+    * Defines validation rules for route parameters using a validation function.
+    */
+   struct param_constraint
+   {
+      /**
+       * @brief Human-readable description of the constraint
+       *
+       * Used for error reporting and debugging.
+       */
+      std::string description{};
+
+      /**
+       * @brief Validation function for parameter values
+       *
+       * This function is used to validate parameter values. It should return true if the parameter value is valid,
+       * false otherwise.
+       */
+      std::function<bool(std::string_view)> validation = [](std::string_view) { return true; };
+   };
+
+   /**
+    * @brief An entry for a registered route.
+    */
+   struct route_spec
+   {
+      std::string description{};
+      std::vector<std::string> tags{};
+      std::unordered_map<std::string, param_constraint> constraints{};
+
+      // Type information for schema generation
+      std::optional<std::string> request_body_schema{};
+      std::optional<std::string> response_schema{};
+      std::optional<std::string> request_body_type_name{};
+      std::optional<std::string> response_type_name{};
+   };
+
+   /**
+    * @brief HTTP router based on a radix tree for efficient path matching
+    *
+    * The http_router class provides fast route matching for HTTP requests using a radix tree
+    * data structure. It supports static routes, parameterized routes (e.g., "/users/:id"),
+    * wildcard routes, and parameter validation via constraints.
+    */
+   struct http_router
+   {
+      /**
+       * @brief Function type for request handlers
+       *
+       * Handlers are called when a route matches the incoming request.
+       */
+      using handler = std::function<void(const request&, response&)>;
+
+      /**
+       * @brief Function type for asynchronous request handlers
+       *
+       * Async handlers return a future that completes when the request is processed.
+       */
+      using async_handler = std::function<std::future<void>(const request&, response&)>;
+
+      /**
+       * @brief An entry for a registered route.
+       */
+      struct route_entry
+      {
+         handler handle{};
+         route_spec spec{};
+      };
+
+      /**
+       * @brief Node in the radix tree routing structure
+       *
+       * Each node represents a segment of a path, which can be a static string,
+       * a parameter (prefixed with ":"), or a wildcard (prefixed with "*").
+       */
+      struct RadixNode
+      {
+         /**
+          * @brief The path segment this node represents
+          */
+         std::string segment;
+
+         /**
+          * @brief Whether this node represents a parameter (e.g., ":id")
+          */
+         bool is_parameter = false;
+
+         /**
+          * @brief Whether this node represents a wildcard (e.g., "*action")
+          */
+         bool is_wildcard = false;
+
+         /**
+          * @brief Name of the parameter (if is_parameter or is_wildcard is true)
+          */
+         std::string parameter_name;
+
+         /**
+          * @brief Map of static child nodes indexed by segment
+          */
+         std::unordered_map<std::string, std::unique_ptr<RadixNode>> static_children;
+
+         /**
+          * @brief Parameter child node (only one parameter child per node is allowed)
+          */
+         std::unique_ptr<RadixNode> parameter_child;
+
+         /**
+          * @brief Wildcard child node (only one wildcard child per node is allowed)
+          */
+         std::unique_ptr<RadixNode> wildcard_child;
+
+         /**
+          * @brief Map of handlers for different HTTP methods
+          *
+          * Only present if this node represents an endpoint.
+          */
+         std::unordered_map<http_method, handler> handlers;
+
+         /**
+          * @brief Map of parameter constraints for different HTTP methods
+          */
+         std::unordered_map<http_method, std::unordered_map<std::string, param_constraint>> constraints;
+
+         /**
+          * @brief Whether this node represents an endpoint (route handler)
+          */
+         bool is_endpoint = false;
+
+         /**
+          * @brief Full path to this node (for debugging and conflict detection)
+          */
+         std::string full_path;
+
+         /**
+          * @brief Return a human-readable representation of this node
+          *
+          * @return String representation of the node
+          */
+         std::string to_string() const
+         {
+            std::string result;
+            result.reserve(80 + segment.size() + full_path.size());
+
+            result.append("Node[");
+            result.append(is_parameter ? "PARAM:" : (is_wildcard ? "WILD:" : ""));
+            result.append(segment);
+            result.append(", endpoint=");
+            result.append(is_endpoint ? "true" : "false");
+            result.append(", children=");
+            result.append(std::to_string(static_children.size()));
+            result.append(parameter_child ? "+param" : "");
+            result.append(wildcard_child ? "+wild" : "");
+            result.append(", full_path=");
+            result.append(full_path);
+            result.append("]");
+            return result;
+         }
+      };
+
+      /**
+       * @brief Default constructor
+       */
+      http_router() = default;
+
+      /**
+       * @brief Match a value against a pattern with advanced pattern matching features
+       *
+       * Supports:
+       * - Wildcards (*) for matching any number of characters
+       * - Question marks (?) for matching a single character
+       * - Character classes ([a-z], [^0-9])
+       * - Anchors (^ for start of string, $ for end of string)
+       * - Escape sequences with backslash
+       *
+       * @param value The string to match
+       * @param pattern The pattern to match against
+       * @return true if the value matches the pattern, false otherwise
+       */
+      static bool match_pattern(std::string_view value, std::string_view pattern)
+      {
+         enum struct State { Literal, Escape, CharClass };
+
+         if (pattern.empty()) return true; // Empty pattern matches anything
+
+         size_t v_pos = 0;
+         size_t p_pos = 0;
+
+         // For backtracking when we encounter *
+         std::optional<size_t> backtrack_pattern;
+         std::optional<size_t> backtrack_value;
+
+         // For character classes
+         State state = State::Literal;
+         bool negate_class = false;
+         bool char_class_match = false;
+
+         while (v_pos < value.size() || p_pos < pattern.size()) {
+            // Pattern exhausted but value remains
+            if (p_pos >= pattern.size()) {
+               // Can we backtrack for wildcard?
+               if (backtrack_pattern) {
+                  p_pos = *backtrack_pattern;
+                  v_pos = ++(*backtrack_value);
+                  continue;
+               }
+               return false;
+            }
+
+            // Value exhausted but pattern remains
+            if (v_pos >= value.size()) {
+               // If remaining pattern is just * wildcard, it's a match
+               if (p_pos < pattern.size() && pattern[p_pos] == '*' && p_pos == pattern.size() - 1) return true;
+
+               // Can we backtrack?
+               if (backtrack_pattern) {
+                  p_pos = *backtrack_pattern;
+                  v_pos = ++(*backtrack_value);
+                  continue;
+               }
+               return false;
+            }
+
+            switch (state) {
+            case State::Literal:
+               if (pattern[p_pos] == '\\') {
+                  // Escape sequence
+                  state = State::Escape;
+                  p_pos++;
+                  continue;
+               }
+               else if (pattern[p_pos] == '[') {
+                  // Begin character class
+                  state = State::CharClass;
+                  char_class_match = false;
+                  p_pos++;
+
+                  // Check for negation
+                  if (p_pos < pattern.size() && pattern[p_pos] == '^') {
+                     negate_class = true;
+                     p_pos++;
+                  }
+                  else {
+                     negate_class = false;
+                  }
+                  continue;
+               }
+               else if (pattern[p_pos] == '*') {
+                  // Wildcard - match zero or more chars
+                  backtrack_pattern = p_pos;
+                  backtrack_value = v_pos;
+                  p_pos++;
+                  continue;
+               }
+               else if (pattern[p_pos] == '?') {
+                  // Match any single character
+                  p_pos++;
+                  v_pos++;
+                  continue;
+               }
+               else if (pattern[p_pos] == '^' && p_pos == 0) {
+                  // Beginning of string anchor
+                  p_pos++;
+                  continue;
+               }
+               else if (pattern[p_pos] == '$' && p_pos == pattern.size() - 1) {
+                  // End of string anchor - only matches if we're at the end
+                  return v_pos == value.size();
+               }
+               else {
+                  // Literal character
+                  if (pattern[p_pos] != value[v_pos]) {
+                     // Can we backtrack?
+                     if (backtrack_pattern) {
+                        p_pos = *backtrack_pattern;
+                        v_pos = ++(*backtrack_value);
+                        continue;
+                     }
+                     return false;
+                  }
+                  p_pos++;
+                  v_pos++;
+               }
+               break;
+
+            case State::Escape:
+               // Escaped character - match literally
+               if (p_pos >= pattern.size() || pattern[p_pos] != value[v_pos]) {
+                  // Can we backtrack?
+                  if (backtrack_pattern) {
+                     p_pos = *backtrack_pattern;
+                     v_pos = ++(*backtrack_value);
+                     state = State::Literal;
+                     continue;
+                  }
+                  return false;
+               }
+               p_pos++;
+               v_pos++;
+               state = State::Literal;
+               break;
+
+            case State::CharClass:
+               if (pattern[p_pos] == ']') {
+                  // End of character class
+                  p_pos++;
+                  if (negate_class) {
+                     if (char_class_match) {
+                        // Negated and found a match = fail
+                        return false;
+                     }
+                     v_pos++; // Character not in class
+                  }
+                  else {
+                     if (!char_class_match) {
+                        // Not negated and no match = fail
+                        return false;
+                     }
+                     v_pos++; // Character in class
+                  }
+                  state = State::Literal;
+                  continue;
+               }
+               else if (p_pos + 2 < pattern.size() && pattern[p_pos + 1] == '-') {
+                  // Character range
+                  char start = pattern[p_pos];
+                  char end = pattern[p_pos + 2];
+                  if (value[v_pos] >= start && value[v_pos] <= end) {
+                     char_class_match = true;
+                  }
+                  p_pos += 3; // Skip the range
+               }
+               else {
+                  // Single character in class
+                  if (pattern[p_pos] == value[v_pos]) {
+                     char_class_match = true;
+                  }
+                  p_pos++;
+               }
+               break;
+            }
+         }
+
+         return v_pos == value.size() && p_pos == pattern.size();
+      }
+
+      /**
+       * @brief Split a path into segments
+       *
+       * Splits a path like "/users/:id/profile" into ["users", ":id", "profile"]
+       *
+       * @param path The path to split
+       * @return Vector of path segments
+       */
+      static std::vector<std::string> split_path(std::string_view path)
+      {
+         std::vector<std::string> segments;
+         segments.reserve(std::count(path.begin(), path.end(), '/') + 1);
+
+         size_t start = 0;
+         while (start < path.size()) {
+            if (path[start] == '/') {
+               start++;
+               continue;
+            }
+
+            size_t end = path.find('/', start);
+            if (end == std::string::npos) end = path.size();
+
+            segments.push_back(std::string(path.substr(start, end - start)));
+            start = end;
+         }
+
+         return segments;
+      }
+
+      /**
+       * @brief Register a route with the router
+       *
+       * @param method The HTTP method (GET, POST, etc.)
+       * @param path The route path, can include parameters (":param") and wildcards ("*param")
+       * @param handle The handler function to call when this route matches
+       * @param spec Optional spec for the route.
+       * @return Reference to this router for method chaining
+       * @throws std::runtime_error if there's a route conflict
+       */
+      inline http_router& route(http_method method, std::string_view path, handler handle, const route_spec& spec = {})
+      {
+         std::string path_str(path);
+         try {
+            // Store in the routes map
+            auto& entry = routes[path_str][method];
+            entry.handle = std::move(handle);
+            entry.spec = spec;
+
+            // Also add to the radix tree
+            add_route(method, path, entry.handle, spec.constraints);
+         }
+         catch (const std::exception& e) {
+            // Log the error instead of propagating it
+            std::fprintf(stderr, "Error adding route '%.*s': %s\n", static_cast<int>(path.length()), path.data(),
+                         e.what());
+         }
+         return *this;
+      }
+
+      /**
+       * @brief Register a GET route
+       */
+      inline http_router& get(std::string_view path, handler handle, const route_spec& spec = {})
+      {
+         return route(http_method::GET, path, std::move(handle), spec);
+      }
+
+      /**
+       * @brief Register a POST route
+       */
+      inline http_router& post(std::string_view path, handler handle, const route_spec& spec = {})
+      {
+         return route(http_method::POST, path, std::move(handle), spec);
+      }
+
+      /**
+       * @brief Register a PUT route
+       */
+      inline http_router& put(std::string_view path, handler handle, const route_spec& spec = {})
+      {
+         return route(http_method::PUT, path, std::move(handle), spec);
+      }
+
+      /**
+       * @brief Register a DELETE route
+       */
+      inline http_router& del(std::string_view path, handler handle, const route_spec& spec = {})
+      {
+         return route(http_method::DELETE, path, std::move(handle), spec);
+      }
+
+      /**
+       * @brief Register a PATCH route
+       */
+      inline http_router& patch(std::string_view path, handler handle, const route_spec& spec = {})
+      {
+         return route(http_method::PATCH, path, std::move(handle), spec);
+      }
+
+      /**
+       * @brief Register an asynchronous route
+       */
+      inline http_router& route_async(http_method method, std::string_view path, async_handler handle,
+                                      const route_spec& spec = {})
+      {
+         // Convert async handle to sync handle
+         return route(
+            method, path,
+            [handle](const request& req, response& res) {
+               // Create a future and get the result, which will propagate any exceptions
+               auto future = handle(req, res);
+               future.get(); // This will throw if the async operation threw
+            },
+            spec);
+      }
+
+      /**
+       * @brief Register an asynchronous GET route
+       */
+      inline http_router& get_async(std::string_view path, async_handler handle, const route_spec& spec = {})
+      {
+         return route_async(http_method::GET, path, std::move(handle), spec);
+      }
+
+      /**
+       * @brief Register an asynchronous POST route
+       */
+      inline http_router& post_async(std::string_view path, async_handler handle, const route_spec& spec = {})
+      {
+         return route_async(http_method::POST, path, std::move(handle), spec);
+      }
+
+      /**
+       * @brief Register an asynchronous PUT route
+       */
+      inline http_router& put_async(std::string_view path, async_handler handle, const route_spec& spec = {})
+      {
+         return route_async(http_method::PUT, path, std::move(handle), spec);
+      }
+
+      /**
+       * @brief Register an asynchronous DELETE route
+       */
+      inline http_router& del_async(std::string_view path, async_handler handle, const route_spec& spec = {})
+      {
+         return route_async(http_method::DELETE, path, std::move(handle), spec);
+      }
+
+      /**
+       * @brief Register an asynchronous PATCH route
+       */
+      inline http_router& patch_async(std::string_view path, async_handler handle, const route_spec& spec = {})
+      {
+         return route_async(http_method::PATCH, path, std::move(handle), spec);
+      }
+
+      /**
+       * @brief Register middleware to be executed before route handlers
+       *
+       * Middleware functions are executed in the order they are registered.
+       *
+       * @param middleware The middleware function
+       * @return Reference to this router for method chaining
+       */
+      inline http_router& use(handler middleware)
+      {
+         middlewares.push_back(std::move(middleware));
+         return *this;
+      }
+
+      /**
+       * @brief Match a request against registered routes
+       *
+       * @param method The HTTP method of the request
+       * @param target The target path of the request
+       * @return A pair containing the matched handler and extracted parameters
+       */
+      inline std::pair<handler, std::unordered_map<std::string, std::string>> match(http_method method,
+                                                                                    const std::string& target) const
+      {
+         std::unordered_map<std::string, std::string> params;
+         handler result = nullptr;
+
+         // First try direct lookup for non-parameterized routes (optimization)
+         auto direct_it = direct_routes.find(target);
+         if (direct_it != direct_routes.end()) {
+            auto method_it = direct_it->second.find(method);
+            if (method_it != direct_it->second.end()) {
+               return {method_it->second, params}; // No params for direct match
+            }
+         }
+
+         // Split the target path into segments
+         std::vector<std::string> segments = split_path(target);
+
+         // Use recursive matching function
+         match_node(&root, segments, 0, method, params, result);
+
+         return {result, params};
+      }
+
+      /**
+       * @brief Print the entire router tree structure for debugging
+       */
+      void print_tree() const
+      {
+         std::cout << "Radix Tree Structure:\n";
+         print_node(&root, 0);
+      }
+
+      /**
+       * @brief Map of routes registered with this router
+       *
+       * Used for compatibility with mount functionality.
+       */
+      std::unordered_map<std::string, std::unordered_map<http_method, route_entry>> routes;
+
+      /**
+       * @brief Vector of middleware handlers
+       */
+      std::vector<handler> middlewares;
+
+     private:
+      /**
+       * @brief Root node of the radix tree
+       */
+      mutable RadixNode root;
+
+      /**
+       * @brief Direct lookup table for non-parameterized routes (optimization)
+       */
+      std::unordered_map<std::string, std::unordered_map<http_method, handler>> direct_routes;
+
+      /**
+       * @brief Add a route to the radix tree
+       *
+       * @param method HTTP method for the route
+       * @param path Path pattern for the route
+       * @param handle Handler function for the route
+       * @param constraints Optional parameter constraints
+       * @throws std::runtime_error if there's a route conflict
+       */
+      void add_route(http_method method, std::string_view path, handler handle,
+                     const std::unordered_map<std::string, param_constraint>& constraints = {})
+      {
+         std::string path_str(path);
+
+         // Optimization: for non-parameterized routes, store them directly
+         if (path_str.find(':') == std::string::npos && path_str.find('*') == std::string::npos) {
+            // Check for conflicts first
+            auto& method_handlers = direct_routes[path_str];
+            if (method_handlers.find(method) != method_handlers.end()) {
+               throw std::runtime_error("Route conflict: handler already exists for " + std::string(to_string(method)) +
+                                        " " + path_str);
+            }
+
+            // Store the route directly
+            method_handlers[method] = handle;
+            return;
+         }
+
+         // For parameterized routes, use the radix tree
+         std::vector<std::string> segments = split_path(path);
+
+         // Start at the root node
+         RadixNode* current = &root;
+
+         // Build the path through the tree
+         for (size_t i = 0; i < segments.size(); ++i) {
+            const std::string& segment = segments[i];
+
+            if (segment.empty()) continue;
+
+            if (segment[0] == ':') {
+               // Parameter segment
+               std::string param_name = segment.substr(1);
+
+               if (!current->parameter_child) {
+                  current->parameter_child = std::make_unique<RadixNode>();
+                  current->parameter_child->is_parameter = true;
+                  current->parameter_child->parameter_name = param_name;
+                  current->parameter_child->segment = segment;
+
+                  // Build the full path for debugging/conflict detection
+                  current->parameter_child->full_path = current->full_path + "/" + segment;
+               }
+               else if (current->parameter_child->parameter_name != param_name) {
+                  // Parameter name conflict
+                  throw std::runtime_error("Route conflict: different parameter names at same position: :" +
+                                           current->parameter_child->parameter_name + " vs :" + param_name);
+               }
+
+               current = current->parameter_child.get();
+            }
+            else if (segment[0] == '*') {
+               // Wildcard segment
+               std::string wildcard_name = segment.substr(1);
+
+               // Wildcards must be at the end of the route
+               if (i != segments.size() - 1) {
+                  throw std::runtime_error("Wildcard must be the last segment in route: " + path_str);
+               }
+
+               if (!current->wildcard_child) {
+                  current->wildcard_child = std::make_unique<RadixNode>();
+                  current->wildcard_child->is_wildcard = true;
+                  current->wildcard_child->parameter_name = wildcard_name;
+                  current->wildcard_child->segment = segment;
+
+                  // Build the full path for debugging/conflict detection
+                  current->wildcard_child->full_path = current->full_path + "/" + segment;
+               }
+               else if (current->wildcard_child->parameter_name != wildcard_name) {
+                  // Wildcard name conflict
+                  throw std::runtime_error("Route conflict: different wildcard names at same position: *" +
+                                           current->wildcard_child->parameter_name + " vs *" + wildcard_name);
+               }
+
+               current = current->wildcard_child.get();
+               break; // Wildcard is always the last segment
+            }
+            else {
+               // Static segment
+               if (current->static_children.find(segment) == current->static_children.end()) {
+                  current->static_children[segment] = std::make_unique<RadixNode>();
+                  current->static_children[segment]->segment = segment;
+
+                  // Build the full path for debugging/conflict detection
+                  current->static_children[segment]->full_path = current->full_path + "/" + segment;
+               }
+
+               current = current->static_children[segment].get();
+            }
+         }
+
+         // Check for route conflict
+         if (current->is_endpoint && current->handlers.find(method) != current->handlers.end()) {
+            throw std::runtime_error("Route conflict: handler already exists for " + std::string(to_string(method)) +
+                                     " " + path_str);
+         }
+
+         // Mark as endpoint and set handler
+         current->is_endpoint = true;
+         current->handlers[method] = handle;
+
+         // Store constraints (if any)
+         if (!constraints.empty()) {
+            current->constraints[method] = constraints;
+         }
+      }
+
+      /**
+       * @brief Match a path against the radix tree
+       *
+       * Recursive function to match a path against the tree and extract parameters.
+       *
+       * @param node Current node in the tree
+       * @param segments Path segments to match
+       * @param index Current segment index
+       * @param method HTTP method to match
+       * @param params Map to store extracted parameters
+       * @param result Handler if a match is found
+       * @return true if a match was found, false otherwise
+       */
+      bool match_node(RadixNode* node, const std::vector<std::string>& segments, size_t index, http_method method,
+                      std::unordered_map<std::string, std::string>& params, handler& result) const
+      {
+         // End of path
+         if (index == segments.size()) {
+            if (node->is_endpoint) {
+               auto it = node->handlers.find(method);
+               if (it != node->handlers.end()) {
+                  // Validate constraints if any before setting the handler
+                  bool constraints_passed = true;
+                  auto constraints_it = node->constraints.find(method);
+                  if (constraints_it != node->constraints.end()) {
+                     for (const auto& [param_name, constraint] : constraints_it->second) {
+                        auto param_it = params.find(param_name);
+                        if (param_it != params.end()) {
+                           const std::string& value = param_it->second;
+
+                           // Use the validation function
+                           if (!constraint.validation(value)) {
+                              constraints_passed = false;
+                              break; // Validation failed
+                           }
+                        }
+                     }
+                  }
+
+                  if (constraints_passed) {
+                     // Only set the handler if constraints pass
+                     result = it->second;
+                     return true;
+                  }
+                  return false;
+               }
+            }
+            return false;
+         }
+
+         const std::string& segment = segments[index];
+
+         // Try static match first (most specific)
+         auto static_it = node->static_children.find(segment);
+         if (static_it != node->static_children.end()) {
+            if (match_node(static_it->second.get(), segments, index + 1, method, params, result)) {
+               return true;
+            }
+         }
+
+         // Try parameter match (less specific than static)
+         if (node->parameter_child) {
+            // Save parameter value
+            std::string param_name = node->parameter_child->parameter_name;
+            params[param_name] = segment;
+
+            if (match_node(node->parameter_child.get(), segments, index + 1, method, params, result)) {
+               return true;
+            }
+
+            // If this parameter didn't lead to a match, remove it
+            params.erase(param_name);
+         }
+
+         // Try wildcard match (least specific)
+         if (node->wildcard_child) {
+            // For wildcards, capture all remaining segments
+            std::string full_capture;
+            for (size_t i = index; i < segments.size(); i++) {
+               if (i > index) full_capture += "/";
+               full_capture += segments[i];
+            }
+
+            params[node->wildcard_child->parameter_name] = full_capture;
+
+            // Wildcards always go to the endpoint of their node
+            if (node->wildcard_child->is_endpoint) {
+               auto it = node->wildcard_child->handlers.find(method);
+               if (it != node->wildcard_child->handlers.end()) {
+                  // Validate constraints for the wildcard before setting the handler
+                  bool constraints_passed = true;
+                  auto constraints_it = node->wildcard_child->constraints.find(method);
+                  if (constraints_it != node->wildcard_child->constraints.end()) {
+                     for (const auto& [param_name, constraint] : constraints_it->second) {
+                        auto param_it = params.find(param_name);
+                        if (param_it != params.end()) {
+                           const std::string& value = param_it->second;
+
+                           // Use the validation function
+                           if (!constraint.validation(value)) {
+                              constraints_passed = false;
+                              break; // Validation failed
+                           }
+                        }
+                     }
+                  }
+
+                  if (constraints_passed) {
+                     // Only set the handler if constraints pass
+                     result = it->second;
+                     return true;
+                  }
+                  return false;
+               }
+            }
+         }
+
+         return false;
+      }
+
+      /**
+       * @brief Print a node in the radix tree (for debugging)
+       *
+       * @param node The node to print
+       * @param depth Current depth in the tree (for indentation)
+       */
+      void print_node(const RadixNode* node, int depth) const
+      {
+         if (!node) return;
+
+         std::string indent(depth * 2, ' ');
+         std::cout << indent << node->to_string() << "\n";
+
+         // Print all handlers for this node
+         if (node->is_endpoint) {
+            std::cout << indent << "  Handlers: ";
+            for (const auto& [method, _] : node->handlers) {
+               std::cout << to_string(method) << " ";
+            }
+            std::cout << "\n";
+
+            // Print constraints if any
+            for (const auto& [method, method_constraints] : node->constraints) {
+               std::cout << indent << "  Constraints for " << to_string(method) << ":\n";
+               for (const auto& [param, constraint] : method_constraints) {
+                  std::cout << indent << "    " << param << ": (" << constraint.description << ")\n";
+               }
+            }
+         }
+
+         // Print children
+         for (const auto& [segment, child] : node->static_children) {
+            print_node(child.get(), depth + 1);
+         }
+
+         if (node->parameter_child) {
+            print_node(node->parameter_child.get(), depth + 1);
+         }
+
+         if (node->wildcard_child) {
+            print_node(node->wildcard_child.get(), depth + 1);
+         }
+      }
+   };
+}
diff --git a/deps/saucer/include/glaze/net/http_server.hpp b/deps/saucer/include/glaze/net/http_server.hpp
new file mode 100644
index 0000000..2ee1dbe
--- /dev/null
+++ b/deps/saucer/include/glaze/net/http_server.hpp
@@ -0,0 +1,1287 @@
+// Glaze Library
+// For the license information refer to glaze.hpp
+
+#pragma once
+
+#include <atomic>
+#include <charconv>
+#include <chrono>
+#include <expected>
+#include <functional>
+#include <future>
+#include <glaze/glaze.hpp>
+#include <source_location>
+#include <thread>
+#include <unordered_map>
+
+#include "glaze/net/cors.hpp"
+#include "glaze/net/http_router.hpp"
+#include "glaze/net/openapi.hpp"
+#include "glaze/net/websocket_connection.hpp"
+
+// Conditionally include SSL headers only when needed
+#ifdef GLZ_ENABLE_SSL
+#include <asio/ssl.hpp>
+#endif
+
+// To deconflict Windows.h
+#ifdef DELETE
+#undef DELETE
+#endif
+
+namespace glz
+{
+   // Streaming connection handle for server-side streaming
+   struct streaming_connection : public std::enable_shared_from_this<streaming_connection>
+   {
+      using data_sent_handler = std::function<void(std::error_code)>;
+      using disconnect_handler = std::function<void()>;
+
+      streaming_connection(std::shared_ptr<asio::ip::tcp::socket> socket)
+         : socket_(socket), is_headers_sent_(false), is_closed_(false)
+      {}
+
+      // Send initial headers for streaming response
+      void send_headers(int status_code, const std::unordered_map<std::string, std::string>& headers = {},
+                        data_sent_handler handler = {})
+      {
+         if (is_headers_sent_) return;
+         is_headers_sent_ = true;
+
+         std::string response_str;
+         response_str.reserve(512);
+
+         response_str.append("HTTP/1.1 ");
+         response_str.append(std::to_string(status_code));
+         response_str.append(" ");
+         response_str.append(get_status_message(status_code));
+         response_str.append("\r\n");
+
+         // Add custom headers
+         for (const auto& [name, value] : headers) {
+            response_str.append(name);
+            response_str.append(": ");
+            response_str.append(value);
+            response_str.append("\r\n");
+         }
+
+         // Default headers for streaming
+         if (headers.find("Transfer-Encoding") == headers.end()) {
+            response_str.append("Transfer-Encoding: chunked\r\n");
+            chunked_encoding_ = true;
+         }
+         if (headers.find("Connection") == headers.end()) {
+            response_str.append("Connection: keep-alive\r\n");
+         }
+         if (headers.find("Cache-Control") == headers.end()) {
+            response_str.append("Cache-Control: no-cache\r\n");
+         }
+
+         response_str.append("\r\n");
+
+         auto buffer = std::make_shared<std::string>(std::move(response_str));
+         auto self = shared_from_this();
+
+         asio::async_write(*socket_, asio::buffer(*buffer), [self, buffer, handler](std::error_code ec, std::size_t) {
+            if (handler) handler(ec);
+         });
+      }
+
+      // Send a chunk of data
+      void send_chunk(std::string_view data, data_sent_handler handler = {})
+      {
+         if (is_closed_) return;
+
+         auto self = shared_from_this();
+
+         if (chunked_encoding_) {
+            // Format as HTTP chunk
+            std::string chunk;
+            chunk.reserve(data.size() + 20); // 20 is a good estimate for hex size + CRLFs
+
+            // Chunk size in hex, converted efficiently with std::to_chars
+            std::array<char, 16> size_buf{}; // 64-bit size_t in hex is at most 16 chars
+            if (auto [ptr, ec] = std::to_chars(size_buf.data(), size_buf.data() + size_buf.size(), data.size(), 16);
+                ec == std::errc()) {
+               chunk.append(std::string_view(size_buf.data(), ptr - size_buf.data()));
+            }
+            chunk.append("\r\n");
+            chunk.append(data);
+            chunk.append("\r\n");
+
+            auto buffer = std::make_shared<std::string>(std::move(chunk));
+            asio::async_write(*socket_, asio::buffer(*buffer),
+                              [self, buffer, handler](std::error_code ec, std::size_t) {
+                                 if (handler) handler(ec);
+                              });
+         }
+         else {
+            // Send raw data
+            auto buffer = std::make_shared<std::string>(data);
+            asio::async_write(*socket_, asio::buffer(*buffer),
+                              [self, buffer, handler](std::error_code ec, std::size_t) {
+                                 if (handler) handler(ec);
+                              });
+         }
+      }
+
+      // Send Server-Sent Event
+      void send_event(std::string_view event_type, std::string_view data, std::string_view id = {},
+                      data_sent_handler handler = {})
+      {
+         std::string sse_data;
+         sse_data.reserve(data.size() + 50);
+
+         if (!id.empty()) {
+            sse_data.append("id: ");
+            sse_data.append(id);
+            sse_data.append("\n");
+         }
+
+         if (!event_type.empty()) {
+            sse_data.append("event: ");
+            sse_data.append(event_type);
+            sse_data.append("\n");
+         }
+
+         sse_data.append("data: ");
+         sse_data.append(data);
+         sse_data.append("\n\n");
+
+         send_chunk(sse_data, handler);
+      }
+
+      // Send JSON as Server-Sent Event
+      template <class T>
+      void send_json_event(const T& data, std::string_view event_type = "message", std::string_view id = {},
+                           data_sent_handler handler = {})
+      {
+         std::string json_str;
+         auto ec = glz::write_json(data, json_str);
+         if (!ec) {
+            send_event(event_type, json_str, id, handler);
+         }
+         else if (handler) {
+            handler(std::make_error_code(std::errc::invalid_argument));
+         }
+      }
+
+      // Close the streaming connection
+      void close(disconnect_handler handler = {})
+      {
+         if (is_closed_) return;
+         is_closed_ = true;
+
+         auto self = shared_from_this();
+
+         if (chunked_encoding_) {
+            // Send final chunk
+            std::string final_chunk = "0\r\n\r\n";
+            auto buffer = std::make_shared<std::string>(std::move(final_chunk));
+
+            asio::async_write(*socket_, asio::buffer(*buffer), [self, buffer, handler](asio::error_code, std::size_t) {
+               if (handler) handler();
+               asio::error_code close_ec;
+               self->socket_->close(close_ec);
+            });
+         }
+         else {
+            if (handler) handler();
+            asio::error_code ec;
+            socket_->close(ec);
+         }
+      }
+
+      // Set disconnect handler for client disconnection
+      void on_disconnect(disconnect_handler handler)
+      {
+         disconnect_handler_ = handler;
+         start_disconnect_detection();
+      }
+
+      // Check if connection is still alive
+      bool is_open() const { return socket_ && socket_->is_open() && !is_closed_; }
+
+      // Get remote endpoint info
+      std::string remote_address() const
+      {
+         if (socket_) {
+            try {
+               return socket_->remote_endpoint().address().to_string();
+            }
+            catch (...) {
+            }
+         }
+         return "";
+      }
+
+      uint16_t remote_port() const
+      {
+         if (socket_) {
+            try {
+               return socket_->remote_endpoint().port();
+            }
+            catch (...) {
+            }
+         }
+         return 0;
+      }
+
+      bool is_headers_sent() const { return is_headers_sent_; }
+
+      std::shared_ptr<asio::ip::tcp::socket> socket_;
+
+     private:
+      disconnect_handler disconnect_handler_;
+      bool is_headers_sent_;
+      bool is_closed_;
+      bool chunked_encoding_ = false;
+
+      void start_disconnect_detection()
+      {
+         if (!socket_ || is_closed_) return;
+
+         auto self = shared_from_this();
+         auto buffer = std::make_shared<std::array<uint8_t, 1>>();
+
+         // Try to read - will fail when client disconnects
+         socket_->async_receive(
+            asio::buffer(*buffer), asio::socket_base::message_peek, [self, buffer](std::error_code ec, std::size_t) {
+               if (ec && self->disconnect_handler_) {
+                  self->is_closed_ = true;
+                  self->disconnect_handler_();
+               }
+               else if (!ec && !self->is_closed_) {
+                  // Continue monitoring
+                  auto timer = std::make_shared<asio::steady_timer>(self->socket_->get_executor());
+                  timer->expires_after(std::chrono::seconds(1));
+                  timer->async_wait([self, timer](std::error_code) { self->start_disconnect_detection(); });
+               }
+            });
+      }
+
+      std::string_view get_status_message(int status_code)
+      {
+         switch (status_code) {
+         case 200:
+            return "OK";
+         case 201:
+            return "Created";
+         case 204:
+            return "No Content";
+         case 400:
+            return "Bad Request";
+         case 401:
+            return "Unauthorized";
+         case 403:
+            return "Forbidden";
+         case 404:
+            return "Not Found";
+         case 500:
+            return "Internal Server Error";
+         default:
+            return "Unknown";
+         }
+      }
+   };
+
+   // Enhanced response class with streaming support
+   struct streaming_response
+   {
+      std::shared_ptr<streaming_connection> stream;
+
+      streaming_response(std::shared_ptr<streaming_connection> conn) : stream(conn) {}
+
+      // Send headers and start streaming
+      streaming_response& start_stream(int status_code = 200,
+                                       const std::unordered_map<std::string, std::string>& headers = {})
+      {
+         if (stream) {
+            stream->send_headers(status_code, headers);
+         }
+         return *this;
+      }
+
+      // Send a chunk of data
+      streaming_response& send(std::string_view data)
+      {
+         if (stream) {
+            stream->send_chunk(data);
+         }
+         return *this;
+      }
+
+      // Send JSON data
+      template <class T>
+      streaming_response& send_json(const T& data)
+      {
+         if (stream) {
+            std::string json_str;
+            auto ec = glz::write_json(data, json_str);
+            if (!ec) {
+               stream->send_chunk(json_str);
+            }
+         }
+         return *this;
+      }
+
+      // Send Server-Sent Event
+      streaming_response& send_event(std::string_view event_type, std::string_view data, std::string_view id = {})
+      {
+         if (stream) {
+            stream->send_event(event_type, data, id);
+         }
+         return *this;
+      }
+
+      // Helper for SSE setup
+      streaming_response& as_event_stream()
+      {
+         return start_stream(200, {{"Content-Type", "text/event-stream"},
+                                   {"Cache-Control", "no-cache"},
+                                   {"Access-Control-Allow-Origin", "*"}});
+      }
+
+      // Close the stream
+      void close()
+      {
+         if (stream) {
+            stream->close();
+         }
+      }
+   };
+
+   // Handler types for streaming
+   using streaming_handler = std::function<void(request&, streaming_response&)>;
+
+   // Server implementation using non-blocking asio with WebSocket support
+   template <bool EnableTLS = false>
+   struct http_server
+   {
+      // Socket type abstraction
+      using socket_type = std::conditional_t<EnableTLS,
+#ifdef GLZ_ENABLE_SSL
+                                             asio::ssl::stream<asio::ip::tcp::socket>,
+#else
+                                             asio::ip::tcp::socket,
+#endif
+                                             asio::ip::tcp::socket>;
+
+      inline http_server() : io_context(std::make_unique<asio::io_context>())
+      {
+         error_handler = [](std::error_code ec, std::source_location loc) {
+            std::fprintf(stderr, "Error at %s:%d: %s\n", loc.file_name(), static_cast<int>(loc.line()),
+                         ec.message().c_str());
+         };
+
+         // Initialize SSL context for TLS-enabled servers
+         if constexpr (EnableTLS) {
+#ifdef GLZ_ENABLE_SSL
+            ssl_context = std::make_unique<asio::ssl::context>(asio::ssl::context::tlsv12);
+            ssl_context->set_default_verify_paths();
+#else
+            static_assert(!EnableTLS, "TLS support requires GLZ_ENABLE_SSL to be defined and OpenSSL to be available");
+#endif
+         }
+      }
+
+      inline ~http_server()
+      {
+         if (running) {
+            stop();
+         }
+      }
+
+      inline http_server& bind(std::string_view address, uint16_t port)
+      {
+         try {
+            asio::ip::tcp::endpoint endpoint(asio::ip::make_address(address), port);
+            acceptor = std::make_unique<asio::ip::tcp::acceptor>(*io_context, endpoint);
+         }
+         catch (...) {
+            error_handler(std::make_error_code(std::errc::address_in_use), std::source_location::current());
+         }
+         return *this;
+      }
+
+      inline http_server& bind(uint16_t port) { return bind("0.0.0.0", port); }
+
+      inline void start(size_t num_threads = 0)
+      {
+         if (running || !acceptor) {
+            return;
+         }
+
+         running = true;
+
+         // Use hardware concurrency if not specified
+         if (num_threads == 0) {
+            num_threads = std::thread::hardware_concurrency();
+         }
+
+         // Start the acceptor
+         do_accept();
+
+         // Start worker threads
+         threads.reserve(num_threads);
+         for (size_t i = 0; i < num_threads; ++i) {
+            threads.emplace_back([this] {
+               try {
+                  io_context->run();
+               }
+               catch (const std::exception& e) {
+                  error_handler(std::make_error_code(std::errc::operation_canceled), std::source_location::current());
+               }
+            });
+         }
+      }
+
+      inline void stop()
+      {
+         if (!running) {
+            return;
+         }
+
+         running = false;
+
+         // Stop accepting new connections
+         if (acceptor) {
+            acceptor->close();
+         }
+
+         // Stop the io_context and join all threads
+         io_context->stop();
+
+         for (auto& thread : threads) {
+            if (thread.joinable()) {
+               thread.join();
+            }
+         }
+
+         threads.clear();
+
+         // Reset for potential restart
+         io_context = std::make_unique<asio::io_context>();
+      }
+
+      inline http_server& mount(std::string_view base_path, const http_router& router)
+      {
+         // Mount all routes from the router at the specified base path
+         for (const auto& [path, method_handlers] : router.routes) {
+            std::string full_path = std::string(base_path);
+            if (!full_path.empty() && full_path.back() == '/') {
+               full_path.pop_back();
+            }
+            full_path += path;
+
+            for (const auto& [method, route_entry] : method_handlers) {
+               root_router.route(method, full_path, route_entry.handle, route_entry.spec);
+            }
+         }
+
+         // Add middleware
+         for (const auto& middleware : router.middlewares) {
+            root_router.use(middleware);
+         }
+
+         return *this;
+      }
+
+      inline http_router& route(http_method method, std::string_view path, handler handle, const route_spec& spec = {})
+      {
+         return root_router.route(method, path, handle, spec);
+      }
+
+      inline http_router& get(std::string_view path, handler handle, const route_spec& spec = {})
+      {
+         return root_router.get(path, handle, spec);
+      }
+
+      inline http_router& post(std::string_view path, handler handle, const route_spec& spec = {})
+      {
+         return root_router.post(path, handle, spec);
+      }
+
+      inline http_router& put(std::string_view path, handler handle, const route_spec& spec = {})
+      {
+         return root_router.put(path, handle, spec);
+      }
+
+      inline http_router& del(std::string_view path, handler handle, const route_spec& spec = {})
+      {
+         return root_router.del(path, handle, spec);
+      }
+
+      inline http_router& patch(std::string_view path, handler handle, const route_spec& spec = {})
+      {
+         return root_router.patch(path, handle, spec);
+      }
+
+      // Register streaming route
+      inline http_server& stream(http_method method, std::string_view path, streaming_handler handle)
+      {
+         streaming_handlers_[std::string(path)][method] = std::move(handle);
+         return *this;
+      }
+
+      // Convenience methods for streaming
+      inline http_server& stream_get(std::string_view path, streaming_handler handle)
+      {
+         return stream(http_method::GET, path, std::move(handle));
+      }
+
+      inline http_server& stream_post(std::string_view path, streaming_handler handle)
+      {
+         return stream(http_method::POST, path, std::move(handle));
+      }
+
+      inline http_server& on_error(error_handler handle)
+      {
+         error_handler = std::move(handle);
+         return *this;
+      }
+
+      /**
+       * @brief Enable API inspection by exposing an OpenAPI 3.0 specification.
+       *
+       * This provides a standard, machine-readable way for clients to discover the API.
+       *
+       * @param path The path to expose the OpenAPI JSON specification on.
+       * @param title The title of the API.
+       * @param version The version of the API.
+       * @return Reference to this server for method chaining.
+       */
+      http_server& enable_openapi_spec(std::string_view path = "/openapi.json",
+                                       std::string_view title = "API Specification", std::string_view version = "1.0.0")
+      {
+         get(path, [this, title = std::string(title), version = std::string(version)](const request&, response& res) {
+            open_api spec{};
+            spec.info.title = title;
+            spec.info.version = version;
+
+            for (const auto& [route_path, method_handlers] : root_router.routes) {
+               // Convert router path /:param to OpenAPI path /{param}
+               std::string openapi_path = route_path;
+               size_t pos = 0;
+               while ((pos = openapi_path.find(':', pos)) != std::string::npos) {
+                  openapi_path.replace(pos, 1, "{");
+                  size_t end_pos = openapi_path.find('/', pos);
+                  if (end_pos == std::string::npos) {
+                     openapi_path.push_back('}');
+                  }
+                  else {
+                     openapi_path.insert(end_pos, "}");
+                  }
+               }
+
+               auto& path_item = spec.paths[openapi_path];
+
+               for (const auto& [method, route_entry] : method_handlers) {
+                  openapi_operation op;
+                  op.summary = route_entry.spec.description;
+                  if (!route_entry.spec.tags.empty()) {
+                     op.tags = route_entry.spec.tags;
+                  }
+                  op.operationId = std::string(to_string(method)) + route_path;
+                  op.responses["200"].description = "OK";
+
+                  // Add request body schema
+                  if (route_entry.spec.request_body_schema) {
+                     openapi_request_body req_body;
+                     req_body.required = true;
+                     if (auto schema_val =
+                            glz::read_json<glz::detail::schematic>(*route_entry.spec.request_body_schema)) {
+                        req_body.content["application/json"].schema = *schema_val;
+                     }
+                     op.requestBody = req_body;
+
+                     // Add schema to components
+                     if (!spec.components) spec.components.emplace();
+                     if (!spec.components->schemas) spec.components->schemas.emplace();
+                     if (auto schema_val =
+                            glz::read_json<glz::detail::schematic>(*route_entry.spec.request_body_schema)) {
+                        spec.components->schemas->operator[](*route_entry.spec.request_body_type_name) = *schema_val;
+                     }
+                  }
+
+                  // Add response schema
+                  if (route_entry.spec.response_schema) {
+                     openapi_response res_obj;
+                     res_obj.description = "Successful response";
+                     res_obj.content.emplace(); // Emplace the unordered_map
+                     if (auto schema_val = glz::read_json<glz::detail::schematic>(*route_entry.spec.response_schema)) {
+                        res_obj.content.value()["application/json"].schema = *schema_val;
+                     }
+                     op.responses["200"] = res_obj;
+
+                     // Add schema to components
+                     if (!spec.components) spec.components.emplace();
+                     if (!spec.components->schemas) spec.components->schemas.emplace();
+                     if (auto schema_val = glz::read_json<glz::detail::schematic>(*route_entry.spec.response_schema)) {
+                        spec.components->schemas->operator[](*route_entry.spec.response_type_name) = *schema_val;
+                     }
+                  }
+
+                  // Extract path parameters
+                  auto segments = http_router::split_path(route_path);
+                  for (const auto& segment : segments) {
+                     if (!segment.empty() && segment.front() == ':') {
+                        if (!op.parameters) op.parameters.emplace();
+                        auto& param = op.parameters->emplace_back();
+                        param.name = segment.substr(1);
+                        param.in = "path";
+                        param.required = true;
+                        if (auto it = route_entry.spec.constraints.find(param.name);
+                            it != route_entry.spec.constraints.end()) {
+                           param.description = it->second.description;
+                        }
+                     }
+                  }
+
+                  switch (method) {
+                  case http_method::GET:
+                     path_item.get = op;
+                     break;
+                  case http_method::POST:
+                     path_item.post = op;
+                     break;
+                  case http_method::PUT:
+                     path_item.put = op;
+                     break;
+                  case http_method::DELETE:
+                     path_item.del = op;
+                     break;
+                  case http_method::PATCH:
+                     path_item.patch = op;
+                     break;
+                  default:
+                     break;
+                  }
+               }
+            }
+            res.json(spec);
+         });
+         return *this;
+      }
+
+      /**
+       * @brief Enable CORS with default configuration (allows all origins)
+       *
+       * This is suitable for development environments
+       *
+       * @return Reference to this server for method chaining
+       */
+      http_server& enable_cors()
+      {
+         root_router.use(glz::simple_cors());
+         return *this;
+      }
+
+      /**
+       * @brief Enable CORS with custom configuration
+       *
+       * @param config The CORS configuration to use
+       * @return Reference to this server for method chaining
+       */
+      http_server& enable_cors(const glz::cors_config& config)
+      {
+         root_router.use(glz::create_cors_middleware(config));
+         return *this;
+      }
+
+      /**
+       * @brief Enable CORS for specific origins
+       *
+       * This is suitable for production environments where you want to restrict
+       * which origins can access your API
+       *
+       * @param origins Vector of allowed origins (e.g., {"https://example.com", "https://app.example.com"})
+       * @param allow_credentials Whether to allow credentials (cookies, auth headers)
+       * @return Reference to this server for method chaining
+       */
+      http_server& enable_cors(const std::vector<std::string>& origins, bool allow_credentials = false)
+      {
+         root_router.use(glz::restrictive_cors(origins, allow_credentials));
+         return *this;
+      }
+
+      /**
+       * @brief Register a WebSocket handler for a specific path
+       *
+       * @param path The path to handle WebSocket connections on
+       * @param server The WebSocket server instance to handle connections
+       * @return Reference to this http_server for method chaining
+       */
+      inline http_server& websocket(std::string_view path, std::shared_ptr<websocket_server> server)
+      {
+         websocket_handlers_[std::string(path)] = server;
+         return *this;
+      }
+
+      /**
+       * @brief Load SSL certificate and private key for HTTPS servers
+       *
+       * @param cert_file Path to the certificate file (PEM format)
+       * @param key_file Path to the private key file (PEM format)
+       * @return Reference to this server for method chaining
+       */
+      inline http_server& load_certificate(const std::string& cert_file, const std::string& key_file)
+      {
+         if constexpr (EnableTLS) {
+#ifdef GLZ_ENABLE_SSL
+            ssl_context->use_certificate_chain_file(cert_file);
+            ssl_context->use_private_key_file(key_file, asio::ssl::context::pem);
+#endif
+         }
+         else {
+            (void)cert_file;
+            (void)key_file;
+         }
+         return *this;
+      }
+
+      /**
+       * @brief Set SSL verification mode
+       *
+       * @param mode SSL verification mode
+       * @return Reference to this server for method chaining
+       */
+      inline http_server& set_ssl_verify_mode([[maybe_unused]] int mode)
+      {
+         if constexpr (EnableTLS) {
+#ifdef GLZ_ENABLE_SSL
+            ssl_context->set_verify_mode(mode);
+#endif
+         }
+         return *this;
+      }
+
+     private:
+      std::unique_ptr<asio::io_context> io_context;
+      std::unique_ptr<asio::ip::tcp::acceptor> acceptor;
+      std::vector<std::thread> threads;
+      http_router root_router;
+      bool running = false;
+      glz::error_handler error_handler;
+      std::unordered_map<std::string, std::shared_ptr<websocket_server>> websocket_handlers_;
+      std::unordered_map<std::string, std::unordered_map<http_method, streaming_handler>> streaming_handlers_;
+
+#ifdef GLZ_ENABLE_SSL
+      std::conditional_t<EnableTLS, std::unique_ptr<asio::ssl::context>, std::monostate> ssl_context;
+#endif
+
+      inline void do_accept()
+      {
+         acceptor->async_accept([this](std::error_code ec, asio::ip::tcp::socket socket) {
+            if (!ec) {
+               // Process the connection
+               process_request(std::move(socket));
+            }
+            else {
+               error_handler(ec, std::source_location::current());
+            }
+
+            // Continue accepting if still running
+            if (running) {
+               do_accept();
+            }
+         });
+      }
+
+      inline void process_request(asio::ip::tcp::socket socket)
+      {
+         // Capture socket in a shared_ptr for async operations
+         auto socket_ptr = std::make_shared<asio::ip::tcp::socket>(std::move(socket));
+         auto remote_endpoint = socket_ptr->remote_endpoint();
+         auto buffer = std::make_shared<asio::streambuf>();
+
+         asio::async_read_until(
+            *socket_ptr, *buffer, "\r\n\r\n",
+            [this, socket_ptr, buffer, remote_endpoint](asio::error_code ec, std::size_t /*bytes_transferred*/) {
+               if (ec) {
+                  // EOF is a normal disconnect, not a server error
+                  if (ec != asio::error::eof) {
+                     error_handler(ec, std::source_location::current());
+                  }
+                  return;
+               }
+
+               const auto data_size = buffer->size();
+               const char* data_ptr = static_cast<const char*>(buffer->data().data());
+               std::string_view request_view(data_ptr, data_size);
+
+               size_t headers_end_pos = request_view.find("\r\n\r\n");
+               if (headers_end_pos == std::string_view::npos) {
+                  send_error_response(socket_ptr, 400, "Bad Request");
+                  return;
+               }
+               std::string_view headers_part = request_view.substr(0, headers_end_pos);
+               size_t body_start_offset = headers_end_pos + 4;
+
+               // Parse request line
+               size_t request_line_end_pos = headers_part.find("\r\n");
+               if (request_line_end_pos == std::string_view::npos) {
+                  request_line_end_pos = headers_part.length();
+               }
+               std::string_view request_line = headers_part.substr(0, request_line_end_pos);
+               headers_part.remove_prefix(request_line_end_pos + 2); // +2 for \r\n
+
+               // Parse method, target, and HTTP version from the request line
+               size_t first_space = request_line.find(' ');
+               if (first_space == std::string_view::npos) {
+                  send_error_response(socket_ptr, 400, "Bad Request");
+                  return;
+               }
+               std::string_view method_sv = request_line.substr(0, first_space);
+               if (method_sv.empty() || !std::all_of(method_sv.begin(), method_sv.end(),
+                                                     [](char c) { return std::isalnum(c) || c == '_'; })) {
+                  send_error_response(socket_ptr, 400, "Bad Request");
+                  return;
+               }
+
+               size_t second_space = request_line.find(' ', first_space + 1);
+               if (second_space == std::string_view::npos) {
+                  send_error_response(socket_ptr, 400, "Bad Request");
+                  return;
+               }
+               std::string_view target_sv = request_line.substr(first_space + 1, second_space - first_space - 1);
+               if (target_sv.empty() || target_sv.find(' ') != std::string_view::npos) {
+                  send_error_response(socket_ptr, 400, "Bad Request");
+                  return;
+               }
+
+               std::string_view http_version_part = request_line.substr(second_space + 1);
+               if (http_version_part.size() > 0 && http_version_part.back() == '\r') {
+                  http_version_part.remove_suffix(1);
+               }
+               if (http_version_part.size() < 7 || http_version_part.rfind("HTTP/", 0) != 0) {
+                  send_error_response(socket_ptr, 400, "Bad Request");
+                  return;
+               }
+               std::string_view version_number = http_version_part.substr(5);
+               size_t dot_pos = version_number.find('.');
+               if (dot_pos == std::string_view::npos || dot_pos == 0 || dot_pos == version_number.length() - 1) {
+                  send_error_response(socket_ptr, 400, "Bad Request");
+                  return;
+               }
+               std::string_view major_v = version_number.substr(0, dot_pos);
+               std::string_view minor_v = version_number.substr(dot_pos + 1);
+               if (major_v.empty() || !std::all_of(major_v.begin(), major_v.end(), ::isdigit) || minor_v.empty() ||
+                   !std::all_of(minor_v.begin(), minor_v.end(), ::isdigit)) {
+                  send_error_response(socket_ptr, 400, "Bad Request");
+                  return;
+               }
+
+               auto method_opt = from_string(std::string(method_sv));
+               if (!method_opt) {
+                  send_error_response(socket_ptr, 501, "Not Implemented");
+                  return;
+               }
+               std::string target{target_sv};
+
+               // Parse headers
+               std::unordered_map<std::string, std::string> headers;
+               while (!headers_part.empty()) {
+                  size_t line_end = headers_part.find("\r\n");
+                  std::string_view line = headers_part.substr(0, line_end);
+
+                  auto colon_pos = line.find(':');
+                  if (colon_pos != std::string_view::npos) {
+                     std::string_view name_sv = line.substr(0, colon_pos);
+                     std::string_view value_sv = line.substr(colon_pos + 1);
+                     value_sv.remove_prefix(std::min(value_sv.find_first_not_of(" \t"), value_sv.size()));
+                     std::string name(name_sv);
+                     std::transform(name.begin(), name.end(), name.begin(), ::tolower);
+                     headers[name] = std::string(value_sv);
+                  }
+
+                  if (line_end == std::string_view::npos) break;
+                  headers_part.remove_prefix(line_end + 2);
+               }
+
+               // Consume the parsed headers from the buffer
+               buffer->consume(body_start_offset);
+
+               if (is_websocket_upgrade(headers)) {
+                  handle_websocket_upgrade(socket_ptr, *method_opt, target, headers, remote_endpoint);
+                  return;
+               }
+
+               std::size_t content_length = 0;
+               if (auto it = headers.find("content-length"); it != headers.end()) {
+                  try {
+                     content_length = std::stoul(it->second);
+                  }
+                  catch (const std::exception&) {
+                     send_error_response(socket_ptr, 400, "Bad Request");
+                     return;
+                  }
+               }
+
+               if (content_length > 0) {
+                  std::string body;
+                  body.reserve(content_length);
+                  // Append what's already in the buffer
+                  const size_t initial_body_size = std::min(content_length, buffer->size());
+                  body.append(static_cast<const char*>(buffer->data().data()), initial_body_size);
+                  buffer->consume(initial_body_size);
+
+                  if (body.length() < content_length) {
+                     asio::async_read(*socket_ptr, *buffer, asio::transfer_exactly(content_length - body.length()),
+                                      [this, socket_ptr, buffer, method_opt, target, headers, remote_endpoint,
+                                       body = std::move(body)](std::error_code ec, size_t) mutable {
+                                         if (ec) {
+                                            error_handler(ec, std::source_location::current());
+                                            return;
+                                         }
+                                         // Append newly read data
+                                         body.append(static_cast<const char*>(buffer->data().data()), buffer->size());
+                                         buffer->consume(buffer->size());
+                                         process_full_request(socket_ptr, *method_opt, target, headers, std::move(body),
+                                                              remote_endpoint);
+                                      });
+                  }
+                  else {
+                     process_full_request(socket_ptr, *method_opt, target, headers, std::move(body), remote_endpoint);
+                  }
+               }
+               else {
+                  process_full_request(socket_ptr, *method_opt, target, headers, "", remote_endpoint);
+               }
+            });
+      }
+
+      inline bool is_websocket_upgrade(const std::unordered_map<std::string, std::string>& headers)
+      {
+         auto upgrade_it = headers.find("upgrade");
+         if (upgrade_it == headers.end()) return false;
+
+         auto connection_it = headers.find("connection");
+         if (connection_it == headers.end()) return false;
+
+         // Check if upgrade header contains "websocket" (case-insensitive)
+         std::string upgrade_value = upgrade_it->second;
+         std::transform(upgrade_value.begin(), upgrade_value.end(), upgrade_value.begin(), ::tolower);
+         if (upgrade_value.find("websocket") == std::string::npos) return false;
+
+         // Check if connection header contains "upgrade" (case-insensitive)
+         std::string connection_value = connection_it->second;
+         std::transform(connection_value.begin(), connection_value.end(), connection_value.begin(), ::tolower);
+         return connection_value.find("upgrade") != std::string::npos;
+      }
+
+      inline void handle_websocket_upgrade(std::shared_ptr<asio::ip::tcp::socket> socket, http_method method,
+                                           const std::string& target,
+                                           const std::unordered_map<std::string, std::string>& headers,
+                                           asio::ip::tcp::endpoint remote_endpoint)
+      {
+         // Find matching WebSocket handler
+         auto ws_it = websocket_handlers_.find(target);
+         if (ws_it == websocket_handlers_.end()) {
+            send_error_response(socket, 404, "Not Found");
+            return;
+         }
+
+         // Create request object for WebSocket handler
+         request req;
+         req.method = method;
+         req.target = target;
+         req.headers = headers;
+         req.remote_ip = remote_endpoint.address().to_string();
+         req.remote_port = remote_endpoint.port();
+
+         // Create WebSocket connection and start it
+         // Need to include websocket_connection.hpp for this to work
+         auto ws_conn = std::make_shared<websocket_connection>(std::move(*socket), ws_it->second.get());
+         ws_conn->start(req);
+      }
+
+      inline void handle_streaming_request(std::shared_ptr<asio::ip::tcp::socket> socket, http_method method,
+                                           const std::string& target,
+                                           const std::unordered_map<std::string, std::string>& headers,
+                                           std::string body, asio::ip::tcp::endpoint remote_endpoint,
+                                           const streaming_handler& handler)
+      {
+         // Create request object
+         request req;
+         req.method = method;
+         req.target = target;
+         req.headers = headers;
+         req.body = std::move(body);
+         req.remote_ip = remote_endpoint.address().to_string();
+         req.remote_port = remote_endpoint.port();
+
+         // Create streaming connection
+         auto stream_conn = std::make_shared<streaming_connection>(socket);
+         streaming_response stream_res(stream_conn);
+
+         try {
+            // Call the streaming handler
+            handler(req, stream_res);
+         }
+         catch (const std::exception&) {
+            // If handler throws immediately, try to send an error response.
+            if (!stream_conn->is_headers_sent()) {
+               stream_conn->send_headers(500, {{"Content-Type", "text/plain"}});
+               stream_conn->send_chunk("Internal Server Error");
+            }
+            stream_conn->close();
+            // Log the error
+            error_handler(std::make_error_code(std::errc::invalid_argument), std::source_location::current());
+         }
+      }
+
+      inline void process_full_request(std::shared_ptr<asio::ip::tcp::socket> socket, http_method method,
+                                       const std::string& target,
+                                       const std::unordered_map<std::string, std::string>& headers, std::string body,
+                                       asio::ip::tcp::endpoint remote_endpoint)
+      {
+         // Check for a streaming handler first. This performs an exact match on the path,
+         // so parameterized streaming routes are not supported, which is consistent
+         // with the WebSocket implementation.
+         auto handler_it = streaming_handlers_.find(target);
+         if (handler_it != streaming_handlers_.end()) {
+            auto method_it = handler_it->second.find(method);
+            if (method_it != handler_it->second.end()) {
+               // Found a streaming handler, delegate to it and exit.
+               handle_streaming_request(socket, method, target, headers, std::move(body), remote_endpoint,
+                                        method_it->second);
+               return;
+            }
+         }
+
+         // Create the request object
+         request request;
+         request.method = method;
+         request.target = target;
+         request.headers = headers;
+         request.body = std::move(body);
+         request.remote_ip = remote_endpoint.address().to_string();
+         request.remote_port = remote_endpoint.port();
+
+         // Find a matching route using http_router::match which handles both exact and parameterized routes
+         auto [handle, params] = root_router.match(method, target);
+
+         // Update the request with any extracted parameters
+         request.params = std::move(params);
+
+         if (!handle) {
+            // No matching route found
+            send_error_response(socket, 404, "Not Found");
+            return;
+         }
+
+         // Create the response object
+         response response;
+
+         try {
+            // Apply middleware
+            for (const auto& middleware : root_router.middlewares) {
+               middleware(request, response);
+            }
+
+            // Call the handle
+            handle(request, response);
+
+            // Send the response
+            send_response(socket, response);
+         }
+         catch (const std::exception& e) {
+            // Log the exception details for debugging
+            std::string error_message = e.what();
+            error_handler(std::make_error_code(std::errc::invalid_argument), std::source_location::current());
+
+            // Send a 500 error response back to the client
+            send_error_response(socket, 500, "Internal Server Error");
+         }
+      }
+
+      inline void send_response(std::shared_ptr<asio::ip::tcp::socket> socket, const response& response)
+      {
+         // Pre-calculate response size to avoid reallocations
+         size_t estimated_size = 64; // Base size for status line
+
+         for (const auto& [name, value] : response.response_headers) {
+            estimated_size += name.size() + value.size() + 4; // ": " + "\r\n"
+         }
+
+         estimated_size += response.response_body.size() + 128; // Extra buffer for default headers
+
+         // Use a single string with reserved capacity
+         std::string response_str;
+         response_str.reserve(estimated_size);
+
+         // Direct string building without streams
+         response_str.append("HTTP/1.1 ");
+         response_str.append(std::to_string(response.status_code));
+         response_str.append(" ");
+         response_str.append(get_status_message(response.status_code));
+         response_str.append("\r\n");
+
+         for (const auto& [name, value] : response.response_headers) {
+            response_str.append(name);
+            response_str.append(": ");
+            response_str.append(value);
+            response_str.append("\r\n");
+         }
+
+         // Add default headers if not present (using find is faster than streams)
+         if (response.response_headers.find("Content-Length") == response.response_headers.end()) {
+            response_str.append("Content-Length: ");
+            response_str.append(std::to_string(response.response_body.size()));
+            response_str.append("\r\n");
+         }
+
+         if (response.response_headers.find("Date") == response.response_headers.end()) {
+            response_str.append("Date: ");
+            response_str.append(get_current_date());
+            response_str.append("\r\n");
+         }
+
+         if (response.response_headers.find("Server") == response.response_headers.end()) {
+            response_str.append("Server: Glaze/1.0\r\n");
+         }
+
+         // End headers and add body
+         response_str.append("\r\n");
+         response_str.append(response.response_body);
+
+         auto response_buffer = std::make_shared<std::string>(std::move(response_str));
+
+         // Send the response asynchronously
+         asio::async_write(*socket, asio::buffer(*response_buffer),
+                           [socket, response_buffer](std::error_code /*ec*/, std::size_t /*bytes_transferred*/) {
+                              // response_buffer keeps the string alive for the duration of the async operation
+                              // Socket cleanup handled by shared_ptr
+                           });
+      }
+
+      inline void send_error_response(std::shared_ptr<asio::ip::tcp::socket> socket, int status_code,
+                                      const std::string& message)
+      {
+         response response;
+         response.status(status_code).content_type("text/plain").body(message);
+
+         send_response(socket, response);
+      }
+
+      inline std::string_view get_status_message(int status_code)
+      {
+         switch (status_code) {
+         case 200:
+            return "OK";
+         case 201:
+            return "Created";
+         case 204:
+            return "No Content";
+         case 400:
+            return "Bad Request";
+         case 401:
+            return "Unauthorized";
+         case 403:
+            return "Forbidden";
+         case 404:
+            return "Not Found";
+         case 405:
+            return "Method Not Allowed";
+         case 409:
+            return "Conflict";
+         case 418:
+            return "I'm a teapot";
+         case 500:
+            return "Internal Server Error";
+         case 501:
+            return "Not Implemented";
+         case 503:
+            return "Service Unavailable";
+         default:
+            return "Unknown";
+         }
+      }
+
+      inline std::string get_current_date()
+      {
+         auto now = std::chrono::system_clock::now();
+         auto time_t_now = std::chrono::system_clock::to_time_t(now);
+
+         char buf[100];
+         std::strftime(buf, sizeof(buf), "%a, %d %b %Y %H:%M:%S GMT", std::gmtime(&time_t_now));
+
+         return buf;
+      }
+   };
+
+   // Utility functions for common streaming patterns
+   namespace streaming_utils
+   {
+      // Create a periodic data sender
+      template <typename T>
+      void send_periodic_data(std::shared_ptr<streaming_connection> conn, std::function<T()> data_generator,
+                              std::chrono::milliseconds interval, size_t max_events = 0)
+      {
+         auto counter = std::make_shared<size_t>(0);
+         if (!conn || !conn->is_open()) return;
+         auto timer = std::make_shared<asio::steady_timer>(conn->socket_->get_executor());
+
+         std::function<void()> send_next = [=]() mutable {
+            if (!conn->is_open() || (max_events > 0 && *counter >= max_events)) {
+               conn->close();
+               return;
+            }
+
+            try {
+               T data = data_generator();
+               conn->send_json_event(data, "data", std::to_string(*counter), [=](std::error_code ec) mutable {
+                  if (!ec) {
+                     (*counter)++;
+                     timer->expires_after(interval);
+                     timer->async_wait([=](std::error_code) { send_next(); });
+                  }
+                  else {
+                     conn->close();
+                  }
+               });
+            }
+            catch (const std::exception&) {
+               conn->close();
+            }
+         };
+
+         send_next();
+      }
+
+      // Create a data stream from a collection
+      template <typename Container>
+      void stream_collection(std::shared_ptr<streaming_connection> conn, const Container& data,
+                             std::chrono::milliseconds delay_between_items = std::chrono::milliseconds(10))
+      {
+         auto it = std::make_shared<typename Container::const_iterator>(data.begin());
+         auto end_it = data.end();
+         if (!conn || !conn->is_open()) return;
+         auto timer = std::make_shared<asio::steady_timer>(conn->socket_->get_executor());
+
+         std::function<void()> send_next = [=]() mutable {
+            if (!conn->is_open() || *it == end_it) {
+               conn->close();
+               return;
+            }
+
+            conn->send_json_event(**it, "item", "", [=](std::error_code ec) mutable {
+               if (!ec) {
+                  ++(*it);
+                  timer->expires_after(delay_between_items);
+                  timer->async_wait([=](std::error_code) { send_next(); });
+               }
+               else {
+                  conn->close();
+               }
+            });
+         };
+
+         send_next();
+      }
+   } // namespace streaming_utils
+
+   // Alias for HTTPS server
+   using https_server = http_server<true>;
+}
diff --git a/deps/saucer/include/glaze/net/openapi.hpp b/deps/saucer/include/glaze/net/openapi.hpp
new file mode 100644
index 0000000..6df79d7
--- /dev/null
+++ b/deps/saucer/include/glaze/net/openapi.hpp
@@ -0,0 +1,90 @@
+// Glaze Library - For the license information refer to glaze.hpp
+#pragma once
+
+#include <unordered_map>
+
+#include "glaze/json.hpp"
+#include "glaze/json/schema.hpp"
+#include "glaze/net/http_router.hpp"
+
+namespace glz
+{
+   struct openapi_info
+   {
+      std::string title = "API";
+      std::string version = "1.0.0";
+      std::optional<std::string> description{};
+   };
+
+   struct openapi_schema_ref
+   {
+      std::string ref{}; // Reference to schema like "#/components/schemas/TypeName"
+   };
+
+   struct openapi_media_type
+   {
+      std::optional<detail::schematic> schema{};
+      std::optional<std::string> example{};
+   };
+
+   struct openapi_request_body
+   {
+      std::optional<std::string> description{};
+      std::unordered_map<std::string, openapi_media_type> content{};
+      bool required = false;
+   };
+
+   struct openapi_parameter
+   {
+      std::string name{};
+      std::string in{}; // "path", "query", "header", or "cookie"
+      std::optional<std::string> description{};
+      bool required = false;
+      std::optional<detail::schematic> schema{};
+   };
+
+   struct openapi_response
+   {
+      std::string description{};
+      std::optional<std::unordered_map<std::string, openapi_media_type>> content{};
+   };
+
+   struct openapi_components
+   {
+      std::optional<std::unordered_map<std::string, detail::schematic>> schemas{};
+   };
+
+   struct openapi_operation
+   {
+      std::optional<std::vector<std::string>> tags{};
+      std::optional<std::string> summary{};
+      std::optional<std::string> operationId{};
+      std::optional<std::vector<openapi_parameter>> parameters{};
+      std::optional<openapi_request_body> requestBody{};
+      std::unordered_map<std::string, openapi_response> responses{};
+   };
+
+   struct openapi_path_item
+   {
+      std::optional<openapi_operation> get{};
+      std::optional<openapi_operation> put{};
+      std::optional<openapi_operation> post{};
+      std::optional<openapi_operation> del{}; // Mapped to "delete" in JSON
+      std::optional<openapi_operation> patch{};
+   };
+
+   struct open_api
+   {
+      std::string openapi = "3.0.3";
+      openapi_info info{};
+      std::optional<openapi_components> components{};
+      std::unordered_map<std::string, openapi_path_item> paths{};
+   };
+}
+
+template <>
+struct glz::meta<glz::openapi_path_item>
+{
+   using T = glz::openapi_path_item;
+   static constexpr auto value = glz::object(&T::get, &T::put, &T::post, "delete", &T::del, &T::patch);
+};
diff --git a/deps/saucer/include/glaze/net/rest_registry_impl.hpp b/deps/saucer/include/glaze/net/rest_registry_impl.hpp
new file mode 100644
index 0000000..3fd8929
--- /dev/null
+++ b/deps/saucer/include/glaze/net/rest_registry_impl.hpp
@@ -0,0 +1,315 @@
+// Glaze Library
+// For the license information refer to glaze.hpp
+
+#pragma once
+
+#include "glaze/core/opts.hpp" // For REST constant
+#include "glaze/glaze.hpp"
+#include "glaze/json/schema.hpp"
+#include "glaze/net/http_router.hpp"
+#include "glaze/rpc/repe/repe.hpp" // For protocol_storage template
+
+namespace glz
+{
+   // Forward declaration of the registry template
+   template <auto Opts, uint32_t Proto>
+   struct registry;
+
+   template <>
+   struct protocol_storage<REST>
+   {
+      using type = http_router;
+   };
+
+   // Implementation for REST protocol
+   template <auto Opts>
+   struct registry_impl<Opts, REST>
+   {
+      using enum http_method;
+
+      // Helper method to convert a JSON pointer path to a REST path
+      static std::string convert_to_rest_path(sv json_pointer_path)
+      {
+         // Make a copy of the path
+         std::string rest_path(json_pointer_path);
+
+         // Remove trailing slashes
+         if (!rest_path.empty() && rest_path.back() == '/') {
+            rest_path.pop_back();
+         }
+
+         return rest_path;
+      }
+
+      // Helper to generate JSON schema for a type
+      template <class T>
+      static std::string generate_schema_for_type()
+      {
+         std::string schema_str;
+         auto ec = write_json_schema<T>(schema_str);
+         if (ec) {
+            return "{}";
+         }
+         return schema_str;
+      }
+
+      template <class T>
+      static std::string get_type_name()
+      {
+         if constexpr (string_t<T>) {
+            return "string";
+         }
+         else if constexpr (num_t<T>) {
+            return "number";
+         }
+         else if constexpr (readable_array_t<T> || tuple_t<T> || is_std_tuple<T>) {
+            return "array";
+         }
+         else if constexpr (boolean_like<T>) {
+            return "boolean";
+         }
+         else if constexpr (glaze_object_t<T> || reflectable<T> || writable_map_t<T>) {
+            return "object";
+         }
+         else {
+            return "";
+         }
+      }
+
+      // Helper to create route spec with type information
+      template <class RequestType = void, class ResponseType = void>
+      static route_spec create_route_spec_with_types(const std::string& description = "",
+                                                     const std::vector<std::string>& tags = {})
+      {
+         route_spec spec;
+         spec.description = description;
+         spec.tags = tags;
+
+         if constexpr (!std::same_as<RequestType, void>) {
+            spec.request_body_schema = generate_schema_for_type<RequestType>();
+            spec.request_body_type_name = get_type_name<RequestType>();
+         }
+
+         if constexpr (!std::same_as<ResponseType, void>) {
+            spec.response_schema = generate_schema_for_type<ResponseType>();
+            spec.response_type_name = get_type_name<ResponseType>();
+         }
+
+         return spec;
+      }
+
+      template <class T, class RegistryType>
+      static void register_endpoint(const sv path, T& value, RegistryType& reg)
+      {
+         std::string rest_path = convert_to_rest_path(path);
+
+         // GET handler for the entire object
+         auto get_spec = create_route_spec_with_types<void, T>("Get " + get_type_name<T>(), {"data"});
+         reg.endpoints.route(
+            GET, rest_path, [&value](const request& /*req*/, response& res) { res.template body<Opts>(value); },
+            get_spec);
+
+         // PUT handler for updating the entire object
+         auto put_spec = create_route_spec_with_types<T, void>("Update " + get_type_name<T>(), {"data"});
+         reg.endpoints.route(
+            PUT, rest_path,
+            [&value](const request& req, response& res) {
+               // Parse the JSON request body
+               auto ec = read<Opts>(value, req.body);
+               if (ec) {
+                  res.status(400).body("Invalid request body: " + format_error(ec, req.body));
+                  return;
+               }
+
+               res.status(204); // No Content
+            },
+            put_spec);
+      }
+
+      template <class Func, class Result, class RegistryType>
+      static void register_function_endpoint(const sv path, Func& func, RegistryType& reg)
+      {
+         std::string rest_path = convert_to_rest_path(path);
+
+         auto get_spec = create_route_spec_with_types<void, Result>("Get " + get_type_name<Result>(), {"data"});
+         // GET handler for functions
+         reg.endpoints.route(
+            GET, rest_path,
+            [&func](const request& /*req*/, response& res) {
+               if constexpr (std::same_as<Result, void>) {
+                  func();
+                  res.status(204); // No Content
+               }
+               else {
+                  auto result = func();
+                  res.body<Opts>(result);
+               }
+            },
+            get_spec);
+      }
+
+      template <class Func, class Params, class RegistryType>
+      static void register_param_function_endpoint(const sv path, Func& func, RegistryType& reg)
+      {
+         std::string rest_path = convert_to_rest_path(path);
+
+         using Result = std::invoke_result_t<decltype(func), Params>;
+         auto post_spec = create_route_spec_with_types<Params, Result>("Create " + get_type_name<Result>(), {"data"});
+         // POST handler for functions with parameters
+         reg.endpoints.route(
+            POST, rest_path,
+            [&func](const request& req, response& res) {
+               // Parse the JSON request body
+               Params params_result{};
+               auto ec = read<Opts>(params_result, req.body);
+               if (bool(ec)) {
+                  res.status(400).body("Invalid request body: " + format_error(ec, req.body));
+                  return;
+               }
+
+               if constexpr (std::same_as<Result, void>) {
+                  func(std::move(params_result));
+                  res.status(204); // No Content
+               }
+               else {
+                  auto result = func(std::move(params_result));
+                  res.body<Opts>(result);
+               }
+            },
+            post_spec);
+      }
+
+      template <class Obj, class RegistryType>
+      static void register_object_endpoint(const sv path, Obj& obj, RegistryType& reg)
+      {
+         std::string rest_path = convert_to_rest_path(path);
+
+         auto get_spec = create_route_spec_with_types<void, Obj>("Get " + get_type_name<Obj>(), {"data"});
+         // GET handler for nested objects
+         reg.endpoints.route(
+            GET, rest_path, [&obj](const request& /*req*/, response& res) { res.body<Opts>(obj); }, get_spec);
+
+         auto put_spec = create_route_spec_with_types<Obj, void>("Update " + get_type_name<Obj>(), {"data"});
+         // PUT handler for updating nested objects
+         reg.endpoints.route(
+            PUT, rest_path,
+            [&obj](const request& req, response& res) {
+               // Parse the JSON request body
+               auto ec = read<Opts>(obj, req.body);
+               if (ec) {
+                  res.status(400).body("Invalid request body: " + format_error(ec, req.body));
+                  return;
+               }
+
+               res.status(204); // No Content
+            },
+            put_spec);
+      }
+
+      template <class Value, class RegistryType>
+      static void register_value_endpoint(const sv path, Value& value, RegistryType& reg)
+      {
+         std::string rest_path = convert_to_rest_path(path);
+
+         auto get_spec = create_route_spec_with_types<void, Value>("Get " + get_type_name<Value>(), {"data"});
+         // GET handler for values
+         reg.endpoints.route(
+            GET, rest_path, [&value](const request& /*req*/, response& res) { res.body<Opts>(value); }, get_spec);
+
+         auto put_spec = create_route_spec_with_types<Value, void>("Update " + get_type_name<Value>(), {"data"});
+         // PUT handler for updating values
+         reg.endpoints.route(
+            PUT, rest_path,
+            [&value](const request& req, response& res) {
+               // Parse the JSON request body
+               auto ec = read<Opts>(value, req.body);
+               if (ec) {
+                  res.status(400).body("Invalid request body: " + format_error(ec, req.body));
+                  return;
+               }
+
+               res.status(204); // No Content
+            },
+            put_spec);
+      }
+
+      template <class Var, class RegistryType>
+      static void register_variable_endpoint(const sv path, Var& var, RegistryType& reg)
+      {
+         std::string rest_path = convert_to_rest_path(path);
+
+         auto get_spec = create_route_spec_with_types<void, Var>("Get " + get_type_name<Var>(), {"data"});
+         // GET handler for variables
+         reg.endpoints.route(
+            GET, rest_path, [&var](const request& /*req*/, response& res) { res.body<Opts>(var); }, get_spec);
+
+         auto put_spec = create_route_spec_with_types<Var, void>("Update " + get_type_name<Var>(), {"data"});
+         // PUT handler for updating variables
+         reg.endpoints.route(
+            PUT, rest_path,
+            [&var](const request& req, response& res) {
+               // Parse the JSON request body
+               auto ec = read<Opts>(var, req.body);
+               if (ec) {
+                  res.status(400).body("Invalid request body: " + format_error(ec, req.body));
+                  return;
+               }
+
+               res.status(204); // No Content
+            },
+            put_spec);
+      }
+
+      template <class T, class F, class Ret, class RegistryType>
+      static void register_member_function_endpoint(const sv path, T& value, F func, RegistryType& reg)
+      {
+         std::string rest_path = convert_to_rest_path(path);
+
+         auto get_spec = create_route_spec_with_types<void, Ret>("Get " + get_type_name<Ret>(), {"data"});
+         // GET handler for member functions with no args
+         reg.endpoints.route(
+            GET, rest_path,
+            [&value, func](const request& /*req*/, response& res) {
+               if constexpr (std::same_as<Ret, void>) {
+                  (value.*func)();
+                  res.status(204); // No Content
+               }
+               else {
+                  auto result = (value.*func)();
+                  res.body<Opts>(result);
+               }
+            },
+            get_spec);
+      }
+
+      template <class T, class F, class Input, class Ret, class RegistryType>
+      static void register_member_function_with_params_endpoint(const sv path, T& value, F func, RegistryType& reg)
+      {
+         std::string rest_path = convert_to_rest_path(path);
+
+         auto post_spec = create_route_spec_with_types<Input, Ret>("Create " + get_type_name<Ret>(), {"data"});
+         // POST handler for member functions with args
+         reg.endpoints.route(
+            POST, rest_path,
+            [&value, func](const request& req, response& res) {
+               // Parse the JSON request body
+               Input params_result{};
+               auto ec = read<Opts>(params_result, req.body);
+               if (bool(ec)) {
+                  res.status(400).body("Invalid request body: " + format_error(ec, req.body));
+                  return;
+               }
+
+               if constexpr (std::same_as<Ret, void>) {
+                  (value.*func)(std::move(params_result));
+                  res.status(204); // No Content
+               }
+               else {
+                  auto result = (value.*func)(std::move(params_result));
+                  res.body<Opts>(result);
+               }
+            },
+            post_spec);
+      }
+   };
+}
diff --git a/deps/saucer/include/glaze/net/websocket_connection.hpp b/deps/saucer/include/glaze/net/websocket_connection.hpp
new file mode 100644
index 0000000..51e19f0
--- /dev/null
+++ b/deps/saucer/include/glaze/net/websocket_connection.hpp
@@ -0,0 +1,790 @@
+// Glaze Library
+// For the license information refer to glaze.hpp
+
+#pragma once
+
+#include <algorithm>
+#include <array>
+#include <chrono>
+#include <cstring>
+#include <functional>
+#include <memory>
+#include <string>
+#include <string_view>
+#include <unordered_map>
+#include <vector>
+
+// Optional OpenSSL support - detected at compile time
+#if defined(GLZ_ENABLE_OPENSSL) && __has_include(<openssl/sha.h>)
+#include <openssl/sha.h>
+#define GLZ_HAS_OPENSSL
+
+// To deconflict Windows.h
+#ifdef DELETE
+#undef DELETE
+#endif
+#endif
+
+#include "glaze/base64/base64.hpp"
+#include "glaze/ext/glaze_asio.hpp"
+#include "glaze/net/http_router.hpp"
+
+namespace glz
+{
+   // WebSocket opcode constants
+   enum class ws_opcode : uint8_t { continuation = 0x0, text = 0x1, binary = 0x2, close = 0x8, ping = 0x9, pong = 0xa };
+
+   // WebSocket close codes
+   enum class ws_close_code : uint16_t {
+      normal = 1000,
+      going_away = 1001,
+      protocol_error = 1002,
+      unsupported_data = 1003,
+      invalid_payload = 1007,
+      policy_violation = 1008,
+      message_too_big = 1009,
+      mandatory_extension = 1010,
+      internal_error = 1011
+   };
+
+   // WebSocket frame header helper
+   struct ws_frame_header
+   {
+      uint8_t data[2];
+
+      ws_frame_header() { reset(); }
+
+      void reset()
+      {
+         data[0] = 0;
+         data[1] = 0;
+      }
+
+      void fin(bool v) { data[0] = (data[0] & ~0x80) | (v ? 0x80 : 0); }
+      void opcode(ws_opcode v) { data[0] = (data[0] & ~0x0F) | (static_cast<uint8_t>(v) & 0x0F); }
+      void mask(bool v) { data[1] = (data[1] & ~0x80) | (v ? 0x80 : 0); }
+      void payload_len(uint8_t v) { data[1] = (data[1] & ~0x7F) | (v & 0x7F); }
+
+      bool fin() const { return (data[0] & 0x80) != 0; }
+      ws_opcode opcode() const { return static_cast<ws_opcode>(data[0] & 0x0F); }
+      bool mask() const { return (data[1] & 0x80) != 0; }
+      uint8_t payload_len() const { return data[1] & 0x7F; }
+   };
+
+   // WebSocket utilities
+   namespace ws_util
+   {
+#if !defined(GLZ_ENABLE_OPENSSL)
+      // Fallback SHA-1 implementation when OpenSSL is not available
+      namespace fallback_sha1
+      {
+         struct sha1_context
+         {
+            uint32_t state[5];
+            uint32_t count[2];
+            uint8_t buffer[64];
+         };
+
+         inline void sha1_init(sha1_context* context)
+         {
+            context->state[0] = 0x67452301;
+            context->state[1] = 0xEFCDAB89;
+            context->state[2] = 0x98BADCFE;
+            context->state[3] = 0x10325476;
+            context->state[4] = 0xC3D2E1F0;
+            context->count[0] = context->count[1] = 0;
+         }
+
+         inline void sha1_process(sha1_context* context, const uint8_t data[64])
+         {
+            uint32_t w[80], a, b, c, d, e, temp;
+
+            for (int i = 0; i < 16; i++) {
+               w[i] = (data[i * 4] << 24) | (data[i * 4 + 1] << 16) | (data[i * 4 + 2] << 8) | data[i * 4 + 3];
+            }
+
+            for (int i = 16; i < 80; i++) {
+               w[i] = w[i - 3] ^ w[i - 8] ^ w[i - 14] ^ w[i - 16];
+               w[i] = (w[i] << 1) | (w[i] >> 31);
+            }
+
+            a = context->state[0];
+            b = context->state[1];
+            c = context->state[2];
+            d = context->state[3];
+            e = context->state[4];
+
+            for (int i = 0; i < 80; i++) {
+               if (i < 20) {
+                  temp = ((a << 5) | (a >> 27)) + ((b & c) | (~b & d)) + e + w[i] + 0x5A827999;
+               }
+               else if (i < 40) {
+                  temp = ((a << 5) | (a >> 27)) + (b ^ c ^ d) + e + w[i] + 0x6ED9EBA1;
+               }
+               else if (i < 60) {
+                  temp = ((a << 5) | (a >> 27)) + ((b & c) | (b & d) | (c & d)) + e + w[i] + 0x8F1BBCDC;
+               }
+               else {
+                  temp = ((a << 5) | (a >> 27)) + (b ^ c ^ d) + e + w[i] + 0xCA62C1D6;
+               }
+
+               e = d;
+               d = c;
+               c = (b << 30) | (b >> 2);
+               b = a;
+               a = temp;
+            }
+
+            context->state[0] += a;
+            context->state[1] += b;
+            context->state[2] += c;
+            context->state[3] += d;
+            context->state[4] += e;
+         }
+
+         inline void sha1_update(sha1_context* context, const uint8_t* data, size_t len)
+         {
+            size_t i = 0;
+            size_t j = (context->count[0] >> 3) & 63;
+
+            if ((context->count[0] += uint32_t(len << 3)) < (len << 3)) context->count[1]++;
+            context->count[1] += (len >> 29);
+
+            if ((j + len) > 63) {
+               std::memcpy(&context->buffer[j], data, (i = 64 - j));
+               sha1_process(context, context->buffer);
+               for (; i + 63 < len; i += 64) {
+                  sha1_process(context, &data[i]);
+               }
+               j = 0;
+            }
+
+            std::memcpy(&context->buffer[j], &data[i], len - i);
+         }
+
+         inline void sha1_final(sha1_context* context, uint8_t digest[20])
+         {
+            uint8_t finalcount[8];
+
+            for (int i = 0; i < 8; i++) {
+               finalcount[i] = (uint8_t)((context->count[(i >= 4 ? 0 : 1)] >> ((3 - (i & 3)) * 8)) & 255);
+            }
+
+            sha1_update(context, (uint8_t*)"\200", 1);
+            while ((context->count[0] & 504) != 448) {
+               sha1_update(context, (uint8_t*)"\0", 1);
+            }
+
+            sha1_update(context, finalcount, 8);
+
+            for (int i = 0; i < 20; i++) {
+               digest[i] = (uint8_t)((context->state[i >> 2] >> ((3 - (i & 3)) * 8)) & 255);
+            }
+         }
+      }
+#endif
+
+      // Generate WebSocket accept key from client key
+      inline std::string generate_accept_key(std::string_view client_key)
+      {
+         std::string combined = std::string(client_key) + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
+
+         unsigned char hash[20];
+
+#if defined(GLZ_ENABLE_OPENSSL) && defined(GLZ_HAS_OPENSSL)
+         // Use OpenSSL when available
+#if OPENSSL_VERSION_NUMBER <= 0x030000000L
+         SHA_CTX sha1;
+         SHA1_Init(&sha1);
+         SHA1_Update(&sha1, combined.data(), combined.size());
+         SHA1_Final(hash, &sha1);
+#else
+         EVP_MD_CTX* sha1 = EVP_MD_CTX_new();
+         EVP_DigestInit_ex(sha1, EVP_sha1(), NULL);
+         EVP_DigestUpdate(sha1, combined.data(), combined.size());
+         EVP_DigestFinal_ex(sha1, hash, NULL);
+         EVP_MD_CTX_free(sha1);
+#endif
+#else
+         // Use fallback implementation when OpenSSL is not available
+         fallback_sha1::sha1_context ctx;
+         fallback_sha1::sha1_init(&ctx);
+         fallback_sha1::sha1_update(&ctx, reinterpret_cast<const uint8_t*>(combined.data()), combined.size());
+         fallback_sha1::sha1_final(&ctx, hash);
+#endif
+
+         return glz::write_base64(std::string_view{reinterpret_cast<char*>(hash), sizeof(hash)});
+      }
+
+      // Check if a string contains a value (case-insensitive, comma-separated)
+      inline bool header_contains(std::string_view header, std::string_view value)
+      {
+         while (!header.empty()) {
+            // Skip whitespace
+            while (!header.empty() && (header.front() == ' ' || header.front() == '\t')) {
+               header.remove_prefix(1);
+            }
+
+            if (header.empty()) break;
+
+            // Find the end of this token
+            auto comma_pos = header.find(',');
+            std::string_view token = header.substr(0, comma_pos);
+
+            // Remove trailing whitespace from token
+            while (!token.empty() && (token.back() == ' ' || token.back() == '\t')) {
+               token.remove_suffix(1);
+            }
+
+            // Case-insensitive comparison
+            if (token.size() == value.size() &&
+                std::equal(token.begin(), token.end(), value.begin(), value.end(),
+                           [](char a, char b) { return std::tolower(a) == std::tolower(b); })) {
+               return true;
+            }
+
+            if (comma_pos == std::string_view::npos) break;
+            header.remove_prefix(comma_pos + 1);
+         }
+
+         return false;
+      }
+   }
+
+   // Forward declarations
+   struct websocket_connection;
+
+   // WebSocket server class
+   struct websocket_server
+   {
+      using message_handler = std::function<void(std::shared_ptr<websocket_connection>, std::string_view, ws_opcode)>;
+      using close_handler = std::function<void(std::shared_ptr<websocket_connection>)>;
+      using error_handler = std::function<void(std::shared_ptr<websocket_connection>, std::error_code)>;
+      using open_handler = std::function<void(std::shared_ptr<websocket_connection>, const request&)>;
+      using validate_handler = std::function<bool(const request&)>;
+
+      websocket_server() = default;
+
+      // Set message handler
+      inline void on_message(message_handler handler) { message_handler_ = std::move(handler); }
+
+      // Set connection handler
+      inline void on_open(open_handler handler) { open_handler_ = std::move(handler); }
+
+      // Set close handler
+      inline void on_close(close_handler handler) { close_handler_ = std::move(handler); }
+
+      // Set error handler
+      inline void on_error(error_handler handler) { error_handler_ = std::move(handler); }
+
+      // Set connection validator
+      inline void on_validate(validate_handler handler) { validate_handler_ = std::move(handler); }
+
+      // Internal methods called by websocket_connection
+      inline void notify_open(std::shared_ptr<websocket_connection> conn, const request& req)
+      {
+         if (open_handler_) {
+            open_handler_(conn, req);
+         }
+      }
+
+      inline void notify_message(std::shared_ptr<websocket_connection> conn, std::string_view message, ws_opcode opcode)
+      {
+         if (message_handler_) {
+            message_handler_(conn, message, opcode);
+         }
+      }
+
+      inline void notify_close(std::shared_ptr<websocket_connection> conn)
+      {
+         if (close_handler_) {
+            close_handler_(conn);
+         }
+      }
+
+      inline void notify_error(std::shared_ptr<websocket_connection> conn, std::error_code ec)
+      {
+         if (error_handler_) {
+            error_handler_(conn, ec);
+         }
+      }
+
+      inline bool validate_connection(const request& req)
+      {
+         if (validate_handler_) {
+            return validate_handler_(req);
+         }
+         return true;
+      }
+
+     private:
+      open_handler open_handler_;
+      message_handler message_handler_;
+      close_handler close_handler_;
+      error_handler error_handler_;
+      validate_handler validate_handler_;
+   };
+
+   // WebSocket connection class - implementations come after websocket_server
+   struct websocket_connection : public std::enable_shared_from_this<websocket_connection>
+   {
+     public:
+      inline websocket_connection(asio::ip::tcp::socket socket, websocket_server* server)
+         : socket_(std::move(socket)), server_(server)
+      {
+         remote_endpoint_ = socket_.remote_endpoint();
+      }
+
+      ~websocket_connection() = default;
+
+      // Start the WebSocket connection (performs handshake)
+      inline void start(const request& req) { perform_handshake(req); }
+
+      // Send a text message
+      inline void send_text(std::string_view message) { send_frame(ws_opcode::text, message); }
+
+      // Send a binary message
+      inline void send_binary(std::string_view message) { send_frame(ws_opcode::binary, message); }
+
+      // Send a ping frame
+      inline void send_ping(std::string_view payload = {}) { send_frame(ws_opcode::ping, payload); }
+
+      // Send a pong frame
+      inline void send_pong(std::string_view payload = {}) { send_frame(ws_opcode::pong, payload); }
+
+      // Close the connection
+      inline void close(ws_close_code code = ws_close_code::normal, std::string_view reason = {})
+      {
+         if (is_closing_) return;
+
+         is_closing_ = true;
+         send_close_frame(code, reason);
+
+         // Close after a short delay to allow the close frame to be sent
+         auto self = shared_from_this();
+         auto timer = std::make_shared<asio::steady_timer>(socket_.get_executor());
+         timer->expires_after(std::chrono::milliseconds(100));
+         timer->async_wait([self, timer](std::error_code) { self->do_close(); });
+      }
+
+      // Get remote endpoint information
+      inline std::string remote_address() const { return remote_endpoint_.address().to_string(); }
+
+      inline uint16_t remote_port() const { return remote_endpoint_.port(); }
+
+      // Set user data
+      inline void set_user_data(std::shared_ptr<void> data) { user_data_ = data; }
+      inline std::shared_ptr<void> get_user_data() const { return user_data_; }
+
+     private:
+      inline void perform_handshake(const request& req)
+      {
+         // Validate WebSocket upgrade request
+         auto it = req.headers.find("upgrade");
+         constexpr std::string_view websocket_str = "websocket";
+         if (it == req.headers.end() ||
+             !std::equal(it->second.begin(), it->second.end(), websocket_str.begin(), websocket_str.end(),
+                         [](char a, char b) { return std::tolower(a) == std::tolower(b); })) {
+            do_close();
+            return;
+         }
+
+         it = req.headers.find("connection");
+         if (it == req.headers.end() || !ws_util::header_contains(it->second, "upgrade")) {
+            do_close();
+            return;
+         }
+
+         it = req.headers.find("sec-websocket-version");
+         if (it == req.headers.end() || it->second != "13") {
+            do_close();
+            return;
+         }
+
+         it = req.headers.find("sec-websocket-key");
+         if (it == req.headers.end()) {
+            do_close();
+            return;
+         }
+
+         // Check if server wants to validate this connection
+         if (server_ && !server_->validate_connection(req)) {
+            do_close();
+            return;
+         }
+
+         // Generate accept key
+         std::string accept_key = ws_util::generate_accept_key(it->second);
+
+         // Send handshake response
+         std::string response_str =
+            "HTTP/1.1 101 Switching Protocols\r\n"
+            "Upgrade: websocket\r\n"
+            "Connection: Upgrade\r\n"
+            "Sec-WebSocket-Accept: ";
+         response_str.append(accept_key);
+         response_str.append("\r\n\r\n");
+
+         auto self = shared_from_this();
+
+         // Use shared_ptr to keep response string alive during async operation
+         auto response_buffer = std::make_shared<std::string>(std::move(response_str));
+         asio::async_write(socket_, asio::buffer(*response_buffer),
+                           [self, req, response_buffer](std::error_code ec, std::size_t) {
+                              if (ec) {
+                                 if (self->server_) {
+                                    self->server_->notify_error(self, ec);
+                                 }
+                                 return;
+                              }
+
+                              self->handshake_complete_ = true;
+
+                              // Notify server of successful connection
+                              if (self->server_) {
+                                 self->server_->notify_open(self, req);
+                              }
+
+                              // Start reading frames
+                              self->start_read();
+                           });
+      }
+
+      inline void start_read()
+      {
+         auto self = shared_from_this();
+         socket_.async_read_some(asio::buffer(read_buffer_), [self](std::error_code ec, std::size_t bytes_transferred) {
+            self->on_read(ec, bytes_transferred);
+         });
+      }
+
+      inline void on_read(std::error_code ec, std::size_t bytes_transferred)
+      {
+         if (ec) {
+            if (server_) {
+               server_->notify_error(shared_from_this(), ec);
+            }
+            return;
+         }
+
+         // Add received data to frame buffer
+         frame_buffer_.insert(frame_buffer_.end(), read_buffer_.begin(), read_buffer_.begin() + bytes_transferred);
+
+         // Process complete frames
+         process_frame(frame_buffer_.data(), frame_buffer_.size());
+
+         // Continue reading if connection is still open
+         if (!is_closing_ && handshake_complete_) {
+            start_read();
+         }
+      }
+
+      inline void process_frame(const uint8_t* data, std::size_t length)
+      {
+         std::size_t offset = 0;
+
+         while (offset < length) {
+            // Need at least 2 bytes for basic header
+            if (length - offset < 2) {
+               break;
+            }
+
+            ws_frame_header header;
+            header.data[0] = data[offset];
+            header.data[1] = data[offset + 1];
+            offset += 2;
+
+            // Check reserved bits
+            if ((header.data[0] & 0x70) != 0) {
+               close(ws_close_code::protocol_error, "Reserved bits set");
+               return;
+            }
+
+            // Get payload length
+            uint64_t payload_length = header.payload_len();
+
+            if (payload_length == 126) {
+               if (length - offset < 2) break;
+               payload_length = (static_cast<uint64_t>(data[offset]) << 8) | data[offset + 1];
+               offset += 2;
+            }
+            else if (payload_length == 127) {
+               if (length - offset < 8) break;
+               payload_length = 0;
+               for (int i = 0; i < 8; ++i) {
+                  payload_length = (payload_length << 8) | data[offset + i];
+               }
+               offset += 8;
+            }
+
+            // Read mask key if present
+            std::array<uint8_t, 4> mask_key{};
+            if (header.mask()) {
+               if (length - offset < 4) break;
+               std::copy(data + offset, data + offset + 4, mask_key.begin());
+               offset += 4;
+            }
+
+            // Check if we have the complete payload
+            if (length - offset < payload_length) {
+               break;
+            }
+
+            // Extract and unmask payload
+            std::vector<uint8_t> payload(payload_length);
+            if (payload_length > 0) {
+               std::copy(data + offset, data + offset + payload_length, payload.begin());
+
+               if (header.mask()) {
+                  for (std::size_t i = 0; i < payload_length; ++i) {
+                     payload[i] ^= mask_key[i % 4];
+                  }
+               }
+            }
+
+            offset += payload_length;
+
+            // Handle the frame
+            handle_frame(header.opcode(), payload.data(), payload.size(), header.fin());
+
+            // Remove processed data from buffer
+            if (offset > 0) {
+               frame_buffer_.erase(frame_buffer_.begin(), frame_buffer_.begin() + offset);
+               return process_frame(frame_buffer_.data(), frame_buffer_.size());
+            }
+         }
+      }
+
+      inline void handle_frame(ws_opcode opcode, const uint8_t* payload, std::size_t length, bool fin)
+      {
+         switch (opcode) {
+         case ws_opcode::text:
+         case ws_opcode::binary:
+            if (is_reading_frame_) {
+               close(ws_close_code::protocol_error, "Unexpected data frame");
+               return;
+            }
+
+            current_opcode_ = opcode;
+            message_buffer_.assign(payload, payload + length);
+
+            if (fin) {
+               // Validate UTF-8 for text frames
+               if (opcode == ws_opcode::text && !is_valid_utf8(message_buffer_.data(), message_buffer_.size())) {
+                  close(ws_close_code::invalid_payload, "Invalid UTF-8");
+                  return;
+               }
+
+               if (server_) {
+                  server_->notify_message(
+                     shared_from_this(),
+                     std::string_view(reinterpret_cast<const char*>(message_buffer_.data()), message_buffer_.size()),
+                     current_opcode_);
+               }
+               message_buffer_.clear();
+               current_opcode_ = ws_opcode::continuation;
+            }
+            else {
+               is_reading_frame_ = true;
+            }
+            break;
+
+         case ws_opcode::continuation:
+            if (!is_reading_frame_) {
+               close(ws_close_code::protocol_error, "Unexpected continuation frame");
+               return;
+            }
+
+            message_buffer_.insert(message_buffer_.end(), payload, payload + length);
+
+            if (fin) {
+               is_reading_frame_ = false;
+
+               // Validate UTF-8 for text frames
+               if (current_opcode_ == ws_opcode::text &&
+                   !is_valid_utf8(message_buffer_.data(), message_buffer_.size())) {
+                  close(ws_close_code::invalid_payload, "Invalid UTF-8");
+                  return;
+               }
+
+               if (server_) {
+                  server_->notify_message(
+                     shared_from_this(),
+                     std::string_view(reinterpret_cast<const char*>(message_buffer_.data()), message_buffer_.size()),
+                     current_opcode_);
+               }
+               message_buffer_.clear();
+               current_opcode_ = ws_opcode::continuation;
+            }
+            break;
+
+         case ws_opcode::close: {
+            ws_close_code code = ws_close_code::normal;
+            std::string reason;
+
+            if (length >= 2) {
+               code = static_cast<ws_close_code>((payload[0] << 8) | payload[1]);
+               if (length > 2) {
+                  reason = std::string(reinterpret_cast<const char*>(payload + 2), length - 2);
+               }
+            }
+
+            if (!is_closing_) {
+               send_close_frame(code, reason);
+            }
+
+            do_close();
+         } break;
+
+         case ws_opcode::ping:
+            send_pong(std::string_view(reinterpret_cast<const char*>(payload), length));
+            break;
+
+         case ws_opcode::pong:
+            // Pong frames are just ignored
+            break;
+
+         default:
+            close(ws_close_code::protocol_error, "Unknown opcode");
+            break;
+         }
+      }
+
+      inline void send_frame(ws_opcode opcode, std::string_view payload, bool fin = true)
+      {
+         if (is_closing_) return;
+
+         std::size_t header_size = get_frame_header_size(payload.size());
+         std::vector<uint8_t> frame(header_size + payload.size());
+
+         write_frame_header(opcode, payload.size(), fin, frame.data());
+         std::copy(payload.begin(), payload.end(), frame.begin() + header_size);
+
+         auto self = shared_from_this();
+
+         // Use shared_ptr to keep the frame alive during async operation
+         auto frame_buffer = std::make_shared<std::vector<uint8_t>>(std::move(frame));
+         asio::async_write(socket_, asio::buffer(*frame_buffer), [self, frame_buffer](std::error_code ec, std::size_t) {
+            if (ec && self->server_) {
+               self->server_->notify_error(self, ec);
+            }
+         });
+      }
+
+      inline void send_close_frame(ws_close_code code, std::string_view reason)
+      {
+         std::vector<uint8_t> payload(2 + reason.size());
+         payload[0] = static_cast<uint8_t>(static_cast<uint16_t>(code) >> 8);
+         payload[1] = static_cast<uint8_t>(static_cast<uint16_t>(code) & 0xFF);
+
+         if (!reason.empty()) {
+            std::copy(reason.begin(), reason.end(), payload.begin() + 2);
+         }
+
+         send_frame(ws_opcode::close, std::string_view(reinterpret_cast<const char*>(payload.data()), payload.size()));
+      }
+
+      inline std::size_t get_frame_header_size(std::size_t payload_length)
+      {
+         if (payload_length < 126) {
+            return 2;
+         }
+         else if (payload_length <= 0xFFFF) {
+            return 4;
+         }
+         else {
+            return 10;
+         }
+      }
+
+      inline void write_frame_header(ws_opcode opcode, std::size_t payload_length, bool fin, uint8_t* header)
+      {
+         ws_frame_header frame_header;
+         frame_header.fin(fin);
+         frame_header.opcode(opcode);
+         frame_header.mask(false);
+
+         header[0] = frame_header.data[0];
+
+         if (payload_length < 126) {
+            frame_header.payload_len(static_cast<uint8_t>(payload_length));
+            header[1] = frame_header.data[1];
+         }
+         else if (payload_length <= 0xFFFF) {
+            frame_header.payload_len(126);
+            header[1] = frame_header.data[1];
+            header[2] = static_cast<uint8_t>(payload_length >> 8);
+            header[3] = static_cast<uint8_t>(payload_length & 0xFF);
+         }
+         else {
+            frame_header.payload_len(127);
+            header[1] = frame_header.data[1];
+            for (int i = 0; i < 8; ++i) {
+               header[2 + i] = static_cast<uint8_t>(payload_length >> (8 * (7 - i)));
+            }
+         }
+      }
+
+      inline bool is_valid_utf8(const uint8_t* data, std::size_t length)
+      {
+         // Simple UTF-8 validation
+         for (std::size_t i = 0; i < length;) {
+            uint8_t byte = data[i];
+
+            if (byte < 0x80) {
+               // ASCII character
+               i++;
+            }
+            else if ((byte & 0xE0) == 0xC0) {
+               // 2-byte sequence
+               if (i + 1 >= length || (data[i + 1] & 0xC0) != 0x80) {
+                  return false;
+               }
+               i += 2;
+            }
+            else if ((byte & 0xF0) == 0xE0) {
+               // 3-byte sequence
+               if (i + 2 >= length || (data[i + 1] & 0xC0) != 0x80 || (data[i + 2] & 0xC0) != 0x80) {
+                  return false;
+               }
+               i += 3;
+            }
+            else if ((byte & 0xF8) == 0xF0) {
+               // 4-byte sequence
+               if (i + 3 >= length || (data[i + 1] & 0xC0) != 0x80 || (data[i + 2] & 0xC0) != 0x80 ||
+                   (data[i + 3] & 0xC0) != 0x80) {
+                  return false;
+               }
+               i += 4;
+            }
+            else {
+               return false;
+            }
+         }
+
+         return true;
+      }
+
+      inline void do_close()
+      {
+         if (server_) {
+            server_->notify_close(shared_from_this());
+         }
+
+         asio::error_code ec;
+         socket_.close(ec);
+      }
+
+      asio::ip::tcp::socket socket_;
+      websocket_server* server_;
+      std::array<uint8_t, 4096> read_buffer_;
+      std::vector<uint8_t> frame_buffer_;
+      std::vector<uint8_t> message_buffer_;
+      ws_opcode current_opcode_{ws_opcode::continuation};
+      bool is_reading_frame_{false};
+      bool is_closing_{false};
+      bool handshake_complete_{false};
+      std::shared_ptr<void> user_data_;
+      asio::ip::tcp::endpoint remote_endpoint_;
+   };
+}
diff --git a/deps/saucer/include/glaze/record/recorder.hpp b/deps/saucer/include/glaze/record/recorder.hpp
index 04f2ed6..87df787 100644
--- a/deps/saucer/include/glaze/record/recorder.hpp
+++ b/deps/saucer/include/glaze/record/recorder.hpp
@@ -62,185 +62,204 @@ namespace glz
       }
    };
 
-   namespace detail
-   {
-      template <class T>
-      concept is_recorder = is_specialization_v<T, recorder>;
+   template <class T>
+   concept is_recorder = is_specialization_v<T, recorder>;
 
-      template <is_recorder T>
-      struct to_json<T>
+   template <is_recorder T>
+   struct to<JSON, T>
+   {
+      template <auto Opts, class... Args>
+      static void op(auto&& value, is_context auto&& ctx, Args&&... args)
       {
-         template <auto Opts, class... Args>
-         static void op(auto&& value, is_context auto&& ctx, Args&&... args) noexcept
-         {
-            dump<'{'>(std::forward<Args>(args)...);
-
-            if constexpr (Opts.prettify) {
-               ctx.indentation_level += Opts.indentation_width;
-               dump<'\n'>(args...);
-               dumpn<Opts.indentation_char>(ctx.indentation_level, args...);
-            }
+         dump<'{'>(std::forward<Args>(args)...);
 
-            const size_t n = value.data.size();
-            for (size_t i = 0; i < n; ++i) {
-               auto& [name, v] = value.data[i];
-               write<json>::op<Opts>(name, ctx, std::forward<Args>(args)...); // write name as key
+         if constexpr (Opts.prettify) {
+            ctx.indentation_level += Opts.indentation_width;
+            dump<'\n'>(args...);
+            dumpn<Opts.indentation_char>(ctx.indentation_level, args...);
+         }
 
-               dump<':'>(std::forward<Args>(args)...);
-               if constexpr (Opts.prettify) {
-                  dump<' '>(args...);
-               }
+         const size_t n = value.data.size();
+         for (size_t i = 0; i < n; ++i) {
+            auto& [name, v] = value.data[i];
+            serialize<JSON>::op<Opts>(name, ctx, args...); // write name as key
 
-               write<json>::op<Opts>(v.first, ctx, std::forward<Args>(args)...); // write deque
-               if (i < n - 1) {
-                  dump<','>(std::forward<Args>(args)...);
-               }
+            dump<':'>(args...);
+            if constexpr (Opts.prettify) {
+               dump<' '>(args...);
+            }
 
-               if constexpr (Opts.prettify) {
-                  dump<'\n'>(args...);
-                  dumpn<Opts.indentation_char>(ctx.indentation_level, args...);
-               }
+            serialize<JSON>::op<Opts>(v.first, ctx, args...); // write deque
+            if (i < n - 1) {
+               dump<','>(std::forward<Args>(args)...);
             }
 
             if constexpr (Opts.prettify) {
-               ctx.indentation_level -= Opts.indentation_width;
                dump<'\n'>(args...);
                dumpn<Opts.indentation_char>(ctx.indentation_level, args...);
             }
-            dump<'}'>(std::forward<Args>(args)...);
          }
-      };
 
-      template <is_recorder T>
-      struct from_json<T>
+         if constexpr (Opts.prettify) {
+            ctx.indentation_level -= Opts.indentation_width;
+            dump<'\n'>(args...);
+            dumpn<Opts.indentation_char>(ctx.indentation_level, args...);
+         }
+         dump<'}'>(args...);
+      }
+   };
+
+   template <is_recorder T>
+   struct from<JSON, T>
+   {
+      template <auto Options>
+      static void op(auto&& value, is_context auto&& ctx, auto&& it, auto&& end)
       {
-         template <auto Options>
-         static void op(auto&& value, is_context auto&& ctx, auto&& it, auto&& end) noexcept
-         {
-            if (bool(ctx.error)) [[unlikely]] {
+         if (bool(ctx.error)) [[unlikely]] {
+            return;
+         }
+
+         constexpr auto Opts = opening_handled_off<ws_handled_off<Options>()>();
+
+         if constexpr (!check_opening_handled(Options)) {
+            if (skip_ws<Opts>(ctx, it, end)) {
                return;
             }
+            if (match_invalid_end<'{', Opts>(ctx, it, end)) {
+               return;
+            }
+         }
 
-            constexpr auto Opts = opening_handled_off<ws_handled_off<Options>()>();
+         if (skip_ws<Opts>(ctx, it, end)) {
+            return;
+         }
 
-            if constexpr (!Options.opening_handled) {
-               GLZ_SKIP_WS;
-               GLZ_MATCH_OPEN_BRACE;
+         // we read into available containers, we do not intialize here
+         const size_t n = value.data.size();
+         for (size_t i = 0; i < n; ++i) {
+            if (*it == '}') [[unlikely]] {
+               ctx.error = error_code::expected_brace;
             }
 
-            GLZ_SKIP_WS;
+            // find the string, escape characters are not supported for recorders
+            if (skip_ws<Opts>(ctx, it, end)) {
+               return;
+            }
+            const auto name = parse_key(ctx, it, end);
 
-            // we read into available containers, we do not intialize here
-            const size_t n = value.data.size();
-            for (size_t i = 0; i < n; ++i) {
-               if (*it == '}') [[unlikely]] {
-                  ctx.error = error_code::expected_brace;
-               }
+            auto& [str, v] = value.data[i];
+            if (name != str) {
+               ctx.error = error_code::name_mismatch; // Recorder read of name does not match initialized state
+               return;
+            }
+
+            if (skip_ws<Opts>(ctx, it, end)) {
+               return;
+            }
+            if (match_invalid_end<':', Opts>(ctx, it, end)) {
+               return;
+            }
+            if (skip_ws<Opts>(ctx, it, end)) {
+               return;
+            }
 
-               // find the string, escape characters are not supported for recorders
-               GLZ_SKIP_WS;
-               const auto name = parse_key(ctx, it, end);
+            std::visit([&](auto&& deq) { parse<JSON>::op<Opts>(deq, ctx, it, end); }, v.first);
 
-               auto& [str, v] = value.data[i];
-               if (name != str) {
-                  ctx.error = error_code::name_mismatch; // Recorder read of name does not match initialized state
+            if (i < n - 1) {
+               if (skip_ws<Opts>(ctx, it, end)) {
                   return;
                }
-
-               GLZ_SKIP_WS;
-               GLZ_MATCH_COLON;
-               GLZ_SKIP_WS;
-
-               std::visit([&](auto&& deq) { read<json>::op<Opts>(deq, ctx, it, end); }, v.first);
-
-               if (i < n - 1) {
-                  GLZ_SKIP_WS;
-                  GLZ_MATCH_COMMA;
-                  GLZ_SKIP_WS;
+               if (match_invalid_end<',', Opts>(ctx, it, end)) {
+                  return;
+               }
+               if (skip_ws<Opts>(ctx, it, end)) {
+                  return;
                }
             }
+         }
 
-            GLZ_SKIP_WS;
-            match<'}'>(ctx, it);
+         if (skip_ws<Opts>(ctx, it, end)) {
+            return;
          }
-      };
+         match<'}'>(ctx, it);
+      }
+   };
 
-      template <is_recorder T>
-      struct to_csv<T>
+   template <is_recorder T>
+   struct to<CSV, T>
+   {
+      template <auto Opts>
+      static void op(auto&& value, is_context auto&& ctx, auto&&... args)
       {
-         template <auto Opts>
-         static void op(auto&& value, is_context auto&& ctx, auto&&... args) noexcept
-         {
-            if constexpr (Opts.layout == rowwise) {
-               const size_t n = value.data.size();
-               for (size_t i = 0; i < n; ++i) {
-                  auto& [name, v] = value.data[i];
-                  dump_maybe_empty(name, args...);
+         if constexpr (Opts.layout == rowwise) {
+            const size_t n = value.data.size();
+            for (size_t i = 0; i < n; ++i) {
+               auto& [name, v] = value.data[i];
+               dump_maybe_empty(name, args...);
+
+               dump<','>(args...);
 
+               std::visit(
+                  [&](auto& x) {
+                     serialize<CSV>::op<Opts>(x, ctx, args...); // write deque
+                  },
+                  v.first);
+
+               if (i < n - 1) {
+                  dump<'\n'>(args...);
+               }
+            }
+         }
+         else {
+            // dump titles
+            const auto n = value.data.size();
+            size_t i = 0;
+            for (auto& [name, data] : value.data) {
+               dump_maybe_empty(name, args...);
+               ++i;
+               if (i < n) {
                   dump<','>(args...);
+               }
+            }
+
+            dump<'\n'>(args...);
 
+            size_t row = 0;
+            bool end = false;
+            while (true) {
+               i = 0;
+               for (auto& [name, data] : value.data) {
+                  bool breakout = false;
                   std::visit(
-                     [&](auto& x) {
-                        write<csv>::op<Opts>(x, ctx, args...); // write deque
+                     [&](auto& v) {
+                        if (row >= v.size()) {
+                           end = true;
+                           breakout = true;
+                           return;
+                        }
+                        serialize<CSV>::op<Opts>(v[row], ctx, args...); // write deque
                      },
-                     v.first);
+                     data.first);
 
-                  if (i < n - 1) {
-                     dump<'\n'>(args...);
+                  if (breakout) {
+                     break;
                   }
-               }
-            }
-            else {
-               // dump titles
-               const auto n = value.data.size();
-               size_t i = 0;
-               for (auto& [name, data] : value.data) {
-                  dump_maybe_empty(name, args...);
+
                   ++i;
                   if (i < n) {
                      dump<','>(args...);
                   }
                }
 
-               dump<'\n'>(args...);
-
-               size_t row = 0;
-               bool end = false;
-               while (true) {
-                  i = 0;
-                  for (auto& [name, data] : value.data) {
-                     bool breakout = false;
-                     std::visit(
-                        [&](auto& v) {
-                           if (row >= v.size()) {
-                              end = true;
-                              breakout = true;
-                              return;
-                           }
-                           write<csv>::op<Opts>(v[row], ctx, args...); // write deque
-                        },
-                        data.first);
-
-                     if (breakout) {
-                        break;
-                     }
-
-                     ++i;
-                     if (i < n) {
-                        dump<','>(args...);
-                     }
-                  }
-
-                  if (end) {
-                     break;
-                  }
+               if (end) {
+                  break;
+               }
 
-                  dump<'\n'>(args...);
+               dump<'\n'>(args...);
 
-                  ++row;
-               }
+               ++row;
             }
          }
-      };
-   }
+      }
+   };
 }
diff --git a/deps/saucer/include/glaze/reflection/get_name.hpp b/deps/saucer/include/glaze/reflection/get_name.hpp
index 2956148..d14b5a3 100644
--- a/deps/saucer/include/glaze/reflection/get_name.hpp
+++ b/deps/saucer/include/glaze/reflection/get_name.hpp
@@ -5,6 +5,8 @@
 
 // TODO: Use std::source_location when deprecating clang 14
 // #include <source_location>
+#include <array>
+#include <string>
 #include <string_view>
 
 #include "glaze/reflection/to_tuple.hpp"
@@ -19,6 +21,9 @@
 // For struct fields
 namespace glz::detail
 {
+   // Do not const qualify this value to avoid duplicate `to_tie` template instantiations with rest of Glaze
+   // Temporary fix: const qualify it despite. Caused issues with reflect begin/end indices
+   // See https://github.com/stephenberry/glaze/issues/1568
    template <class T>
    extern const T external;
 
@@ -78,7 +83,7 @@ namespace glz::detail
 namespace glz
 {
    template <auto N, class T>
-   struct nameof_impl
+   struct member_nameof_impl
    {
       static constexpr auto name = detail::get_name_impl<N, T>;
       static constexpr auto begin = name.find(detail::reflect_field::end);
@@ -89,7 +94,7 @@ namespace glz
    };
 
    template <auto N, class T>
-   constexpr auto nameof = []() constexpr { return nameof_impl<N, T>::stripped_literal; }();
+   inline constexpr auto member_nameof = []() constexpr { return member_nameof_impl<N, T>::stripped_literal; }();
 
    template <class T>
    constexpr auto type_name = [] {
@@ -108,7 +113,86 @@ namespace glz
    template <class T, size_t... I>
    [[nodiscard]] constexpr auto member_names_impl(std::index_sequence<I...>)
    {
-      return std::array{nameof<I, T>...};
+      if constexpr (sizeof...(I) == 0) {
+         return std::array<sv, 0>{};
+      }
+      else {
+         return std::array{member_nameof<I, T>...};
+      }
+   }
+
+   template <class T>
+   struct meta;
+
+   // Concept for when rename_key returns exactly std::string (allocates)
+   template <class T>
+   concept meta_has_rename_key_string = requires(T t, const std::string_view s) {
+      { glz::meta<std::remove_cvref_t<T>>::rename_key(s) } -> std::same_as<std::string>;
+   };
+
+   template <std::pair V>
+   struct make_static
+   {
+      static constexpr auto value = V;
+   };
+
+   template <meta_has_rename_key_string T, size_t... I>
+   [[nodiscard]] constexpr auto member_names_impl(std::index_sequence<I...>)
+   {
+      if constexpr (sizeof...(I) == 0) {
+         return std::array<sv, 0>{};
+      }
+      else {
+         return std::array{[]() -> sv {
+         // Need to move allocation into a new static buffer
+#ifdef __clang__
+            static constexpr auto arr = [] {
+               constexpr auto str = glz::meta<std::remove_cvref_t<T>>::rename_key(member_nameof<I, T>);
+               constexpr size_t len = str.size();
+               std::array<char, len + 1> arr;
+               for (size_t i = 0; i < len; ++i) {
+                  arr[i] = str[i];
+               }
+               arr[len] = '\0';
+               return arr;
+            }();
+            return {arr.data(), arr.size() - 1};
+#else
+            // GCC does not support constexpr designation on std::string
+            // We therefore limit to a maximum of 64 characters on GCC for key transformations
+            constexpr auto arr_temp = [] {
+               const auto str = glz::meta<std::remove_cvref_t<T>>::rename_key(member_nameof<I, T>);
+               const size_t len = str.size();
+               std::array<char, 65> arr{};
+               for (size_t i = 0; i < len; ++i) {
+                  arr[i] = str[i];
+               }
+               arr[len] = '\0';
+               return std::pair{arr, len};
+            }();
+            // GCC 12 requires this make_static
+            auto& arr = make_static<arr_temp>::value;
+            return {arr.first.data(), arr.second};
+#endif
+         }()...};
+      }
+   }
+
+   // Concept for when rename_key returns anything convertible to std::string_view EXCEPT std::string (non-allocating)
+   template <class T>
+   concept meta_has_rename_key_convertible = requires(T t, const std::string_view s) {
+      { glz::meta<std::remove_cvref_t<T>>::rename_key(s) } -> std::convertible_to<std::string_view>;
+   } && !meta_has_rename_key_string<T>;
+
+   template <meta_has_rename_key_convertible T, size_t... I>
+   [[nodiscard]] constexpr auto member_names_impl(std::index_sequence<I...>)
+   {
+      if constexpr (sizeof...(I) == 0) {
+         return std::array<sv, 0>{};
+      }
+      else {
+         return std::array{glz::meta<std::remove_cvref_t<T>>::rename_key(member_nameof<I, T>)...};
+      }
    }
 
    template <class T>
@@ -186,7 +270,7 @@ namespace glz
    }
 
    template <auto E>
-      requires(std::is_enum_v<decltype(E)>)
+      requires(std::is_enum_v<decltype(E)> && std::is_scoped_enum_v<decltype(E)>)
    consteval auto get_name()
    {
 #if defined(_MSC_VER) && !defined(__clang__)
@@ -197,6 +281,21 @@ namespace glz
       std::string_view str = GLZ_PRETTY_FUNCTION;
       str = str.substr(str.rfind("::") + 2);
       return str.substr(0, str.find(']'));
+#endif
+   }
+
+   template <auto E>
+      requires(std::is_enum_v<decltype(E)> && not std::is_scoped_enum_v<decltype(E)>)
+   consteval auto get_name()
+   {
+#if defined(_MSC_VER) && !defined(__clang__)
+      std::string_view str = GLZ_PRETTY_FUNCTION;
+      str = str.substr(str.rfind("= ") + 2);
+      return str.substr(0, str.find('>'));
+#else
+      std::string_view str = GLZ_PRETTY_FUNCTION;
+      str = str.substr(str.rfind("= ") + 2);
+      return str.substr(0, str.find(']'));
 #endif
    }
 }
diff --git a/deps/saucer/include/glaze/reflection/reflect.hpp b/deps/saucer/include/glaze/reflection/reflect.hpp
deleted file mode 100644
index 58d555f..0000000
--- a/deps/saucer/include/glaze/reflection/reflect.hpp
+++ /dev/null
@@ -1,174 +0,0 @@
-// Glaze Library
-// For the license information refer to glaze.hpp
-
-#pragma once
-
-#include <initializer_list>
-
-#include "glaze/core/common.hpp"
-#include "glaze/reflection/get_name.hpp"
-#include "glaze/reflection/to_tuple.hpp"
-
-namespace glz
-{
-   // Use a dummy struct for make_reflectable so that we don't conflict with any user defined constructors
-   struct dummy final
-   {};
-
-   // If you want to make an empty struct or a struct with constructors visible in reflected structs,
-   // add the folllwing constructor to your type:
-   // my_struct(glz::make_reflectable) {}
-   using make_reflectable = std::initializer_list<dummy>;
-
-   namespace detail
-   {
-      template <class Tuple>
-      using reflection_value_tuple_variant_t = typename tuple_ptr_variant<Tuple>::type;
-
-      template <class T, size_t I>
-      struct named_member
-      {
-         static constexpr sv value = get<I>(member_names<T>);
-      };
-
-      template <class T, bool use_hash_comparison, size_t... I>
-      constexpr auto make_reflection_map_impl(std::index_sequence<I...>)
-      {
-         using V = decltype(to_tuple(std::declval<T>()));
-         constexpr auto n = glz::tuple_size_v<V>;
-         constexpr auto members = member_names<T>;
-         static_assert(members.size() == n);
-
-         using value_t = reflection_value_tuple_variant_t<V>;
-
-         if constexpr (n == 0) {
-            return nullptr; // Hack to fix MSVC
-            // static_assert(false_v<T>, "Empty object map is illogical. Handle empty upstream.");
-         }
-         else if constexpr (n == 1) {
-            return micro_map1<value_t, named_member<T, I>::value...>{
-               pair<sv, value_t>{get<I>(members), std::add_pointer_t<glz::tuple_element_t<I, V>>{}}...};
-         }
-         else if constexpr (n == 2) {
-            return micro_map2<value_t, named_member<T, I>::value...>{
-               pair<sv, value_t>{get<I>(members), std::add_pointer_t<glz::tuple_element_t<I, V>>{}}...};
-         }
-         else if constexpr (n < 64) // don't even attempt a first character hash if we have too many keys
-         {
-            constexpr auto& keys = member_names<T>;
-            constexpr auto front_desc = single_char_hash<n>(keys);
-
-            if constexpr (front_desc.valid) {
-               return make_single_char_map<value_t, front_desc>(
-                  {{get<I>(members), std::add_pointer_t<glz::tuple_element_t<I, V>>{}}...});
-            }
-            else {
-               constexpr single_char_hash_opts rear_hash{.is_front_hash = false};
-               constexpr auto back_desc = single_char_hash<n, rear_hash>(keys);
-
-               if constexpr (back_desc.valid) {
-                  return make_single_char_map<value_t, back_desc>(
-                     {{get<I>(members), std::add_pointer_t<glz::tuple_element_t<I, V>>{}}...});
-               }
-               else {
-                  constexpr single_char_hash_opts sum_hash{.is_front_hash = true, .is_sum_hash = true};
-                  constexpr auto sum_desc = single_char_hash<n, sum_hash>(keys);
-
-                  if constexpr (sum_desc.valid) {
-                     return make_single_char_map<value_t, sum_desc>(
-                        {{get<I>(members), std::add_pointer_t<glz::tuple_element_t<I, V>>{}}...});
-                  }
-                  else {
-                     if constexpr (n <= naive_map_max_size) {
-                        constexpr auto naive_desc = naive_map_hash<use_hash_comparison, n>(keys);
-                        return glz::detail::make_naive_map<value_t, naive_desc>(std::array{
-                           pair<sv, value_t>{get<I>(members), std::add_pointer_t<glz::tuple_element_t<I, V>>{}}...});
-                     }
-                     else {
-                        return glz::detail::normal_map<sv, value_t, n, use_hash_comparison>(std::array{
-                           pair<sv, value_t>{get<I>(members), std::add_pointer_t<glz::tuple_element_t<I, V>>{}}...});
-                     }
-                  }
-               }
-            }
-         }
-         else {
-            return glz::detail::normal_map<sv, value_t, n, use_hash_comparison>(
-               std::array{pair<sv, value_t>{get<I>(members), std::add_pointer_t<glz::tuple_element_t<I, V>>{}}...});
-         }
-      }
-
-      template <reflectable T, bool use_hash_comparison = false>
-      constexpr auto make_map()
-         requires(!glaze_t<T> && !array_t<T> && std::is_aggregate_v<std::remove_cvref_t<T>>)
-      {
-         constexpr auto indices = std::make_index_sequence<count_members<T>>{};
-         return make_reflection_map_impl<decay_keep_volatile_t<T>, use_hash_comparison>(indices);
-      }
-
-      template <reflectable T>
-      constexpr void populate_map(T&& value, auto& cmap) noexcept
-      {
-         // we have to populate the pointers in the reflection map from the structured binding
-         auto t = to_tuple(std::forward<T>(value));
-         [&]<size_t... I>(std::index_sequence<I...>) {
-            ((std::get<std::add_pointer_t<decay_keep_volatile_t<decltype(std::get<I>(t))>>>(
-                 std::get<I>(cmap.items).second) = &std::get<I>(t)),
-             ...);
-         }(std::make_index_sequence<count_members<T>>{});
-      }
-
-      // We create const and not-const versions for when our reflected struct is const or non-const qualified
-      template <class Tuple>
-      struct tuple_ptr;
-
-      template <class... Ts>
-      struct tuple_ptr<std::tuple<Ts...>>
-      {
-         using type = std::tuple<std::add_pointer_t<Ts>...>;
-      };
-
-      template <class Tuple>
-      struct tuple_ptr_const;
-
-      template <class... Ts>
-      struct tuple_ptr_const<std::tuple<Ts...>>
-      {
-         using type = std::tuple<std::add_pointer_t<std::add_const_t<std::remove_reference_t<Ts>>>...>;
-      };
-
-      // This is needed to hack a fix for MSVC evaluating wrong `if constexpr` branches
-      template <class T>
-         requires(!reflectable<T>)
-      constexpr auto make_tuple_from_struct() noexcept
-      {
-         return glz::tuplet::tuple{};
-      }
-
-      // This needs to produce const qualified pointers so that we can write out const structs
-      template <reflectable T>
-      constexpr auto make_tuple_from_struct() noexcept
-      {
-         using V = decay_keep_volatile_t<decltype(to_tuple(std::declval<T>()))>;
-         return typename tuple_ptr<V>::type{};
-      }
-
-      template <reflectable T>
-      constexpr auto make_const_tuple_from_struct() noexcept
-      {
-         using V = decay_keep_volatile_t<decltype(to_tuple(std::declval<T>()))>;
-         return typename tuple_ptr_const<V>::type{};
-      }
-
-      template <reflectable T, class TuplePtrs>
-         requires(!std::is_const_v<TuplePtrs>)
-      constexpr void populate_tuple_ptr(T&& value, TuplePtrs& tuple_of_ptrs) noexcept
-      {
-         // we have to populate the pointers in the reflection tuple from the structured binding
-         auto t = to_tuple(std::forward<T>(value));
-         [&]<size_t... I>(std::index_sequence<I...>) {
-            ((std::get<I>(tuple_of_ptrs) = &std::get<I>(t)), ...);
-         }(std::make_index_sequence<count_members<T>>{});
-      }
-   }
-}
diff --git a/deps/saucer/include/glaze/reflection/to_tuple.hpp b/deps/saucer/include/glaze/reflection/to_tuple.hpp
index 7b49b7f..43767a2 100644
--- a/deps/saucer/include/glaze/reflection/to_tuple.hpp
+++ b/deps/saucer/include/glaze/reflection/to_tuple.hpp
@@ -9,6 +9,8 @@
 #include <type_traits>
 #include <utility>
 
+#include "glaze/tuplet/tuple.hpp"
+#include "glaze/util/inline.hpp"
 #include "glaze/util/type_traits.hpp"
 
 namespace glz
@@ -52,1257 +54,1220 @@ namespace glz
          }
       }();
 
-      template <class T, size_t N = count_members<T>>
-         requires(N <= 128)
-      constexpr decltype(auto) to_tuple(T&& t)
-      {
-         if constexpr (N == 0) {
-            return std::tuple{};
-         }
-         else if constexpr (N == 1) {
-            auto& [p] = t;
-            return std::tie(p);
-         }
-         else if constexpr (N == 2) {
-            auto& [p0, p1] = t;
-            return std::tie(p0, p1);
-         }
-         else if constexpr (N == 3) {
-            auto& [p0, p1, p2] = t;
-            return std::tie(p0, p1, p2);
-         }
-         else if constexpr (N == 4) {
-            auto& [p0, p1, p2, p3] = t;
-            return std::tie(p0, p1, p2, p3);
-         }
-         else if constexpr (N == 5) {
-            auto& [p0, p1, p2, p3, p4] = t;
-            return std::tie(p0, p1, p2, p3, p4);
-         }
-         else if constexpr (N == 6) {
-            auto& [p0, p1, p2, p3, p4, p5] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5);
-         }
-         else if constexpr (N == 7) {
-            auto& [p0, p1, p2, p3, p4, p5, p6] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6);
-         }
-         else if constexpr (N == 8) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7);
-         }
-         else if constexpr (N == 9) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8);
-         }
-         else if constexpr (N == 10) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9);
-         }
-         else if constexpr (N == 11) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10);
-         }
-         else if constexpr (N == 12) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11);
-         }
-         else if constexpr (N == 13) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12);
-         }
-         else if constexpr (N == 14) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13);
-         }
-         else if constexpr (N == 15) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14);
-         }
-         else if constexpr (N == 16) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15);
-         }
-         else if constexpr (N == 17) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16);
-         }
-         else if constexpr (N == 18) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17);
-         }
-         else if constexpr (N == 19) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18);
-         }
-         else if constexpr (N == 20) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19);
-         }
-         else if constexpr (N == 21) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20);
-         }
-         else if constexpr (N == 22) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21] =
-               t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21);
-         }
-         else if constexpr (N == 23) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22);
-         }
-         else if constexpr (N == 24) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23);
-         }
-         else if constexpr (N == 25) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24);
-         }
-         else if constexpr (N == 26) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25);
-         }
-         else if constexpr (N == 27) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26);
-         }
-         else if constexpr (N == 28) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27);
-         }
-         else if constexpr (N == 29) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28);
-         }
-         else if constexpr (N == 30) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29);
-         }
-         else if constexpr (N == 31) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30);
-         }
-         else if constexpr (N == 32) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31);
-         }
-         else if constexpr (N == 33) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32);
-         }
-         else if constexpr (N == 34) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33);
-         }
-         else if constexpr (N == 35) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34);
-         }
-         else if constexpr (N == 36) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35);
-         }
-         else if constexpr (N == 37) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36);
-         }
-         else if constexpr (N == 38) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37);
-         }
-         else if constexpr (N == 39) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38);
-         }
-         else if constexpr (N == 40) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39);
-         }
-         else if constexpr (N == 41) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39, p40);
-         }
-         else if constexpr (N == 42) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41] =
-               t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39, p40, p41);
-         }
-         else if constexpr (N == 43) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41,
-                   p42] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39, p40, p41, p42);
-         }
-         else if constexpr (N == 44) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41,
-                   p42, p43] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39, p40, p41, p42, p43);
-         }
-         else if constexpr (N == 45) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41,
-                   p42, p43, p44] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39, p40, p41, p42, p43, p44);
-         }
-         else if constexpr (N == 46) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41,
-                   p42, p43, p44, p45] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39, p40, p41, p42, p43, p44, p45);
-         }
-         else if constexpr (N == 47) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41,
-                   p42, p43, p44, p45, p46] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39, p40, p41, p42, p43, p44, p45, p46);
-         }
-         else if constexpr (N == 48) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41,
-                   p42, p43, p44, p45, p46, p47] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39, p40, p41, p42, p43, p44, p45, p46, p47);
-         }
-         else if constexpr (N == 49) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41,
-                   p42, p43, p44, p45, p46, p47, p48] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39, p40, p41, p42, p43, p44, p45, p46, p47, p48);
-         }
-         else if constexpr (N == 50) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41,
-                   p42, p43, p44, p45, p46, p47, p48, p49] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39, p40, p41, p42, p43, p44, p45, p46, p47, p48, p49);
-         }
-         else if constexpr (N == 51) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41,
-                   p42, p43, p44, p45, p46, p47, p48, p49, p50] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39, p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50);
-         }
-         else if constexpr (N == 52) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41,
-                   p42, p43, p44, p45, p46, p47, p48, p49, p50, p51] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39, p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51);
-         }
-         else if constexpr (N == 53) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41,
-                   p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39, p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52);
-         }
-         else if constexpr (N == 54) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41,
-                   p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39, p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53);
-         }
-         else if constexpr (N == 55) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41,
-                   p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39, p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54);
-         }
-         else if constexpr (N == 56) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41,
-                   p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39, p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55);
-         }
-         else if constexpr (N == 57) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41,
-                   p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39, p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55,
-                            p56);
-         }
-         else if constexpr (N == 58) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41,
-                   p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39, p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55,
-                            p56, p57);
-         }
-         else if constexpr (N == 59) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41,
-                   p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39, p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55,
-                            p56, p57, p58);
-         }
-         else if constexpr (N == 60) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41,
-                   p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39, p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55,
-                            p56, p57, p58, p59);
-         }
-         else if constexpr (N == 61) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41,
-                   p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39, p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55,
-                            p56, p57, p58, p59, p60);
-         }
-         else if constexpr (N == 62) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41,
-                   p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61] =
-               t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39, p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55,
-                            p56, p57, p58, p59, p60, p61);
-         }
-         else if constexpr (N == 63) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41,
-                   p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61,
-                   p62] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39, p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55,
-                            p56, p57, p58, p59, p60, p61, p62);
-         }
-         else if constexpr (N == 64) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41,
-                   p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61,
-                   p62, p63] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39, p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55,
-                            p56, p57, p58, p59, p60, p61, p62, p63);
-         }
-         else if constexpr (N == 65) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41,
-                   p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61,
-                   p62, p63, p64] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39, p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55,
-                            p56, p57, p58, p59, p60, p61, p62, p63, p64);
-         }
-         else if constexpr (N == 66) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41,
-                   p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61,
-                   p62, p63, p64, p65] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39, p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55,
-                            p56, p57, p58, p59, p60, p61, p62, p63, p64, p65);
-         }
-         else if constexpr (N == 67) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41,
-                   p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61,
-                   p62, p63, p64, p65, p66] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39, p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55,
-                            p56, p57, p58, p59, p60, p61, p62, p63, p64, p65, p66);
-         }
-         else if constexpr (N == 68) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41,
-                   p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61,
-                   p62, p63, p64, p65, p66, p67] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39, p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55,
-                            p56, p57, p58, p59, p60, p61, p62, p63, p64, p65, p66, p67);
-         }
-         else if constexpr (N == 69) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41,
-                   p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61,
-                   p62, p63, p64, p65, p66, p67, p68] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39, p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55,
-                            p56, p57, p58, p59, p60, p61, p62, p63, p64, p65, p66, p67, p68);
-         }
-         else if constexpr (N == 70) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41,
-                   p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61,
-                   p62, p63, p64, p65, p66, p67, p68, p69] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39, p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55,
-                            p56, p57, p58, p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69);
-         }
-         else if constexpr (N == 71) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41,
-                   p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61,
-                   p62, p63, p64, p65, p66, p67, p68, p69, p70] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39, p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55,
-                            p56, p57, p58, p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70);
-         }
-         else if constexpr (N == 72) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41,
-                   p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61,
-                   p62, p63, p64, p65, p66, p67, p68, p69, p70, p71] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39, p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55,
-                            p56, p57, p58, p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71);
-         }
-         else if constexpr (N == 73) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41,
-                   p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61,
-                   p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39, p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55,
-                            p56, p57, p58, p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72);
-         }
-         else if constexpr (N == 74) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41,
-                   p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61,
-                   p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39, p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55,
-                            p56, p57, p58, p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73);
-         }
-         else if constexpr (N == 75) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41,
-                   p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61,
-                   p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39, p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55,
-                            p56, p57, p58, p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73,
-                            p74);
-         }
-         else if constexpr (N == 76) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41,
-                   p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61,
-                   p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39, p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55,
-                            p56, p57, p58, p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73,
-                            p74, p75);
-         }
-         else if constexpr (N == 77) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41,
-                   p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61,
-                   p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39, p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55,
-                            p56, p57, p58, p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73,
-                            p74, p75, p76);
-         }
-         else if constexpr (N == 78) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41,
-                   p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61,
-                   p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39, p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55,
-                            p56, p57, p58, p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73,
-                            p74, p75, p76, p77);
-         }
-         else if constexpr (N == 79) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41,
-                   p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61,
-                   p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39, p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55,
-                            p56, p57, p58, p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73,
-                            p74, p75, p76, p77, p78);
-         }
-         else if constexpr (N == 80) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41,
-                   p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61,
-                   p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39, p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55,
-                            p56, p57, p58, p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73,
-                            p74, p75, p76, p77, p78, p79);
-         }
-         else if constexpr (N == 81) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41,
-                   p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61,
-                   p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39, p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55,
-                            p56, p57, p58, p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73,
-                            p74, p75, p76, p77, p78, p79, p80);
-         }
-         else if constexpr (N == 82) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41,
-                   p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61,
-                   p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81] =
-               t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39, p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55,
-                            p56, p57, p58, p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73,
-                            p74, p75, p76, p77, p78, p79, p80, p81);
-         }
-         else if constexpr (N == 83) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41,
-                   p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61,
-                   p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81,
-                   p82] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39, p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55,
-                            p56, p57, p58, p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73,
-                            p74, p75, p76, p77, p78, p79, p80, p81, p82);
-         }
-         else if constexpr (N == 84) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41,
-                   p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61,
-                   p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81,
-                   p82, p83] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39, p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55,
-                            p56, p57, p58, p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73,
-                            p74, p75, p76, p77, p78, p79, p80, p81, p82, p83);
-         }
-         else if constexpr (N == 85) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41,
-                   p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61,
-                   p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81,
-                   p82, p83, p84] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39, p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55,
-                            p56, p57, p58, p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73,
-                            p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84);
-         }
-         else if constexpr (N == 86) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41,
-                   p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61,
-                   p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81,
-                   p82, p83, p84, p85] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39, p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55,
-                            p56, p57, p58, p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73,
-                            p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85);
-         }
-         else if constexpr (N == 87) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41,
-                   p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61,
-                   p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81,
-                   p82, p83, p84, p85, p86] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39, p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55,
-                            p56, p57, p58, p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73,
-                            p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, p86);
-         }
-         else if constexpr (N == 88) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41,
-                   p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61,
-                   p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81,
-                   p82, p83, p84, p85, p86, p87] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39, p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55,
-                            p56, p57, p58, p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73,
-                            p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, p86, p87);
-         }
-         else if constexpr (N == 89) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41,
-                   p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61,
-                   p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81,
-                   p82, p83, p84, p85, p86, p87, p88] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39, p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55,
-                            p56, p57, p58, p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73,
-                            p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88);
-         }
-         else if constexpr (N == 90) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41,
-                   p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61,
-                   p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81,
-                   p82, p83, p84, p85, p86, p87, p88, p89] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39, p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55,
-                            p56, p57, p58, p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73,
-                            p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89);
-         }
-         else if constexpr (N == 91) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41,
-                   p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61,
-                   p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81,
-                   p82, p83, p84, p85, p86, p87, p88, p89, p90] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39, p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55,
-                            p56, p57, p58, p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73,
-                            p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90);
-         }
-         else if constexpr (N == 92) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41,
-                   p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61,
-                   p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81,
-                   p82, p83, p84, p85, p86, p87, p88, p89, p90, p91] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39, p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55,
-                            p56, p57, p58, p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73,
-                            p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91);
-         }
-         else if constexpr (N == 93) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41,
-                   p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61,
-                   p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81,
-                   p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39, p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55,
-                            p56, p57, p58, p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73,
-                            p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91,
-                            p92);
-         }
-         else if constexpr (N == 94) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41,
-                   p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61,
-                   p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81,
-                   p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39, p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55,
-                            p56, p57, p58, p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73,
-                            p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91,
-                            p92, p93);
-         }
-         else if constexpr (N == 95) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41,
-                   p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61,
-                   p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81,
-                   p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39, p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55,
-                            p56, p57, p58, p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73,
-                            p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91,
-                            p92, p93, p94);
-         }
-         else if constexpr (N == 96) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41,
-                   p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61,
-                   p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81,
-                   p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39, p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55,
-                            p56, p57, p58, p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73,
-                            p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91,
-                            p92, p93, p94, p95);
-         }
-         else if constexpr (N == 97) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41,
-                   p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61,
-                   p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81,
-                   p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39, p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55,
-                            p56, p57, p58, p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73,
-                            p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91,
-                            p92, p93, p94, p95, p96);
-         }
-         else if constexpr (N == 98) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41,
-                   p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61,
-                   p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81,
-                   p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39, p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55,
-                            p56, p57, p58, p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73,
-                            p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91,
-                            p92, p93, p94, p95, p96, p97);
-         }
-         else if constexpr (N == 99) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41,
-                   p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61,
-                   p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81,
-                   p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39, p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55,
-                            p56, p57, p58, p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73,
-                            p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91,
-                            p92, p93, p94, p95, p96, p97, p98);
-         }
-         else if constexpr (N == 100) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41,
-                   p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61,
-                   p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81,
-                   p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39, p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55,
-                            p56, p57, p58, p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73,
-                            p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91,
-                            p92, p93, p94, p95, p96, p97, p98, p99);
-         }
-         else if constexpr (N == 101) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41,
-                   p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61,
-                   p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81,
-                   p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39, p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55,
-                            p56, p57, p58, p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73,
-                            p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91,
-                            p92, p93, p94, p95, p96, p97, p98, p99, p100);
-         }
-         else if constexpr (N == 102) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41,
-                   p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61,
-                   p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81,
-                   p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100,
-                   p101] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39, p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55,
-                            p56, p57, p58, p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73,
-                            p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91,
-                            p92, p93, p94, p95, p96, p97, p98, p99, p100, p101);
-         }
-         else if constexpr (N == 103) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41,
-                   p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61,
-                   p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81,
-                   p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101,
-                   p102] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39, p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55,
-                            p56, p57, p58, p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73,
-                            p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91,
-                            p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102);
-         }
-         else if constexpr (N == 104) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41,
-                   p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61,
-                   p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81,
-                   p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101,
-                   p102, p103] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39, p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55,
-                            p56, p57, p58, p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73,
-                            p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91,
-                            p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103);
-         }
-         else if constexpr (N == 105) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41,
-                   p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61,
-                   p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81,
-                   p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101,
-                   p102, p103, p104] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39, p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55,
-                            p56, p57, p58, p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73,
-                            p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91,
-                            p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104);
-         }
-         else if constexpr (N == 106) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41,
-                   p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61,
-                   p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81,
-                   p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101,
-                   p102, p103, p104, p105] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39, p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55,
-                            p56, p57, p58, p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73,
-                            p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91,
-                            p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, p105);
-         }
-         else if constexpr (N == 107) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41,
-                   p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61,
-                   p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81,
-                   p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101,
-                   p102, p103, p104, p105, p106] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39, p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55,
-                            p56, p57, p58, p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73,
-                            p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91,
-                            p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, p105, p106);
-         }
-         else if constexpr (N == 108) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41,
-                   p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61,
-                   p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81,
-                   p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101,
-                   p102, p103, p104, p105, p106, p107] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39, p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55,
-                            p56, p57, p58, p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73,
-                            p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91,
-                            p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107);
-         }
-         else if constexpr (N == 109) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41,
-                   p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61,
-                   p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81,
-                   p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101,
-                   p102, p103, p104, p105, p106, p107, p108] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39, p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55,
-                            p56, p57, p58, p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73,
-                            p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91,
-                            p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107,
-                            p108);
-         }
-         else if constexpr (N == 110) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41,
-                   p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61,
-                   p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81,
-                   p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101,
-                   p102, p103, p104, p105, p106, p107, p108, p109] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39, p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55,
-                            p56, p57, p58, p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73,
-                            p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91,
-                            p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107,
-                            p108, p109);
-         }
-         else if constexpr (N == 111) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41,
-                   p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61,
-                   p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81,
-                   p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101,
-                   p102, p103, p104, p105, p106, p107, p108, p109, p110] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39, p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55,
-                            p56, p57, p58, p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73,
-                            p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91,
-                            p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107,
-                            p108, p109, p110);
-         }
-         else if constexpr (N == 112) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41,
-                   p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61,
-                   p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81,
-                   p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101,
-                   p102, p103, p104, p105, p106, p107, p108, p109, p110, p111] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39, p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55,
-                            p56, p57, p58, p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73,
-                            p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91,
-                            p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107,
-                            p108, p109, p110, p111);
-         }
-         else if constexpr (N == 113) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41,
-                   p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61,
-                   p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81,
-                   p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101,
-                   p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39, p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55,
-                            p56, p57, p58, p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73,
-                            p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91,
-                            p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107,
-                            p108, p109, p110, p111, p112);
-         }
-         else if constexpr (N == 114) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41,
-                   p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61,
-                   p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81,
-                   p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101,
-                   p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112, p113] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39, p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55,
-                            p56, p57, p58, p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73,
-                            p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91,
-                            p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107,
-                            p108, p109, p110, p111, p112, p113);
-         }
-         else if constexpr (N == 115) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41,
-                   p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61,
-                   p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81,
-                   p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101,
-                   p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112, p113, p114] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39, p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55,
-                            p56, p57, p58, p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73,
-                            p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91,
-                            p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107,
-                            p108, p109, p110, p111, p112, p113, p114);
-         }
-         else if constexpr (N == 116) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41,
-                   p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61,
-                   p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81,
-                   p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101,
-                   p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39, p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55,
-                            p56, p57, p58, p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73,
-                            p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91,
-                            p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107,
-                            p108, p109, p110, p111, p112, p113, p114, p115);
-         }
-         else if constexpr (N == 117) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41,
-                   p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61,
-                   p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81,
-                   p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101,
-                   p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39, p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55,
-                            p56, p57, p58, p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73,
-                            p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91,
-                            p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107,
-                            p108, p109, p110, p111, p112, p113, p114, p115, p116);
-         }
-         else if constexpr (N == 118) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41,
-                   p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61,
-                   p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81,
-                   p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101,
-                   p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39, p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55,
-                            p56, p57, p58, p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73,
-                            p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91,
-                            p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107,
-                            p108, p109, p110, p111, p112, p113, p114, p115, p116, p117);
-         }
-         else if constexpr (N == 119) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41,
-                   p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61,
-                   p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81,
-                   p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101,
-                   p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117,
-                   p118] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39, p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55,
-                            p56, p57, p58, p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73,
-                            p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91,
-                            p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107,
-                            p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118);
-         }
-         else if constexpr (N == 120) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41,
-                   p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61,
-                   p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81,
-                   p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101,
-                   p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118,
-                   p119] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39, p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55,
-                            p56, p57, p58, p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73,
-                            p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91,
-                            p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107,
-                            p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119);
-         }
-         else if constexpr (N == 121) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41,
-                   p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61,
-                   p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81,
-                   p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101,
-                   p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118,
-                   p119, p120] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39, p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55,
-                            p56, p57, p58, p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73,
-                            p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91,
-                            p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107,
-                            p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119, p120);
-         }
-         else if constexpr (N == 122) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41,
-                   p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61,
-                   p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81,
-                   p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101,
-                   p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118,
-                   p119, p120, p121] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39, p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55,
-                            p56, p57, p58, p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73,
-                            p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91,
-                            p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107,
-                            p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119, p120, p121);
-         }
-         else if constexpr (N == 123) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41,
-                   p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61,
-                   p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81,
-                   p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101,
-                   p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118,
-                   p119, p120, p121, p122] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39, p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55,
-                            p56, p57, p58, p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73,
-                            p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91,
-                            p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107,
-                            p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119, p120, p121, p122);
-         }
-         else if constexpr (N == 124) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41,
-                   p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61,
-                   p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81,
-                   p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101,
-                   p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118,
-                   p119, p120, p121, p122, p123] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39, p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55,
-                            p56, p57, p58, p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73,
-                            p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91,
-                            p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107,
-                            p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119, p120, p121, p122,
-                            p123);
-         }
-         else if constexpr (N == 125) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41,
-                   p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61,
-                   p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81,
-                   p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101,
-                   p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118,
-                   p119, p120, p121, p122, p123, p124] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39, p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55,
-                            p56, p57, p58, p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73,
-                            p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91,
-                            p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107,
-                            p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119, p120, p121, p122,
-                            p123, p124);
-         }
-         else if constexpr (N == 126) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41,
-                   p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61,
-                   p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81,
-                   p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101,
-                   p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118,
-                   p119, p120, p121, p122, p123, p124, p125] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39, p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55,
-                            p56, p57, p58, p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73,
-                            p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91,
-                            p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107,
-                            p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119, p120, p121, p122,
-                            p123, p124, p125);
-         }
-         else if constexpr (N == 127) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41,
-                   p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61,
-                   p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81,
-                   p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101,
-                   p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118,
-                   p119, p120, p121, p122, p123, p124, p125, p126] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39, p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55,
-                            p56, p57, p58, p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73,
-                            p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91,
-                            p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107,
-                            p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119, p120, p121, p122,
-                            p123, p124, p125, p126);
-         }
-         else if constexpr (N == 128) {
-            auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
-                   p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41,
-                   p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61,
-                   p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81,
-                   p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101,
-                   p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118,
-                   p119, p120, p121, p122, p123, p124, p125, p126, p127] = t;
-            return std::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
-                            p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37,
-                            p38, p39, p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55,
-                            p56, p57, p58, p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73,
-                            p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91,
-                            p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107,
-                            p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119, p120, p121, p122,
-                            p123, p124, p125, p126, p127);
-         }
+      constexpr size_t max_pure_reflection_count = 128;
+   }
+
+   template <class T, size_t N = detail::count_members<T>>
+      requires(N <= detail::max_pure_reflection_count)
+   GLZ_ALWAYS_INLINE constexpr decltype(auto) to_tie(T&& t)
+   {
+      if constexpr (N == 0) {
+         return tuple{};
+      }
+      else if constexpr (N == 1) {
+         auto& [p] = t;
+         return glz::tie(p);
+      }
+      else if constexpr (N == 2) {
+         auto& [p0, p1] = t;
+         return glz::tie(p0, p1);
+      }
+      else if constexpr (N == 3) {
+         auto& [p0, p1, p2] = t;
+         return glz::tie(p0, p1, p2);
+      }
+      else if constexpr (N == 4) {
+         auto& [p0, p1, p2, p3] = t;
+         return glz::tie(p0, p1, p2, p3);
+      }
+      else if constexpr (N == 5) {
+         auto& [p0, p1, p2, p3, p4] = t;
+         return glz::tie(p0, p1, p2, p3, p4);
+      }
+      else if constexpr (N == 6) {
+         auto& [p0, p1, p2, p3, p4, p5] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5);
+      }
+      else if constexpr (N == 7) {
+         auto& [p0, p1, p2, p3, p4, p5, p6] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6);
+      }
+      else if constexpr (N == 8) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7);
+      }
+      else if constexpr (N == 9) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8);
+      }
+      else if constexpr (N == 10) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9);
+      }
+      else if constexpr (N == 11) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10);
+      }
+      else if constexpr (N == 12) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11);
+      }
+      else if constexpr (N == 13) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12);
+      }
+      else if constexpr (N == 14) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13);
+      }
+      else if constexpr (N == 15) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14);
+      }
+      else if constexpr (N == 16) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15);
+      }
+      else if constexpr (N == 17) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16);
+      }
+      else if constexpr (N == 18) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17);
+      }
+      else if constexpr (N == 19) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18);
+      }
+      else if constexpr (N == 20) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19);
+      }
+      else if constexpr (N == 21) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20);
+      }
+      else if constexpr (N == 22) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21);
+      }
+      else if constexpr (N == 23) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
+                p22] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22);
+      }
+      else if constexpr (N == 24) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23);
+      }
+      else if constexpr (N == 25) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24);
+      }
+      else if constexpr (N == 26) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25);
+      }
+      else if constexpr (N == 27) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26);
+      }
+      else if constexpr (N == 28) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27);
+      }
+      else if constexpr (N == 29) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28);
+      }
+      else if constexpr (N == 30) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29);
+      }
+      else if constexpr (N == 31) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30);
+      }
+      else if constexpr (N == 32) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31);
+      }
+      else if constexpr (N == 33) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32);
+      }
+      else if constexpr (N == 34) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33);
+      }
+      else if constexpr (N == 35) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34);
+      }
+      else if constexpr (N == 36) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35);
+      }
+      else if constexpr (N == 37) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36);
+      }
+      else if constexpr (N == 38) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37);
+      }
+      else if constexpr (N == 39) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38);
+      }
+      else if constexpr (N == 40) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39);
+      }
+      else if constexpr (N == 41) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
+                         p40);
+      }
+      else if constexpr (N == 42) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
+                         p40, p41);
+      }
+      else if constexpr (N == 43) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
+                         p40, p41, p42);
+      }
+      else if constexpr (N == 44) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42,
+                p43] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
+                         p40, p41, p42, p43);
+      }
+      else if constexpr (N == 45) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
+                p44] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
+                         p40, p41, p42, p43, p44);
+      }
+      else if constexpr (N == 46) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
+                p44, p45] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
+                         p40, p41, p42, p43, p44, p45);
+      }
+      else if constexpr (N == 47) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
+                p44, p45, p46] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
+                         p40, p41, p42, p43, p44, p45, p46);
+      }
+      else if constexpr (N == 48) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
+                p44, p45, p46, p47] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
+                         p40, p41, p42, p43, p44, p45, p46, p47);
+      }
+      else if constexpr (N == 49) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
+                p44, p45, p46, p47, p48] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
+                         p40, p41, p42, p43, p44, p45, p46, p47, p48);
+      }
+      else if constexpr (N == 50) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
+                p44, p45, p46, p47, p48, p49] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
+                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49);
+      }
+      else if constexpr (N == 51) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
+                p44, p45, p46, p47, p48, p49, p50] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
+                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50);
+      }
+      else if constexpr (N == 52) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
+                p44, p45, p46, p47, p48, p49, p50, p51] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
+                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51);
+      }
+      else if constexpr (N == 53) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
+                p44, p45, p46, p47, p48, p49, p50, p51, p52] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
+                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52);
+      }
+      else if constexpr (N == 54) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
+                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
+                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53);
+      }
+      else if constexpr (N == 55) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
+                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
+                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54);
+      }
+      else if constexpr (N == 56) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
+                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
+                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55);
+      }
+      else if constexpr (N == 57) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
+                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
+                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56);
+      }
+      else if constexpr (N == 58) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
+                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
+                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57);
+      }
+      else if constexpr (N == 59) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
+                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
+                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58);
+      }
+      else if constexpr (N == 60) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
+                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
+                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
+                         p59);
+      }
+      else if constexpr (N == 61) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
+                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
+                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
+                         p59, p60);
+      }
+      else if constexpr (N == 62) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
+                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
+                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
+                         p59, p60, p61);
+      }
+      else if constexpr (N == 63) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
+                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
+                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
+                         p59, p60, p61, p62);
+      }
+      else if constexpr (N == 64) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
+                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
+                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
+                         p59, p60, p61, p62, p63);
+      }
+      else if constexpr (N == 65) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
+                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63,
+                p64] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
+                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
+                         p59, p60, p61, p62, p63, p64);
       }
+      else if constexpr (N == 66) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
+                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
+                p65] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
+                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
+                         p59, p60, p61, p62, p63, p64, p65);
+      }
+      else if constexpr (N == 67) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
+                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
+                p65, p66] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
+                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
+                         p59, p60, p61, p62, p63, p64, p65, p66);
+      }
+      else if constexpr (N == 68) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
+                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
+                p65, p66, p67] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
+                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
+                         p59, p60, p61, p62, p63, p64, p65, p66, p67);
+      }
+      else if constexpr (N == 69) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
+                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
+                p65, p66, p67, p68] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
+                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
+                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68);
+      }
+      else if constexpr (N == 70) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
+                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
+                p65, p66, p67, p68, p69] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
+                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
+                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69);
+      }
+      else if constexpr (N == 71) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
+                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
+                p65, p66, p67, p68, p69, p70] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
+                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
+                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70);
+      }
+      else if constexpr (N == 72) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
+                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
+                p65, p66, p67, p68, p69, p70, p71] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
+                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
+                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71);
+      }
+      else if constexpr (N == 73) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
+                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
+                p65, p66, p67, p68, p69, p70, p71, p72] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
+                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
+                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72);
+      }
+      else if constexpr (N == 74) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
+                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
+                p65, p66, p67, p68, p69, p70, p71, p72, p73] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
+                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
+                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73);
+      }
+      else if constexpr (N == 75) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
+                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
+                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
+                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
+                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74);
+      }
+      else if constexpr (N == 76) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
+                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
+                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
+                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
+                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75);
+      }
+      else if constexpr (N == 77) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
+                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
+                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
+                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
+                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76);
+      }
+      else if constexpr (N == 78) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
+                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
+                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
+                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
+                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77);
+      }
+      else if constexpr (N == 79) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
+                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
+                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
+                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
+                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
+                         p78);
+      }
+      else if constexpr (N == 80) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
+                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
+                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
+                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
+                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
+                         p78, p79);
+      }
+      else if constexpr (N == 81) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
+                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
+                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
+                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
+                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
+                         p78, p79, p80);
+      }
+      else if constexpr (N == 82) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
+                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
+                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
+                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
+                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
+                         p78, p79, p80, p81);
+      }
+      else if constexpr (N == 83) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
+                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
+                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
+                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
+                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
+                         p78, p79, p80, p81, p82);
+      }
+      else if constexpr (N == 84) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
+                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
+                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
+                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
+                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
+                         p78, p79, p80, p81, p82, p83);
+      }
+      else if constexpr (N == 85) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
+                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
+                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
+                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
+                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
+                         p78, p79, p80, p81, p82, p83, p84);
+      }
+      else if constexpr (N == 86) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
+                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
+                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84,
+                p85] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
+                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
+                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
+                         p78, p79, p80, p81, p82, p83, p84, p85);
+      }
+      else if constexpr (N == 87) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
+                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
+                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
+                p86] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
+                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
+                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
+                         p78, p79, p80, p81, p82, p83, p84, p85, p86);
+      }
+      else if constexpr (N == 88) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
+                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
+                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
+                p86, p87] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
+                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
+                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
+                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87);
+      }
+      else if constexpr (N == 89) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
+                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
+                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
+                p86, p87, p88] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
+                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
+                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
+                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88);
+      }
+      else if constexpr (N == 90) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
+                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
+                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
+                p86, p87, p88, p89] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
+                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
+                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
+                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89);
+      }
+      else if constexpr (N == 91) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
+                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
+                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
+                p86, p87, p88, p89, p90] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
+                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
+                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
+                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90);
+      }
+      else if constexpr (N == 92) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
+                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
+                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
+                p86, p87, p88, p89, p90, p91] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
+                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
+                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
+                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91);
+      }
+      else if constexpr (N == 93) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
+                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
+                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
+                p86, p87, p88, p89, p90, p91, p92] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
+                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
+                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
+                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92);
+      }
+      else if constexpr (N == 94) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
+                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
+                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
+                p86, p87, p88, p89, p90, p91, p92, p93] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
+                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
+                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
+                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93);
+      }
+      else if constexpr (N == 95) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
+                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
+                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
+                p86, p87, p88, p89, p90, p91, p92, p93, p94] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
+                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
+                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
+                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94);
+      }
+      else if constexpr (N == 96) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
+                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
+                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
+                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
+                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
+                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
+                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95);
+      }
+      else if constexpr (N == 97) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
+                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
+                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
+                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
+                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
+                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
+                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96);
+      }
+      else if constexpr (N == 98) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
+                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
+                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
+                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
+                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
+                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
+                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
+                         p97);
+      }
+      else if constexpr (N == 99) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
+                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
+                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
+                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
+                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
+                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
+                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
+                         p97, p98);
+      }
+      else if constexpr (N == 100) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
+                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
+                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
+                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
+                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
+                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
+                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
+                         p97, p98, p99);
+      }
+      else if constexpr (N == 101) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
+                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
+                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
+                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
+                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
+                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
+                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
+                         p97, p98, p99, p100);
+      }
+      else if constexpr (N == 102) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
+                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
+                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
+                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
+                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
+                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
+                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
+                         p97, p98, p99, p100, p101);
+      }
+      else if constexpr (N == 103) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
+                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
+                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
+                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
+                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
+                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
+                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
+                         p97, p98, p99, p100, p101, p102);
+      }
+      else if constexpr (N == 104) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
+                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
+                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
+                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
+                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
+                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
+                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
+                         p97, p98, p99, p100, p101, p102, p103);
+      }
+      else if constexpr (N == 105) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
+                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
+                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
+                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
+                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
+                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
+                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
+                         p97, p98, p99, p100, p101, p102, p103, p104);
+      }
+      else if constexpr (N == 106) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
+                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
+                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
+                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
+                p105] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
+                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
+                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
+                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
+                         p97, p98, p99, p100, p101, p102, p103, p104, p105);
+      }
+      else if constexpr (N == 107) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
+                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
+                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
+                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
+                p105, p106] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
+                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
+                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
+                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
+                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106);
+      }
+      else if constexpr (N == 108) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
+                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
+                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
+                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
+                p105, p106, p107] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
+                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
+                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
+                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
+                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107);
+      }
+      else if constexpr (N == 109) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
+                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
+                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
+                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
+                p105, p106, p107, p108] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
+                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
+                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
+                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
+                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108);
+      }
+      else if constexpr (N == 110) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
+                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
+                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
+                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
+                p105, p106, p107, p108, p109] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
+                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
+                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
+                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
+                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109);
+      }
+      else if constexpr (N == 111) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
+                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
+                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
+                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
+                p105, p106, p107, p108, p109, p110] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
+                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
+                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
+                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
+                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110);
+      }
+      else if constexpr (N == 112) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
+                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
+                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
+                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
+                p105, p106, p107, p108, p109, p110, p111] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
+                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
+                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
+                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
+                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111);
+      }
+      else if constexpr (N == 113) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
+                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
+                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
+                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
+                p105, p106, p107, p108, p109, p110, p111, p112] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
+                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
+                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
+                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
+                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112);
+      }
+      else if constexpr (N == 114) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
+                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
+                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
+                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
+                p105, p106, p107, p108, p109, p110, p111, p112, p113] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
+                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
+                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
+                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
+                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112,
+                         p113);
+      }
+      else if constexpr (N == 115) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
+                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
+                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
+                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
+                p105, p106, p107, p108, p109, p110, p111, p112, p113, p114] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
+                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
+                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
+                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
+                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112,
+                         p113, p114);
+      }
+      else if constexpr (N == 116) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
+                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
+                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
+                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
+                p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
+                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
+                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
+                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
+                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112,
+                         p113, p114, p115);
+      }
+      else if constexpr (N == 117) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
+                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
+                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
+                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
+                p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
+                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
+                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
+                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
+                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112,
+                         p113, p114, p115, p116);
+      }
+      else if constexpr (N == 118) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
+                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
+                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
+                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
+                p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
+                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
+                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
+                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
+                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112,
+                         p113, p114, p115, p116, p117);
+      }
+      else if constexpr (N == 119) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
+                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
+                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
+                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
+                p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
+                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
+                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
+                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
+                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112,
+                         p113, p114, p115, p116, p117, p118);
+      }
+      else if constexpr (N == 120) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
+                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
+                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
+                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
+                p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
+                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
+                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
+                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
+                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112,
+                         p113, p114, p115, p116, p117, p118, p119);
+      }
+      else if constexpr (N == 121) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
+                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
+                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
+                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
+                p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119, p120] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
+                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
+                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
+                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
+                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112,
+                         p113, p114, p115, p116, p117, p118, p119, p120);
+      }
+      else if constexpr (N == 122) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
+                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
+                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
+                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
+                p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119, p120, p121] =
+            t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
+                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
+                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
+                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
+                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112,
+                         p113, p114, p115, p116, p117, p118, p119, p120, p121);
+      }
+      else if constexpr (N == 123) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
+                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
+                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
+                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
+                p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119, p120, p121,
+                p122] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
+                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
+                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
+                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
+                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112,
+                         p113, p114, p115, p116, p117, p118, p119, p120, p121, p122);
+      }
+      else if constexpr (N == 124) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
+                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
+                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
+                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
+                p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119, p120, p121,
+                p122, p123] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
+                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
+                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
+                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
+                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112,
+                         p113, p114, p115, p116, p117, p118, p119, p120, p121, p122, p123);
+      }
+      else if constexpr (N == 125) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
+                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
+                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
+                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
+                p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119, p120, p121,
+                p122, p123, p124] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
+                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
+                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
+                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
+                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112,
+                         p113, p114, p115, p116, p117, p118, p119, p120, p121, p122, p123, p124);
+      }
+      else if constexpr (N == 126) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
+                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
+                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
+                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
+                p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119, p120, p121,
+                p122, p123, p124, p125] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
+                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
+                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
+                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
+                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112,
+                         p113, p114, p115, p116, p117, p118, p119, p120, p121, p122, p123, p124, p125);
+      }
+      else if constexpr (N == 127) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
+                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
+                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
+                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
+                p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119, p120, p121,
+                p122, p123, p124, p125, p126] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
+                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
+                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
+                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
+                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112,
+                         p113, p114, p115, p116, p117, p118, p119, p120, p121, p122, p123, p124, p125, p126);
+      }
+      else if constexpr (N == 128) {
+         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
+                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
+                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
+                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
+                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
+                p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119, p120, p121,
+                p122, p123, p124, p125, p126, p127] = t;
+         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
+                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
+                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
+                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
+                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112,
+                         p113, p114, p115, p116, p117, p118, p119, p120, p121, p122, p123, p124, p125, p126, p127);
+      }
+   }
 
+   namespace detail
+   {
       template <class T>
       struct ptr_t final
       {
@@ -1312,7 +1277,7 @@ namespace glz
       template <size_t N, class T>
       constexpr auto get_ptr(T&& t) noexcept
       {
-         auto& p = std::get<N>(to_tuple(t));
+         auto& p = get<N>(to_tie(t));
          return ptr_t<std::remove_cvref_t<decltype(p)>>{&p};
       }
    }
diff --git a/deps/saucer/include/glaze/rpc/registry.hpp b/deps/saucer/include/glaze/rpc/registry.hpp
new file mode 100644
index 0000000..817506d
--- /dev/null
+++ b/deps/saucer/include/glaze/rpc/registry.hpp
@@ -0,0 +1,217 @@
+// Glaze Library
+// For the license information refer to glaze.hpp
+
+#pragma once
+
+#include "glaze/glaze.hpp"
+#include "glaze/rpc/repe/repe.hpp"
+
+namespace glz
+{
+   namespace detail
+   {
+      static constexpr std::string_view empty_path = "";
+   }
+
+   // Forward declaration of implementation template
+   template <auto Opts, uint32_t Protocol>
+   struct registry_impl;
+}
+
+// Include implementation files
+#include "glaze/net/rest_registry_impl.hpp"
+#include "glaze/rpc/repe/repe_registry_impl.hpp"
+
+namespace glz
+{
+   // This registry does not support adding methods from RPC calls or adding methods once RPC calls can be made.
+   template <auto Opts = opts{}, uint32_t Proto = REPE>
+   struct registry
+   {
+      // procedure for REPE protocol
+      using procedure = std::function<void(repe::state&&)>; // RPC method
+
+      static constexpr auto protocol = Proto;
+
+      typename protocol_storage<Proto>::type endpoints{};
+
+      void clear() { endpoints.clear(); }
+
+      // Register a C++ type that stores pointers to the value, so be sure to keep the registered value alive
+      template <const std::string_view& root = detail::empty_path, class T, const std::string_view& parent = root>
+         requires(glaze_object_t<T> || reflectable<T>)
+      void on(T& value)
+      {
+         using namespace glz::detail;
+         static constexpr auto N = reflect<T>::size;
+
+         [[maybe_unused]] decltype(auto) t = [&]() -> decltype(auto) {
+            if constexpr (reflectable<T> && requires { to_tie(value); }) {
+               return to_tie(value);
+            }
+            else {
+               return nullptr;
+            }
+         }();
+
+         using impl = registry_impl<Opts, Proto>;
+
+         if constexpr (parent == root && (glaze_object_t<T> || reflectable<T>)) {
+            impl::register_endpoint(root, value, *this);
+         }
+
+         for_each<N>([&]<auto I>() {
+            decltype(auto) func = [&]() -> decltype(auto) {
+               if constexpr (reflectable<T>) {
+                  return get_member(value, get<I>(t));
+               }
+               else {
+                  return get_member(value, get<I>(reflect<T>::values));
+               }
+            }();
+
+            static constexpr auto key = reflect<T>::keys[I];
+
+            static constexpr std::string_view full_key = [&] {
+               if constexpr (parent == detail::empty_path) {
+                  return join_v<chars<"/">, key>;
+               }
+               else {
+                  return join_v<parent, chars<"/">, key>;
+               }
+            }();
+
+            // This logic chain should match glz::cli_menu
+            using Func = decltype(func);
+            if constexpr (std::is_invocable_v<Func>) {
+               using Result = std::decay_t<std::invoke_result_t<Func>>;
+               impl::template register_function_endpoint<Func, Result>(full_key, func, *this);
+            }
+            else if constexpr (is_invocable_concrete<std::remove_cvref_t<Func>>) {
+               using Tuple = invocable_args_t<std::remove_cvref_t<Func>>;
+               constexpr auto N = glz::tuple_size_v<Tuple>;
+               static_assert(N == 1, "Only one input is allowed for your function");
+
+               using Params = glz::tuple_element_t<0, Tuple>;
+
+               impl::template register_param_function_endpoint<Func, Params>(full_key, func, *this);
+            }
+            else if constexpr (glaze_object_t<std::remove_cvref_t<Func>> || reflectable<std::remove_cvref_t<Func>>) {
+               on<root, std::remove_cvref_t<Func>, full_key>(func);
+
+               impl::template register_object_endpoint<std::remove_cvref_t<Func>>(full_key, func, *this);
+            }
+            else if constexpr (not std::is_lvalue_reference_v<Func>) {
+               // For glz::custom, glz::manage, etc.
+               impl::template register_value_endpoint<std::remove_cvref_t<Func>>(full_key, func, *this);
+            }
+            else {
+               static_assert(std::is_lvalue_reference_v<Func>);
+
+               if constexpr (std::is_member_function_pointer_v<std::decay_t<Func>>) {
+                  using F = std::decay_t<Func>;
+                  using Ret = typename return_type<F>::type;
+                  using Tuple = typename inputs_as_tuple<F>::type;
+                  constexpr auto n_args = glz::tuple_size_v<Tuple>;
+                  if constexpr (std::is_void_v<Ret>) {
+                     if constexpr (n_args == 0) {
+                        impl::template register_member_function_endpoint<T, F, void>(full_key, value, func, *this);
+                     }
+                     else if constexpr (n_args == 1) {
+                        using Input = std::decay_t<glz::tuple_element_t<0, Tuple>>;
+                        impl::template register_member_function_with_params_endpoint<T, F, Input, void>(full_key, value,
+                                                                                                        func, *this);
+                     }
+                     else {
+                        static_assert(false_v<Func>, "function cannot have more than one input");
+                     }
+                  }
+                  else {
+                     // Member function pointers
+                     if constexpr (n_args == 0) {
+                        impl::template register_member_function_endpoint<T, F, Ret>(full_key, value, func, *this);
+                     }
+                     else if constexpr (n_args == 1) {
+                        using Input = std::decay_t<glz::tuple_element_t<0, Tuple>>;
+                        impl::template register_member_function_with_params_endpoint<T, F, Input, Ret>(full_key, value,
+                                                                                                       func, *this);
+                     }
+                     else {
+                        static_assert(false_v<Func>, "function cannot have more than one input");
+                     }
+                  }
+               }
+               else {
+                  // this is a variable and not a function, so we build RPC read/write calls
+                  // We can't remove const here, because const fields need to be able to be written
+                  impl::template register_variable_endpoint<std::remove_reference_t<Func>>(full_key, func, *this);
+               }
+            }
+         });
+      }
+
+      // Function to call methods - only available for REPE protocol
+      template <class In = repe::message, class Out = repe::message>
+         requires(Proto == REPE) // call method is only available for REPE protocol
+      void call(In&& in, Out&& out)
+      {
+         auto write_error = [&](const std::string& body) {
+            out.body = body;
+            out.header.body_length = body.size();
+            out.header.length = sizeof(repe::header) + out.query.size() + out.body.size();
+         };
+
+         // REPE Header Validation
+
+         // Version validation - REPE spec requires version 1
+         if (in.header.version != 1) {
+            out.header.ec = error_code::version_mismatch;
+            out.header.id = in.header.id; // Echo back the original ID
+            write_error("REPE version mismatch: expected 1, got " + std::to_string(in.header.version));
+            return;
+         }
+
+         // Length validation - REPE spec requires length = 48 + query_length + body_length
+         const uint64_t expected_length = sizeof(repe::header) + in.header.query_length + in.header.body_length;
+         if (in.header.length != expected_length) {
+            out.header.ec = error_code::invalid_header;
+            out.header.id = in.header.id; // Echo back the original ID
+            write_error("REPE length mismatch: expected " + std::to_string(expected_length) + ", got " +
+                        std::to_string(in.header.length));
+            return;
+         }
+
+         // Magic number validation - REPE spec requires 0x1507
+         if (in.header.spec != 0x1507) {
+            out.header.ec = error_code::invalid_header;
+            out.header.id = in.header.id; // Echo back the original ID
+            write_error("REPE magic number mismatch: expected 0x1507, got 0x" + std::to_string(in.header.spec));
+            return;
+         }
+
+         if (auto it = endpoints.find(in.query); it != endpoints.end()) {
+            if (bool(in.header.ec)) {
+               out = in;
+            }
+            else {
+               try {
+                  it->second(repe::state{in, out}); // handle the body
+               }
+               catch (const std::exception& e) {
+                  out = repe::message{}; // reset the output message because it could have been modified
+                  out.header.query_length = 0;
+                  std::string body = "registry error for `" + in.query + "`: ";
+                  body.append(e.what());
+                  out.header.ec = error_code::parse_error;
+                  write_error(body);
+               }
+            }
+         }
+         else {
+            std::string body = "invalid_query: " + in.query;
+            out.header.ec = error_code::method_not_found;
+            write_error(body);
+         }
+      }
+   };
+}
diff --git a/deps/saucer/include/glaze/rpc/repe.hpp b/deps/saucer/include/glaze/rpc/repe.hpp
deleted file mode 100644
index 2081aa9..0000000
--- a/deps/saucer/include/glaze/rpc/repe.hpp
+++ /dev/null
@@ -1,1205 +0,0 @@
-// Glaze Library
-// For the license information refer to glaze.hpp
-
-#pragma once
-
-#include <mutex>
-#include <shared_mutex>
-#include <thread>
-
-#include "glaze/glaze.hpp"
-
-namespace glz::repe
-{
-   constexpr uint8_t notify = 0b00000001;
-   constexpr uint8_t empty = 0b00000010;
-
-   // Note: The method and id are at the top of the class for easier initialization
-   // The order in the serialized message follows the REPE specification
-   struct header final
-   {
-      std::string_view method = ""; // the RPC method (JSON pointer path) to call or member to access/assign (GET/POST)
-      std::variant<std::monostate, uint64_t, std::string_view> id{}; // an identifier
-      static constexpr uint8_t version = 0; // the REPE version
-      uint8_t error = 0; // 0 denotes no error (boolean: 0 or 1)
-
-      // Action: These booleans are packed into the a uint8_t action in the REPE header
-      bool notify{}; // no response returned
-      bool empty{}; // the body should be ignored (considered empty)
-   };
-
-   template <class T>
-   concept is_header = std::same_as<std::decay_t<T>, header>;
-}
-
-template <>
-struct glz::meta<glz::repe::header>
-{
-   using T = glz::repe::header;
-   static constexpr sv name = "glz::repe::header"; // Hack to fix MSVC (shouldn't be needed)
-   static constexpr auto read_action = [](T& self, const uint8_t input) {
-      self.notify = input & 0b00000001;
-      self.empty = input & 0b00000010;
-   };
-   static constexpr auto write_action = [](const T& self) {
-      uint8_t action{};
-      action |= self.notify;
-      action |= (self.empty << 1);
-      return action;
-   };
-   static constexpr auto value =
-      glz::array(&T::version, &T::error, custom<read_action, write_action>, &T::method, &T::id);
-};
-
-namespace glz::repe
-{
-   struct error_e
-   {
-      static constexpr int32_t no_error = 0;
-      static constexpr int32_t server_error_lower = -32000;
-      static constexpr int32_t server_error_upper = -32099;
-      static constexpr int32_t invalid_request = -32600;
-      static constexpr int32_t method_not_found = -32601;
-      static constexpr int32_t invalid_params = -32602;
-      static constexpr int32_t internal = -32603;
-      static constexpr int32_t parse_error = -32700;
-
-      static constexpr int32_t timeout = -6000;
-   };
-
-   inline constexpr std::string_view error_code_to_sv(const int32_t e) noexcept
-   {
-      switch (e) {
-      case error_e::no_error: {
-         return "0 [no_error]";
-      }
-      case error_e::server_error_lower: {
-         return "-32000 [server_error_lower]";
-      }
-      case error_e::server_error_upper: {
-         return "-32099 [server_error_upper]";
-      }
-      case error_e::invalid_request: {
-         return "-32600 [invalid_request]";
-      }
-      case error_e::method_not_found: {
-         return "-32601 [method_not_found]";
-      }
-      case error_e::invalid_params: {
-         return "-32602 [invalid_params]";
-      }
-      case error_e::internal: {
-         return "-32603 [internal]";
-      }
-      case error_e::parse_error: {
-         return "-32700 [parse_error]";
-      }
-      case error_e::timeout: {
-         return "-6000 [timeout]";
-      }
-      default: {
-         return "unknown_error_code";
-         break;
-      }
-      };
-   }
-
-   struct error_t final
-   {
-      int32_t code = error_e::no_error;
-      std::string message = "";
-
-      operator bool() const noexcept { return bool(code); }
-
-      struct glaze
-      {
-         using T = error_t;
-         static constexpr auto value = glz::array(&T::code, &T::message);
-      };
-   };
-
-   inline std::string format_error(const error_t& e) noexcept
-   {
-      std::string result = "error: " + std::string(error_code_to_sv(e.code));
-      result += "\n";
-      result += e.message;
-      return result;
-   }
-
-   struct state final
-   {
-      const std::string_view message{};
-      repe::header& header;
-      std::string& response;
-      error_t& error;
-   };
-
-   template <class T>
-   concept is_state = std::same_as<std::decay_t<T>, state>;
-
-   namespace detail
-   {
-      struct string_hash
-      {
-         using is_transparent = void;
-         [[nodiscard]] size_t operator()(const char* txt) const { return std::hash<std::string_view>{}(txt); }
-         [[nodiscard]] size_t operator()(std::string_view txt) const { return std::hash<std::string_view>{}(txt); }
-         [[nodiscard]] size_t operator()(const std::string& txt) const { return std::hash<std::string>{}(txt); }
-      };
-   }
-
-   // returns 0 on error
-   template <opts Opts, class Value>
-   size_t read_params(Value&& value, auto&& state, auto&& response)
-   {
-      glz::context ctx{};
-      auto [b, e] = read_iterators<Opts>(ctx, state.message);
-      if (bool(ctx.error)) [[unlikely]] {
-         return 0;
-      }
-      auto start = b;
-
-      glz::detail::read<Opts.format>::template op<Opts>(std::forward<Value>(value), ctx, b, e);
-
-      if (bool(ctx.error)) {
-         error_ctx ec{ctx.error, size_t(b - start), ctx.includer_error};
-         std::ignore =
-            write<Opts>(std::forward_as_tuple(header{.error = true},
-                                              error_t{error_e::parse_error, format_error(ec, state.message)}),
-                        response);
-         return 0;
-      }
-
-      return size_t(b - start);
-   }
-
-   template <opts Opts, class Value>
-   void write_response(Value&& value, is_state auto&& state)
-   {
-      if (state.error) {
-         std::ignore = write<Opts>(std::forward_as_tuple(header{.error = true}, state.error), state.response);
-      }
-      else {
-         state.header.empty = false; // we are writing a response
-         const auto ec = write<Opts>(std::forward_as_tuple(state.header, std::forward<Value>(value)), state.response);
-         if (bool(ec)) [[unlikely]] {
-            std::ignore = write<Opts>(std::forward_as_tuple(header{.error = true}, ec.ec), state.response);
-         }
-      }
-   }
-
-   template <opts Opts>
-   void write_response(is_state auto&& state)
-   {
-      if (state.error) {
-         std::ignore = write<Opts>(std::forward_as_tuple(header{.error = true}, state.error), state.response);
-      }
-      else {
-         state.header.notify = false;
-         state.header.empty = true;
-         const auto ec = write<Opts>(std::forward_as_tuple(state.header, nullptr), state.response);
-         if (bool(ec)) [[unlikely]] {
-            std::ignore = write<Opts>(std::forward_as_tuple(header{.error = true}, ec.ec), state.response);
-         }
-      }
-   }
-
-   struct ignore_result final
-   {};
-
-   template <opts Opts, class Result>
-   [[nodiscard]] error_t decode_response(Result&& result, auto& buffer)
-   {
-      repe::header h;
-      context ctx{};
-      auto [b, e] = read_iterators<Opts>(ctx, buffer);
-      if (bool(ctx.error)) [[unlikely]] {
-         return error_t{error_e::parse_error};
-      }
-      auto start = b;
-
-      auto handle_error = [&](auto& it) {
-         ctx.error = error_code::syntax_error;
-         error_ctx pe{ctx.error, size_t(it - start), ctx.includer_error};
-         return error_t{error_e::parse_error, format_error(pe, buffer)};
-      };
-
-      if (*b == '[') {
-         ++b;
-      }
-      else {
-         return handle_error(b);
-      }
-
-      glz::detail::read<Opts.format>::template op<Opts>(h, ctx, b, e);
-
-      if (bool(ctx.error)) {
-         error_ctx pe{ctx.error, size_t(b - start), ctx.includer_error};
-         return {error_e::parse_error, format_error(pe, buffer)};
-      }
-
-      if (*b == ',') {
-         ++b;
-      }
-      else {
-         return handle_error(b);
-      }
-
-      if (h.error) {
-         error_t error{};
-         glz::detail::read<Opts.format>::template op<Opts>(error, ctx, b, e);
-         return error;
-      }
-
-      if constexpr (!std::same_as<std::decay_t<Result>, ignore_result>) {
-         glz::detail::read<Opts.format>::template op<Opts>(result, ctx, b, e);
-
-         if (bool(ctx.error)) {
-            error_ctx pe{ctx.error, size_t(b - start), ctx.includer_error};
-            return {error_e::parse_error, format_error(pe, buffer)};
-         }
-      }
-
-      return {};
-   }
-
-   template <opts Opts>
-   [[nodiscard]] error_t decode_response(auto& buffer)
-   {
-      return decode_response<Opts>(ignore_result{}, buffer);
-   }
-
-   template <opts Opts, class Value, class H = header>
-   [[nodiscard]] auto request(H&& header, Value&& value)
-   {
-      return glz::write<Opts>(std::forward_as_tuple(std::forward<H>(header), std::forward<Value>(value)));
-   }
-
-   template <opts Opts, class Value, class H = header>
-   [[nodiscard]] auto request(H&& header, Value&& value, auto& buffer)
-   {
-      return glz::write<Opts>(std::forward_as_tuple(std::forward<H>(header), std::forward<Value>(value)), buffer);
-   }
-
-   template <class H = header>
-   [[nodiscard]] auto request_binary(H&& header)
-   {
-      header.empty = true; // because no value provided
-      return glz::write_binary(std::forward_as_tuple(std::forward<H>(header), nullptr));
-   }
-
-   template <class H = header>
-   [[nodiscard]] auto request_json(H&& h)
-   {
-      h.empty = true; // because no value provided
-      return glz::write_json(std::forward_as_tuple(std::forward<H>(h), nullptr));
-   }
-
-   template <class Value, class H = header>
-   [[nodiscard]] auto request_json(H&& header, Value&& value)
-   {
-      return glz::write_json(std::forward_as_tuple(std::forward<H>(header), std::forward<Value>(value)));
-   }
-
-   template <class Value, class H = header>
-   [[nodiscard]] auto request_binary(H&& header, Value&& value)
-   {
-      return glz::write_binary(std::forward_as_tuple(std::forward<H>(header), std::forward<Value>(value)));
-   }
-
-   // DESIGN NOTE: It might appear that we are locking ourselves into a poor design choice by using a runtime
-   // std::unordered_map. However, we can actually improve this in the future by allowing glz::meta specialization on
-   // the server to list out the method names and allow us to build a compile time map prior to function registration.
-   // This is made possible by constinit, and the same approach used for compile time maps and struct reflection.
-   // This will then be an opt-in performance improvement where a bit more code must be written by the user to
-   // list the method names.
-
-   namespace detail
-   {
-      static constexpr std::string_view empty_path = "";
-   }
-
-   template <class T, const std::string_view& parent = detail::empty_path>
-      requires(glz::detail::glaze_object_t<T> || glz::detail::reflectable<T>)
-   constexpr auto make_mutex_map()
-   {
-      using Mtx = std::mutex*;
-      using namespace glz::detail;
-      constexpr auto N = reflection_count<T>;
-      return [&]<size_t... I>(std::index_sequence<I...>) {
-         return normal_map<sv, Mtx, N>(
-            std::array<pair<sv, Mtx>, N>{pair<sv, Mtx>{join_v<parent, chars<"/">, key_name_v<I, T>>, Mtx{}}...});
-      }(std::make_index_sequence<N>{});
-   }
-
-   struct buffer_pool
-   {
-      std::mutex mtx{};
-      std::deque<std::string> buffers{2};
-      std::vector<size_t> available{0, 1}; // indices of available buffers
-
-      // provides a pointer to a buffer and an index
-      std::tuple<std::string*, size_t> get()
-      {
-         std::unique_lock lock{mtx};
-         if (available.empty()) {
-            const auto current_size = buffers.size();
-            const auto new_size = buffers.size() * 2;
-            buffers.resize(new_size);
-            for (size_t i = current_size; i < new_size; ++i) {
-               available.emplace_back(i);
-            }
-         }
-
-         const auto index = available.back();
-         available.pop_back();
-         return {&buffers[index], index};
-      }
-
-      void free(const size_t index)
-      {
-         std::unique_lock lock{mtx};
-         available.emplace_back(index);
-      }
-   };
-
-   struct unique_buffer
-   {
-      buffer_pool* pool{};
-      std::string* ptr{};
-      size_t index{};
-
-      std::string& value() { return *ptr; }
-
-      const std::string& value() const { return *ptr; }
-
-      unique_buffer(buffer_pool* input_pool) : pool(input_pool) { std::tie(ptr, index) = pool->get(); }
-      unique_buffer(const unique_buffer&) = default;
-      unique_buffer(unique_buffer&&) = default;
-      unique_buffer& operator=(const unique_buffer&) = default;
-      unique_buffer& operator=(unique_buffer&&) = default;
-
-      ~unique_buffer() { pool->free(index); }
-   };
-
-   using shared_buffer = std::shared_ptr<unique_buffer>;
-
-   struct mutex_link
-   {
-      std::shared_mutex route{};
-      std::shared_mutex endpoint{};
-   };
-
-   using mutex_chain = std::vector<mutex_link*>;
-
-   [[nodiscard]] inline uint64_t& timeout_duration_ns()
-   {
-      static thread_local uint64_t timeout_ns = 1'000'000'000; // 1 second default
-      return timeout_ns;
-   }
-
-   struct shared_mutex
-   {
-      shared_mutex(std::shared_mutex& mtx) : mtx_(mtx) {}
-      void lock() { mtx_.lock_shared(); }
-      void unlock() { mtx_.unlock_shared(); }
-      bool try_lock() { return mtx_.try_lock_shared(); }
-
-     private:
-      std::shared_mutex& mtx_;
-   };
-
-   template <class Clock, class Duration, class L0, class L1>
-   [[nodiscard]] inline bool try_lock_until(std::chrono::time_point<Clock, Duration> t, L0& l0, L1& l1)
-   {
-      while (true) {
-         {
-            std::unique_lock<L0> u0(l0);
-            if (l1.try_lock()) {
-               u0.release();
-               break;
-            }
-         }
-         std::this_thread::yield();
-         {
-            std::unique_lock<L1> u1(l1);
-            if (l0.try_lock()) {
-               u1.release();
-               break;
-            }
-         }
-         std::this_thread::yield();
-         if (std::chrono::steady_clock::now() >= t) {
-            return false;
-         }
-      }
-      return true;
-   }
-
-   template <class L0, class L1>
-   [[nodiscard]] inline bool try_lock_for(L0& l0, L1& l1)
-   {
-      return try_lock_until(std::chrono::steady_clock::now() + std::chrono::nanoseconds(timeout_duration_ns()), l0, l1);
-   }
-
-   [[nodiscard]] inline bool lock_shared(auto& mtx0, auto& mtx1)
-   {
-      shared_mutex wrapper0{mtx0};
-      shared_mutex wrapper1{mtx1};
-      return try_lock_for(wrapper0, wrapper1);
-   }
-
-   template <class Clock, class Duration, class L0>
-   [[nodiscard]] inline bool try_lock_until(std::chrono::time_point<Clock, Duration> t, L0& l0)
-   {
-      while (true) {
-         if (l0.try_lock()) {
-            break;
-         }
-         std::this_thread::yield();
-         if (std::chrono::steady_clock::now() >= t) {
-            return false;
-         }
-      }
-      return true;
-   }
-
-   template <class L0>
-   [[nodiscard]] inline bool try_lock_for(L0& l0)
-   {
-      return try_lock_until(std::chrono::steady_clock::now() + std::chrono::nanoseconds(timeout_duration_ns()), l0);
-   }
-
-   namespace detail
-   {
-      // lock reading into a value (writing to C++ memory)
-      [[nodiscard]] inline bool lock_read(mutex_chain& chain)
-      {
-         const auto n = chain.size();
-         if (n == 0) {
-            return true;
-         }
-         else if (n == 1) {
-            return try_lock_for(chain[0]->route, chain[0]->endpoint);
-         }
-         else {
-            for (size_t i = 0; i < (n - 1); ++i) {
-               shared_mutex route{chain[i]->route};
-               const auto valid = try_lock_for(route, chain[i]->endpoint);
-               if (not valid) {
-                  return false;
-               }
-            }
-            return try_lock_for(chain.back()->route, chain.back()->endpoint);
-         }
-      }
-
-      inline void unlock_read(mutex_chain& chain)
-      {
-         const auto n = chain.size();
-         if (n == 0) {
-            return;
-         }
-         else if (n == 1) {
-            chain[0]->endpoint.unlock();
-            chain[0]->route.unlock();
-         }
-         else {
-            for (size_t i = 0; i < (n - 1); ++i) {
-               chain[i]->endpoint.unlock();
-               chain[i]->route.unlock_shared();
-            }
-            chain.back()->endpoint.unlock();
-            chain.back()->route.unlock();
-         }
-      }
-
-      // lock writing out a value (reading from C++ memory)
-      [[nodiscard]] inline bool lock_write(mutex_chain& chain)
-      {
-         const auto n = chain.size();
-         if (n == 0) {
-            return true;
-         }
-         else if (n == 1) {
-            return lock_shared(chain[0]->route, chain[0]->endpoint);
-         }
-         else {
-            for (size_t i = 0; i < (n - 1); ++i) {
-               shared_mutex route{chain[i]->route};
-               const bool valid = try_lock_for(route);
-               if (not valid) {
-                  return false;
-               }
-            }
-            return lock_shared(chain.back()->route, chain.back()->endpoint);
-         }
-      }
-
-      inline void unlock_write(mutex_chain& chain)
-      {
-         const auto n = chain.size();
-         if (n == 0) {
-            return;
-         }
-         else if (n == 1) {
-            chain[0]->endpoint.unlock_shared();
-            chain[0]->route.unlock_shared();
-         }
-         else {
-            for (size_t i = 0; i < (n - 1); ++i) {
-               chain[i]->route.unlock_shared();
-            }
-            chain.back()->endpoint.unlock_shared();
-            chain.back()->route.unlock_shared();
-         }
-      }
-
-      // lock invoking a function, which locks same depth and lower (supports member functions that manipulate class
-      // state) treated as writing to C++ memory at the function depth and its parent depth
-      [[nodiscard]] inline bool lock_invoke(mutex_chain& chain)
-      {
-         const auto n = chain.size();
-         if (n == 0) {
-            return true;
-         }
-         else if (n == 1) {
-            shared_mutex route{chain[0]->route};
-            return try_lock_for(route, chain[0]->endpoint);
-         }
-         else {
-            for (size_t i = 0; i < (n - 2); ++i) {
-               shared_mutex route{chain[i]->route};
-               const bool valid = try_lock_for(route, chain[i]->endpoint);
-               if (not valid) {
-                  return false;
-               }
-            }
-            auto valid = try_lock_for(chain[n - 2]->route, chain[n - 2]->endpoint);
-            if (not valid) {
-               return false;
-            }
-            return try_lock_for(chain.back()->route, chain.back()->endpoint);
-         }
-      }
-
-      inline void unlock_invoke(mutex_chain& chain)
-      {
-         const auto n = chain.size();
-         if (n == 0) {
-            return;
-         }
-         else if (n == 1) {
-            chain[0]->endpoint.unlock();
-            chain[0]->route.unlock_shared();
-         }
-         else {
-            for (size_t i = 0; i < (n - 2); ++i) {
-               chain[i]->endpoint.unlock();
-               chain[i]->route.unlock_shared();
-            }
-            chain.back()->endpoint.unlock();
-            chain.back()->route.unlock();
-            chain[n - 2]->endpoint.unlock();
-            chain[n - 2]->route.unlock();
-         }
-      }
-   }
-
-   struct chain_read_lock final
-   {
-      mutex_chain& chain;
-      bool lock_aquired = false;
-
-      chain_read_lock(mutex_chain& input) : chain(input) { lock_aquired = detail::lock_read(chain); }
-
-      operator bool() const { return lock_aquired; }
-
-      chain_read_lock(const chain_read_lock&) = delete;
-      chain_read_lock(chain_read_lock&&) = default;
-      chain_read_lock& operator=(const chain_read_lock&) = delete;
-      chain_read_lock& operator=(chain_read_lock&&) = delete;
-
-      ~chain_read_lock() { detail::unlock_read(chain); }
-   };
-
-   struct chain_write_lock final
-   {
-      mutex_chain& chain;
-      bool lock_aquired = false;
-
-      chain_write_lock(mutex_chain& input) : chain(input) { lock_aquired = detail::lock_write(chain); }
-
-      operator bool() const { return lock_aquired; }
-
-      chain_write_lock(const chain_write_lock&) = delete;
-      chain_write_lock(chain_write_lock&&) = default;
-      chain_write_lock& operator=(const chain_write_lock&) = delete;
-      chain_write_lock& operator=(chain_write_lock&&) = delete;
-
-      ~chain_write_lock() { detail::unlock_write(chain); }
-   };
-
-   struct chain_invoke_lock final
-   {
-      mutex_chain& chain;
-      bool lock_aquired = false;
-
-      chain_invoke_lock(mutex_chain& input) : chain(input) { lock_aquired = detail::lock_invoke(chain); }
-
-      operator bool() const { return lock_aquired; }
-
-      chain_invoke_lock(const chain_invoke_lock&) = delete;
-      chain_invoke_lock(chain_invoke_lock&&) = default;
-      chain_invoke_lock& operator=(const chain_invoke_lock&) = delete;
-      chain_invoke_lock& operator=(chain_invoke_lock&&) = delete;
-
-      ~chain_invoke_lock() { detail::unlock_invoke(chain); }
-   };
-
-   // This registry does not support adding methods from RPC calls or adding methods once RPC calls can be made.
-   template <opts Opts = opts{}>
-   struct registry
-   {
-      using procedure = std::function<void(state&&)>; // RPC method
-      std::unordered_map<sv, procedure, detail::string_hash, std::equal_to<>> methods;
-
-      void clear() { methods.clear(); }
-
-      // TODO: replace this std::map with a std::flat_map with a std::deque (to not invalidate references)
-      std::map<sv, mutex_link> mtxs; // only hashes during initialization
-
-      mutex_chain get_chain(const sv json_ptr)
-      {
-         std::vector<sv> paths = glz::detail::json_ptr_children(json_ptr);
-         mutex_chain v{};
-         v.reserve(paths.size());
-         for (auto& path : paths) {
-            v.emplace_back(&mtxs[path]);
-         }
-         return v;
-      }
-
-      // used for writing to C++ memory
-      template <string_literal json_ptr>
-      auto lock()
-      {
-         // TODO: use a std::array and calculate number of path segments
-         static thread_local mutex_chain chain = [&] {
-            std::vector<sv> paths = glz::detail::json_ptr_children(json_ptr.sv());
-            mutex_chain chain{};
-            chain.resize(paths.size());
-            for (size_t i = 0; i < paths.size(); ++i) {
-               chain[i] = &mtxs[paths[i]];
-            }
-            return chain;
-         }();
-         return chain_read_lock{chain};
-      }
-
-      // used for reading from C++ memory
-      template <string_literal json_ptr>
-      auto read_only_lock()
-      {
-         // TODO: use a std::array and calculate number of path segments
-         static thread_local mutex_chain chain = [&] {
-            std::vector<sv> paths = glz::detail::json_ptr_children(json_ptr.sv());
-            mutex_chain mtx_chain{};
-            mtx_chain.resize(paths.size());
-            for (size_t i = 0; i < paths.size(); ++i) {
-               mtx_chain[i] = &mtxs[paths[i]];
-            }
-            return mtx_chain;
-         }();
-         return chain_write_lock{chain};
-      }
-
-      template <string_literal json_ptr>
-      auto invoke_lock()
-      {
-         // TODO: use a std::array and calculate number of path segments
-         static thread_local mutex_chain chain = [&] {
-            std::vector<sv> paths = glz::detail::json_ptr_children(json_ptr.sv());
-            mutex_chain chain{};
-            chain.resize(paths.size());
-            for (size_t i = 0; i < paths.size(); ++i) {
-               chain[i] = &mtxs[paths[i]];
-            }
-            return chain;
-         }();
-         return chain_invoke_lock{chain};
-      }
-
-      buffer_pool buffers{};
-
-      template <const std::string_view& root = detail::empty_path, class T, const std::string_view& parent = root>
-         requires(glz::detail::glaze_object_t<T> || glz::detail::reflectable<T>)
-      void on(T& value)
-      {
-         using namespace glz::detail;
-         static constexpr auto N = reflection_count<T>;
-
-         [[maybe_unused]] decltype(auto) t = [&] {
-            if constexpr (reflectable<T>) {
-               return to_tuple(value);
-            }
-            else {
-               return nullptr;
-            }
-         }();
-
-         if constexpr (parent == root && (glaze_object_t<T> || reflectable<T>)) {
-            // build read/write calls to the top level object
-            methods[root] = [&value, chain = get_chain(root)](repe::state&& state) mutable {
-               if (not state.header.empty) {
-                  chain_read_lock lock{chain};
-                  if (not lock) {
-                     state.error = {error_e::timeout, std::string(root)};
-                     write_response<Opts>(state);
-                     return;
-                  }
-                  if (read_params<Opts>(value, state, state.response) == 0) {
-                     return;
-                  }
-               }
-
-               if (state.header.notify) {
-                  return;
-               }
-
-               if (state.header.empty) {
-                  chain_write_lock lock{chain};
-                  if (not lock) {
-                     state.error = {error_e::timeout, std::string(root)};
-                     write_response<Opts>(state);
-                     return;
-                  }
-                  write_response<Opts>(value, state);
-               }
-               else {
-                  write_response<Opts>(state);
-               }
-            };
-         }
-
-         for_each<N>([&](auto I) {
-            using Element = glaze_tuple_element<I, N, T>;
-
-            // size_t Index is to fix MSVC
-            decltype(auto) func = [&]<size_t Index>() -> decltype(auto) {
-               if constexpr (reflectable<T>) {
-                  return std::get<I>(t);
-               }
-               else {
-                  // To fix MSVC
-                  using LocalElement = glaze_tuple_element<Index, N, T>;
-                  return get_member(value, get<LocalElement::member_index>(get<I>(meta_v<T>)));
-               }
-            }.template operator()<I>();
-
-            static constexpr std::string_view full_key = [&] {
-               if constexpr (parent == detail::empty_path) {
-                  return join_v<chars<"/">, key_name<I, T, Element::use_reflection>>;
-               }
-               else {
-                  return join_v<parent, chars<"/">, key_name<I, T, Element::use_reflection>>;
-               }
-            }();
-
-            using E = typename Element::type;
-
-            // This logic chain should match glz::cli_menu
-            using Func = decltype(func);
-            if constexpr (std::is_invocable_v<Func>) {
-               using Result = std::decay_t<std::invoke_result_t<Func>>;
-               if constexpr (std::same_as<Result, void>) {
-                  methods[full_key] = [callback = func, chain = get_chain(full_key)](repe::state&& state) mutable {
-                     {
-                        chain_invoke_lock lock{chain};
-                        if (not lock) {
-                           state.error = {error_e::timeout, std::string(full_key)};
-                           write_response<Opts>(state);
-                           return;
-                        }
-                        callback();
-                        if (state.header.notify) {
-                           return;
-                        }
-                     }
-                     write_response<Opts>(state);
-                  };
-               }
-               else {
-                  methods[full_key] = [callback = func, chain = get_chain(full_key)](repe::state&& state) mutable {
-                     {
-                        chain_invoke_lock lock{chain};
-                        if (not lock) {
-                           state.error = {error_e::timeout, std::string(full_key)};
-                           write_response<Opts>(state);
-                           return;
-                        }
-                        if (state.header.notify) {
-                           std::ignore = callback();
-                           return;
-                        }
-                        write_response<Opts>(callback(), state);
-                     }
-                  };
-               }
-            }
-            else if constexpr (is_invocable_concrete<std::remove_cvref_t<Func>>) {
-               using Tuple = invocable_args_t<std::remove_cvref_t<Func>>;
-               constexpr auto N = glz::tuple_size_v<Tuple>;
-               static_assert(N == 1, "Only one input is allowed for your function");
-
-               using Params = glz::tuple_element_t<0, Tuple>;
-               // using Result = std::invoke_result_t<Func, Params>;
-
-               methods[full_key] = [callback = func, chain = get_chain(full_key)](repe::state&& state) mutable {
-                  static thread_local std::decay_t<Params> params{};
-                  // no need lock locals
-                  if (read_params<Opts>(params, state, state.response) == 0) {
-                     return;
-                  }
-
-                  {
-                     chain_invoke_lock lock{chain};
-                     if (not lock) {
-                        state.error = {error_e::timeout, std::string(full_key)};
-                        write_response<Opts>(state);
-                        return;
-                     }
-
-                     if (state.header.notify) {
-                        std::ignore = callback(params);
-                        return;
-                     }
-                     write_response<Opts>(callback(params), state);
-                  }
-               };
-            }
-            else if constexpr (glaze_object_t<E> || reflectable<E>) {
-               on<root, std::decay_t<E>, full_key>(get_member(value, func));
-
-               // build read/write calls to the object as a variable
-               methods[full_key] = [&func, chain = get_chain(full_key)](repe::state&& state) mutable {
-                  if (not state.header.empty) {
-                     chain_read_lock lock{chain};
-                     if (not lock) {
-                        state.error = {error_e::timeout, std::string(full_key)};
-                        write_response<Opts>(state);
-                        return;
-                     }
-                     if (read_params<Opts>(func, state, state.response) == 0) {
-                        return;
-                     }
-                  }
-
-                  if (state.header.notify) {
-                     return;
-                  }
-
-                  if (state.header.empty) {
-                     chain_write_lock lock{chain};
-                     if (not lock) {
-                        state.error = {error_e::timeout, std::string(full_key)};
-                        write_response<Opts>(state);
-                        return;
-                     }
-                     write_response<Opts>(func, state);
-                  }
-                  else {
-                     write_response<Opts>(state);
-                  }
-               };
-            }
-            else if constexpr (not std::is_lvalue_reference_v<Func>) {
-               // For glz::custom, glz::manage, etc.
-               methods[full_key] = [func, chain = get_chain(full_key)](repe::state&& state) mutable {
-                  if (not state.header.empty) {
-                     chain_read_lock lock{chain};
-                     if (not lock) {
-                        state.error = {error_e::timeout, std::string(full_key)};
-                        write_response<Opts>(state);
-                        return;
-                     }
-                     if (read_params<Opts>(func, state, state.response) == 0) {
-                        return;
-                     }
-                  }
-
-                  if (state.header.notify) {
-                     return;
-                  }
-
-                  if (state.header.empty) {
-                     chain_write_lock lock{chain};
-                     if (not lock) {
-                        state.error = {error_e::timeout, std::string(full_key)};
-                        write_response<Opts>(state);
-                        return;
-                     }
-                     write_response<Opts>(func, state);
-                  }
-                  else {
-                     write_response<Opts>(state);
-                  }
-               };
-            }
-            else {
-               static_assert(std::is_lvalue_reference_v<Func>);
-
-               if constexpr (std::is_member_function_pointer_v<std::decay_t<Func>>) {
-                  using F = std::decay_t<Func>;
-                  using Ret = typename return_type<F>::type;
-                  using Tuple = typename inputs_as_tuple<F>::type;
-                  constexpr auto n_args = glz::tuple_size_v<Tuple>;
-                  if constexpr (std::is_void_v<Ret>) {
-                     if constexpr (n_args == 0) {
-                        methods[full_key] = [&value, &func, chain = get_chain(full_key)](repe::state&& state) mutable {
-                           {
-                              chain_invoke_lock lock{chain};
-                              if (not lock) {
-                                 state.error = {error_e::timeout, std::string(full_key)};
-                                 write_response<Opts>(state);
-                                 return;
-                              }
-                              (value.*func)();
-                           }
-
-                           if (state.header.notify) {
-                              return;
-                           }
-
-                           state.header.empty = false;
-                           write_response<Opts>(state);
-                        };
-                     }
-                     else if constexpr (n_args == 1) {
-                        using Input = std::decay_t<glz::tuple_element_t<0, Tuple>>;
-                        methods[full_key] = [&value, &func, chain = get_chain(full_key)](repe::state&& state) mutable {
-                           static thread_local Input input{};
-                           if (not state.header.empty) {
-                              if (read_params<Opts>(input, state, state.response) == 0) {
-                                 return;
-                              }
-                           }
-
-                           {
-                              chain_invoke_lock lock{chain};
-                              if (not lock) {
-                                 state.error = {error_e::timeout, std::string(full_key)};
-                                 write_response<Opts>(state);
-                                 return;
-                              }
-                              (value.*func)(input);
-                           }
-
-                           if (state.header.notify) {
-                              return;
-                           }
-
-                           state.header.empty = false;
-                           write_response<Opts>(state);
-                        };
-                     }
-                     else {
-                        static_assert(false_v<Func>, "function cannot have more than one input");
-                     }
-                  }
-                  else {
-                     // Member function pointers
-                     if constexpr (n_args == 0) {
-                        methods[full_key] = [&value, &func, chain = get_chain(full_key)](repe::state&& state) mutable {
-                           // using Result = std::decay_t<decltype((value.*func)())>;
-                           {
-                              chain_invoke_lock lock{chain};
-                              if (not lock) {
-                                 state.error = {error_e::timeout, std::string(full_key)};
-                                 write_response<Opts>(state);
-                                 return;
-                              }
-
-                              if (state.header.notify) {
-                                 std::ignore = (value.*func)();
-                                 return;
-                              }
-
-                              write_response<Opts>((value.*func)(), state);
-                           }
-                        };
-                     }
-                     else if constexpr (n_args == 1) {
-                        using Input = std::decay_t<glz::tuple_element_t<0, Tuple>>;
-                        methods[full_key] = [this, &value, &func,
-                                             chain = get_chain(full_key)](repe::state&& state) mutable {
-                           static thread_local Input input{};
-
-                           if (not state.header.empty) {
-                              if (read_params<Opts>(input, state, state.response) == 0) {
-                                 return;
-                              }
-                           }
-
-                           // using Result = std::decay_t<decltype((value.*func)(input))>;
-                           {
-                              chain_invoke_lock lock{chain};
-                              if (not lock) {
-                                 state.error = {error_e::timeout, std::string(full_key)};
-                                 write_response<Opts>(state);
-                                 return;
-                              }
-
-                              if (state.header.notify) {
-                                 std::ignore = (value.*func)(input);
-                                 return;
-                              }
-
-                              write_response<Opts>((value.*func)(input), state);
-                           }
-                        };
-                     }
-                     else {
-                        static_assert(false_v<Func>, "function cannot have more than one input");
-                     }
-                  }
-               }
-               else {
-                  // this is a variable and not a function, so we build RPC read/write calls
-                  methods[full_key] = [&func, chain = get_chain(full_key)](repe::state&& state) mutable {
-                     if (not state.header.empty) {
-                        chain_read_lock lock{chain};
-                        if (not lock) {
-                           state.error = {error_e::timeout, std::string(full_key)};
-                           write_response<Opts>(state);
-                           return;
-                        }
-                        if (read_params<Opts>(func, state, state.response) == 0) {
-                           return;
-                        }
-                     }
-
-                     if (state.header.notify) {
-                        return;
-                     }
-
-                     if (state.header.empty) {
-                        chain_write_lock lock{chain};
-                        if (not lock) {
-                           state.error = {error_e::timeout, std::string(full_key)};
-                           write_response<Opts>(state);
-                           return;
-                        }
-                        write_response<Opts>(func, state);
-                     }
-                     else {
-                        write_response<Opts>(state);
-                     }
-                  };
-               }
-            }
-         });
-      }
-
-      template <class Value, class H = header>
-      [[nodiscard]] bool call(H&& header, Value&& value)
-      {
-         return call(request<Opts>(std::forward<H>(header), std::forward<Value>(value)));
-      }
-
-      template <class Value, class H = header>
-      [[nodiscard]] bool call(H&& header, Value&& value, auto& buffer)
-      {
-         return call(request<Opts>(std::forward<H>(header), std::forward<Value>(value), buffer));
-      }
-
-      // returns null for notifications
-      [[nodiscard]] shared_buffer call(const sv msg)
-      {
-         shared_buffer u_buffer = std::make_shared<unique_buffer>(&buffers);
-         auto& response = *(u_buffer->ptr);
-
-         context ctx{};
-         auto [b, e] = read_iterators<Opts>(ctx, msg);
-         auto start = b;
-
-         auto handle_error = [&](auto& it) {
-            ctx.error = error_code::syntax_error;
-            error_ctx pe{ctx.error, size_t(it - start), ctx.includer_error};
-            std::ignore = write<Opts>(
-               std::forward_as_tuple(header{.error = true}, error_t{error_e::parse_error, format_error(pe, msg)}),
-               response);
-         };
-
-         header h{};
-
-         auto finish = [&]() -> std::shared_ptr<unique_buffer> {
-            if (h.notify) {
-               return {};
-            }
-            else {
-               return u_buffer;
-            }
-         };
-
-         if (bool(ctx.error)) [[unlikely]] {
-            // TODO: What should we do if we have read_iterators errors?
-            return finish();
-         }
-
-         if constexpr (Opts.format == json) {
-            if (*b == '[') {
-               ++b;
-            }
-            else {
-               handle_error(b);
-               return finish();
-            }
-         }
-         else {
-            if (*b == glz::tag::generic_array) {
-               ++b; // skip the tag
-               const auto n = glz::detail::int_from_compressed(ctx, b, e);
-               if (bool(ctx.error) || (n != 2)) [[unlikely]] {
-                  handle_error(b);
-                  return finish();
-               }
-            }
-            else {
-               handle_error(b);
-               return finish();
-            }
-         }
-
-         glz::detail::read<Opts.format>::template op<Opts>(h, ctx, b, e);
-
-         if (bool(ctx.error)) [[unlikely]] {
-            error_ctx pe{ctx.error, size_t(b - start), ctx.includer_error};
-            response = format_error(pe, msg);
-            return finish();
-         }
-
-         if constexpr (Opts.format == json) {
-            if (*b == ',') {
-               ++b;
-            }
-            else {
-               handle_error(b);
-               return finish();
-            }
-         }
-
-         if (auto it = methods.find(h.method); it != methods.end()) {
-            const sv body = msg.substr(size_t(b - start));
-            static thread_local error_t error{};
-            it->second(state{body, h, response, error}); // handle the body
-         }
-         else {
-            std::ignore =
-               write<Opts>(std::forward_as_tuple(header{.error = true}, error_t{error_e::method_not_found}), response);
-         }
-
-         return finish();
-      }
-   };
-}
diff --git a/deps/saucer/include/glaze/rpc/repe/header.hpp b/deps/saucer/include/glaze/rpc/repe/header.hpp
new file mode 100644
index 0000000..3990d55
--- /dev/null
+++ b/deps/saucer/include/glaze/rpc/repe/header.hpp
@@ -0,0 +1,68 @@
+// Glaze Library
+// For the license information refer to glaze.hpp
+
+#pragma once
+
+#include <cstdint>
+#include <limits>
+#include <string>
+#include <string_view>
+
+#include "glaze/core/context.hpp"
+
+namespace glz::repe
+{
+   struct header
+   {
+      uint64_t length{}; // Total length of [header, query, body]
+      //
+      uint16_t spec{0x1507}; // (5383) Magic two bytes to denote the REPE specification
+      uint8_t version = 1; // REPE version
+      uint8_t notify{}; // Action to take, multiple actions may be bit-packed together
+      uint32_t reserved{}; // Must be zero
+      //
+      uint64_t id{}; // Identifier
+      //
+      uint64_t query_length{}; // The total length of the query (-1 denotes no size given)
+      //
+      uint64_t body_length{}; // The total length of the body (-1 denotes no size given)
+      //
+      uint16_t query_format{};
+      uint16_t body_format{};
+      error_code ec{};
+   };
+
+   static_assert(sizeof(header) == 48);
+
+   // query and body are heap allocated and we want to be able to reuse memory
+   struct message final
+   {
+      repe::header header{};
+      std::string query{};
+      std::string body{};
+
+      operator bool() const { return bool(header.ec); }
+
+      error_code error() const { return header.ec; }
+   };
+
+   // User interface that will be encoded into a REPE header
+   struct user_header final
+   {
+      std::string_view query = ""; // The JSON pointer path to call or member to access/assign
+      uint64_t id{}; // Identifier
+      error_code ec{};
+      bool notify{};
+   };
+
+   inline repe::header encode(const user_header& h) noexcept
+   {
+      repe::header ret{
+         .notify = h.notify, //
+         .id = h.id, //
+         .query_length = h.query.size(), //
+         .ec = h.ec //
+      };
+      return ret;
+   }
+}
diff --git a/deps/saucer/include/glaze/rpc/repe/repe.hpp b/deps/saucer/include/glaze/rpc/repe/repe.hpp
new file mode 100644
index 0000000..2d7a05c
--- /dev/null
+++ b/deps/saucer/include/glaze/rpc/repe/repe.hpp
@@ -0,0 +1,176 @@
+// Glaze Library
+// For the license information refer to glaze.hpp
+
+#pragma once
+
+#include "glaze/core/opts.hpp"
+#include "glaze/rpc/repe/header.hpp"
+
+namespace glz
+{
+   // Single template storage for all protocol-specific storage
+   template <uint32_t P>
+   struct protocol_storage
+   {};
+}
+
+namespace glz::detail
+{
+   struct string_hash
+   {
+      using is_transparent = void;
+      [[nodiscard]] size_t operator()(const char* txt) const { return std::hash<std::string_view>{}(txt); }
+      [[nodiscard]] size_t operator()(std::string_view txt) const { return std::hash<std::string_view>{}(txt); }
+      [[nodiscard]] size_t operator()(const std::string& txt) const { return std::hash<std::string>{}(txt); }
+   };
+}
+
+namespace glz::repe
+{
+   struct state final
+   {
+      repe::message& in;
+      repe::message& out;
+
+      bool notify() const { return bool(in.header.notify); }
+
+      bool has_body() const { return bool(in.header.body_length); }
+   };
+
+   template <class T>
+   concept is_state = std::same_as<std::decay_t<T>, state>;
+
+   template <auto Opts, class Value>
+   void write_response(Value&& value, is_state auto&& state)
+   {
+      auto& in = state.in;
+      auto& out = state.out;
+      out.header.id = in.header.id;
+      if (bool(out.header.ec)) {
+         out.header.query_length = out.query.size();
+         out.header.body_length = out.body.size();
+         out.header.length = sizeof(repe::header) + out.query.size() + out.body.size();
+      }
+      else {
+         const auto ec = write<Opts>(std::forward<Value>(value), out.body);
+         if (bool(ec)) [[unlikely]] {
+            out.header.ec = ec.ec;
+         }
+         out.header.query_length = out.query.size();
+         out.header.body_length = out.body.size();
+         out.header.length = sizeof(repe::header) + out.query.size() + out.body.size();
+      }
+   }
+
+   template <auto Opts>
+   void write_response(is_state auto&& state)
+   {
+      auto& in = state.in;
+      auto& out = state.out;
+      out.header.id = in.header.id;
+      if (bool(out.header.ec)) {
+         out.header.query_length = out.query.size();
+         out.header.body_length = out.body.size();
+         out.header.length = sizeof(repe::header) + out.query.size() + out.body.size();
+      }
+      else {
+         const auto ec = write<Opts>(nullptr, out.body);
+         if (bool(ec)) [[unlikely]] {
+            out.header.ec = ec.ec;
+         }
+         out.query.clear();
+         out.header.query_length = out.query.size();
+         out.header.body_length = out.body.size();
+         out.header.length = sizeof(repe::header) + out.query.size() + out.body.size();
+      }
+   }
+
+   // returns 0 on error
+   template <auto Opts, class Value>
+   size_t read_params(Value&& value, auto&& state)
+   {
+      glz::context ctx{};
+      auto [b, e] = read_iterators<Opts>(state.in.body);
+      if (state.in.body.empty()) [[unlikely]] {
+         ctx.error = error_code::no_read_input;
+      }
+      if (bool(ctx.error)) [[unlikely]] {
+         return 0;
+      }
+      auto start = b;
+
+      glz::parse<Opts.format>::template op<Opts>(std::forward<Value>(value), ctx, b, e);
+
+      if (bool(ctx.error)) {
+         state.out.header.ec = ctx.error;
+         error_ctx ec{ctx.error, ctx.custom_error_message, size_t(b - start), ctx.includer_error};
+
+         auto& in = state.in;
+         auto& out = state.out;
+
+         std::string error_message = format_error(ec, in.body);
+         out.header.body_length = uint32_t(error_message.size());
+         out.body = error_message;
+
+         write_response<Opts>(state);
+         return 0;
+      }
+
+      return size_t(b - start);
+   }
+
+   namespace detail
+   {
+      template <auto Opts>
+      struct request_impl
+      {
+         message operator()(const user_header& h) const
+         {
+            message msg{};
+            msg.header = encode(h);
+            msg.query = std::string{h.query};
+            msg.header.body_length = msg.body.size();
+            msg.header.length = sizeof(repe::header) + msg.query.size() + msg.body.size();
+            return msg;
+         }
+
+         template <class Value>
+         message operator()(const user_header& h, Value&& value) const
+         {
+            message msg{};
+            msg.header = encode(h);
+            msg.query = std::string{h.query};
+            // TODO: Handle potential write errors and put in msg
+            std::ignore = glz::write<Opts>(std::forward<Value>(value), msg.body);
+            msg.header.body_length = msg.body.size();
+            msg.header.length = sizeof(repe::header) + msg.query.size() + msg.body.size();
+            return msg;
+         }
+
+         void operator()(const user_header& h, message& msg) const
+         {
+            msg.header = encode(h);
+            msg.query = std::string{h.query};
+            msg.header.body_length = msg.body.size();
+            msg.header.length = sizeof(repe::header) + msg.query.size() + msg.body.size();
+         }
+
+         template <class Value>
+         void operator()(const user_header& h, message& msg, Value&& value) const
+         {
+            msg.header = encode(h);
+            msg.query = std::string{h.query};
+            // TODO: Handle potential write errors and put in msg
+            std::ignore = glz::write<Opts>(std::forward<Value>(value), msg.body);
+            msg.header.body_length = msg.body.size();
+            msg.header.length = sizeof(repe::header) + msg.query.size() + msg.body.size();
+         }
+      };
+   }
+
+   template <auto Opts>
+   inline constexpr auto request = detail::request_impl<Opts>{};
+
+   inline constexpr auto request_beve = request<opts{BEVE}>;
+   inline constexpr auto request_json = request<opts{JSON}>;
+}
diff --git a/deps/saucer/include/glaze/rpc/repe/repe_registry_impl.hpp b/deps/saucer/include/glaze/rpc/repe/repe_registry_impl.hpp
new file mode 100644
index 0000000..e2a4373
--- /dev/null
+++ b/deps/saucer/include/glaze/rpc/repe/repe_registry_impl.hpp
@@ -0,0 +1,235 @@
+// Glaze Library
+// For the license information refer to glaze.hpp
+
+#pragma once
+
+#include "glaze/glaze.hpp"
+#include "glaze/rpc/repe/repe.hpp"
+
+namespace glz
+{
+   // Forward declaration of the registry template
+   template <auto Opts, uint32_t Proto>
+   struct registry;
+
+   template <>
+   struct protocol_storage<REPE>
+   {
+      using type = std::unordered_map<sv, std::function<void(repe::state&&)>, detail::string_hash, std::equal_to<>>;
+   };
+
+   // Implementation for REPE protocol
+   template <auto Opts>
+   struct registry_impl<Opts, REPE>
+   {
+      template <class T, class RegistryType>
+      static void register_endpoint(const sv path, T& value, RegistryType& reg)
+      {
+         reg.endpoints[path] = [&value](repe::state&& state) mutable {
+            if (state.has_body()) {
+               if (read_params<Opts>(value, state) == 0) {
+                  return;
+               }
+            }
+
+            if (state.notify()) {
+               return;
+            }
+
+            if (not state.has_body()) {
+               write_response<Opts>(value, state);
+            }
+            else {
+               write_response<Opts>(state);
+            }
+         };
+      }
+
+      template <class Func, class Result, class RegistryType>
+      static void register_function_endpoint(const sv path, Func& func, RegistryType& reg)
+      {
+         if constexpr (std::same_as<Result, void>) {
+            reg.endpoints[path] = [&func](repe::state&& state) mutable {
+               func();
+               if (state.notify()) {
+                  state.out.header.notify = true;
+                  return;
+               }
+               write_response<Opts>(state);
+            };
+         }
+         else {
+            reg.endpoints[path] = [&func](repe::state&& state) mutable {
+               if (state.notify()) {
+                  std::ignore = func();
+                  state.out.header.notify = true;
+                  return;
+               }
+               write_response<Opts>(func(), state);
+            };
+         }
+      }
+
+      template <class Func, class Params, class RegistryType>
+      static void register_param_function_endpoint(const sv path, Func& func, RegistryType& reg)
+      {
+         reg.endpoints[path] = [&func](repe::state&& state) mutable {
+            static thread_local std::decay_t<Params> params{};
+            if (read_params<Opts>(params, state) == 0) {
+               return;
+            }
+
+            using Result = std::invoke_result_t<decltype(func), Params>;
+
+            if (state.notify()) {
+               if constexpr (std::same_as<Result, void>) {
+                  func(params);
+               }
+               else {
+                  std::ignore = func(params);
+               }
+               state.out.header.notify = true;
+               return;
+            }
+            if constexpr (std::same_as<Result, void>) {
+               func(params);
+               write_response<Opts>(state);
+            }
+            else {
+               auto ret = func(params);
+               write_response<Opts>(ret, state);
+            }
+         };
+      }
+
+      template <class Obj, class RegistryType>
+      static void register_object_endpoint(const sv path, Obj& obj, RegistryType& reg)
+      {
+         reg.endpoints[path] = [&obj](repe::state&& state) mutable {
+            if (state.has_body()) {
+               if (read_params<Opts>(obj, state) == 0) {
+                  return;
+               }
+            }
+
+            if (state.notify()) {
+               return;
+            }
+
+            if (not state.has_body()) {
+               write_response<Opts>(obj, state);
+            }
+            else {
+               write_response<Opts>(state);
+            }
+         };
+      }
+
+      template <class Value, class RegistryType>
+      static void register_value_endpoint(const sv path, Value& value, RegistryType& reg)
+      {
+         reg.endpoints[path] = [value](repe::state&& state) mutable {
+            if (state.has_body()) {
+               if (read_params<Opts>(value, state) == 0) {
+                  return;
+               }
+            }
+
+            if (state.notify()) {
+               state.out.header.notify = true;
+               return;
+            }
+
+            if (not state.has_body()) {
+               write_response<Opts>(value, state);
+            }
+            else {
+               write_response<Opts>(state);
+            }
+         };
+      }
+
+      template <class Var, class RegistryType>
+      static void register_variable_endpoint(const sv path, Var& var, RegistryType& reg)
+      {
+         reg.endpoints[path] = [&var](repe::state&& state) mutable {
+            if (state.has_body()) {
+               if (read_params<Opts>(var, state) == 0) {
+                  return;
+               }
+            }
+
+            if (state.notify()) {
+               state.out.header.notify = true;
+               return;
+            }
+
+            if (not state.has_body()) {
+               write_response<Opts>(var, state);
+            }
+            else {
+               write_response<Opts>(state);
+            }
+         };
+      }
+
+      template <class T, class F, class Ret, class RegistryType>
+      static void register_member_function_endpoint(const sv path, T& value, F func, RegistryType& reg)
+      {
+         reg.endpoints[path] = [&value, func](repe::state&& state) mutable {
+            if constexpr (std::same_as<Ret, void>) {
+               (value.*func)();
+
+               if (state.notify()) {
+                  state.out.header.notify = true;
+                  return;
+               }
+
+               write_response<Opts>(state);
+            }
+            else {
+               if (state.notify()) {
+                  std::ignore = (value.*func)();
+                  state.out.header.notify = true;
+                  return;
+               }
+
+               write_response<Opts>((value.*func)(), state);
+            }
+         };
+      }
+
+      template <class T, class F, class Input, class Ret, class RegistryType>
+      static void register_member_function_with_params_endpoint(const sv path, T& value, F func, RegistryType& reg)
+      {
+         reg.endpoints[path] = [&value, func](repe::state&& state) mutable {
+            static thread_local Input input{};
+            if (state.has_body()) {
+               if (read_params<Opts>(input, state) == 0) {
+                  return;
+               }
+            }
+
+            if constexpr (std::same_as<Ret, void>) {
+               (value.*func)(input);
+
+               if (state.notify()) {
+                  state.out.header.notify = true;
+                  return;
+               }
+
+               write_response<Opts>(state);
+            }
+            else {
+               if (state.notify()) {
+                  std::ignore = (value.*func)(input);
+                  state.out.header.notify = true;
+                  return;
+               }
+
+               write_response<Opts>((value.*func)(input), state);
+            }
+         };
+      }
+   };
+}
diff --git a/deps/saucer/include/glaze/stencil/stencil.hpp b/deps/saucer/include/glaze/stencil/stencil.hpp
new file mode 100644
index 0000000..2f6310f
--- /dev/null
+++ b/deps/saucer/include/glaze/stencil/stencil.hpp
@@ -0,0 +1,402 @@
+// Glaze Library
+// For the license information refer to glaze.hpp
+
+#pragma once
+
+#include "glaze/core/read.hpp"
+#include "glaze/core/reflect.hpp"
+#include "glaze/core/write.hpp"
+
+namespace glz
+{
+   // HTML escape function
+   inline std::string html_escape(const std::string& input)
+   {
+      std::string result;
+      result.reserve(static_cast<size_t>(input.size() * 1.1)); // Reserve some extra space
+
+      for (char c : input) {
+         switch (c) {
+         case '<':
+            result += "&lt;";
+            break;
+         case '>':
+            result += "&gt;";
+            break;
+         case '&':
+            result += "&amp;";
+            break;
+         case '"':
+            result += "&quot;";
+            break;
+         case '\'':
+            result += "&#x27;";
+            break;
+         default:
+            result += c;
+            break;
+         }
+      }
+      return result;
+   }
+
+   template <auto Opts = opts{.format = STENCIL}, class Template, class T, resizable Buffer>
+   [[nodiscard]] error_ctx stencil(Template&& layout, T&& value, Buffer& buffer)
+   {
+      context ctx{};
+
+      if (layout.empty()) [[unlikely]] {
+         ctx.error = error_code::no_read_input;
+         return {ctx.error, ctx.custom_error_message, 0};
+      }
+
+      auto p = read_iterators<Opts, false>(layout);
+      auto it = p.first;
+      auto end = p.second;
+      auto outer_start = it;
+
+      if (not bool(ctx.error)) [[likely]] {
+         auto skip_whitespace = [&] {
+            while (it < end && whitespace_table[uint8_t(*it)]) {
+               ++it;
+            }
+         };
+
+         while (it < end) {
+            if (*it == '{') {
+               ++it;
+               if (it != end && *it == '{') {
+                  ++it;
+
+                  // Check for triple braces (unescaped HTML)
+                  bool is_triple_brace = false;
+                  if (it != end && *it == '{') {
+                     ++it;
+                     is_triple_brace = true;
+                  }
+
+                  bool is_section = false;
+                  bool is_inverted_section = false;
+                  bool is_comment = false;
+
+                  if (it != end && !is_triple_brace) {
+                     if (*it == '!') {
+                        ++it;
+                        is_comment = true;
+                     }
+                     else if (*it == '#') {
+                        ++it;
+                        is_section = true;
+                     }
+                     else if (*it == '^') {
+                        ++it;
+                        is_inverted_section = true;
+                     }
+                  }
+
+                  skip_whitespace();
+
+                  auto start = it;
+                  while (it != end && *it != '}' && *it != ' ' && *it != '\t') {
+                     ++it;
+                  }
+
+                  if (it == end) {
+                     ctx.error = error_code::unexpected_end;
+                     return {ctx.error, ctx.custom_error_message, size_t(it - outer_start)};
+                  }
+
+                  const sv key{start, size_t(it - start)};
+
+                  skip_whitespace();
+
+                  if (is_comment) {
+                     while (it < end && !(it + 1 < end && *it == '}' && *(it + 1) == '}')) {
+                        ++it;
+                     }
+                     if (it + 1 < end) {
+                        it += 2; // Skip '}}'
+                     }
+                     continue;
+                  }
+
+                  if (is_section || is_inverted_section) {
+                     // Find the closing tag '{{/key}}'
+                     std::string closing_tag = "{{/" + std::string(key) + "}}";
+                     auto closing_pos = std::search(it, end, closing_tag.begin(), closing_tag.end());
+
+                     if (closing_pos == end) {
+                        ctx.error = error_code::unexpected_end;
+                        return {ctx.error, "Closing tag not found for section", size_t(it - outer_start)};
+                     }
+
+                     if (it + 1 < end) {
+                        it += 2; // Skip '}}'
+                     }
+
+                     // Extract inner template between current position and closing tag
+                     std::string_view inner_template(it, closing_pos);
+                     it = closing_pos + closing_tag.size();
+
+                     // Retrieve the value associated with 'key'
+                     bool condition = false;
+                     bool is_container = false;
+
+                     {
+                        static constexpr auto N = reflect<T>::size;
+                        static constexpr auto HashInfo = hash_info<T>;
+
+                        const auto index =
+                           decode_hash_with_size<STENCIL, T, HashInfo, HashInfo.type>::op(start, end, key.size());
+
+                        if (index >= N) {
+                           ctx.error = error_code::unknown_key;
+                           return {ctx.error, ctx.custom_error_message, size_t(it - outer_start)};
+                        }
+                        else {
+                           visit<N>(
+                              [&]<size_t I>() {
+                                 static constexpr auto TargetKey = get<I>(reflect<T>::keys);
+                                 if (TargetKey == key) [[likely]] {
+                                    using field_type = refl_t<T, I>;
+
+                                    if constexpr (bool_t<field_type>) {
+                                       // Boolean field
+                                       if constexpr (reflectable<T>) {
+                                          condition = bool(get_member(value, get<I>(to_tie(value))));
+                                       }
+                                       else if constexpr (glaze_object_t<T>) {
+                                          condition = bool(get_member(value, get<I>(reflect<T>::values)));
+                                       }
+                                    }
+                                    else if constexpr (writable_array_t<field_type>) {
+                                       // Container field - check if empty for condition
+                                       is_container = true;
+
+                                       if constexpr (reflectable<T>) {
+                                          auto& container = get_member(value, get<I>(to_tie(value)));
+                                          condition = !empty_range(container);
+
+                                          // Process container iteration for regular sections
+                                          if (is_section && condition) {
+                                             using element_type = std::decay_t<decltype(*std::begin(container))>;
+                                             if constexpr (reflectable<element_type> || glaze_object_t<element_type>) {
+                                                for (const auto& item : container) {
+                                                   std::string inner_buffer;
+                                                   auto inner_ec = stencil<Opts>(inner_template, item, inner_buffer);
+                                                   if (inner_ec) {
+                                                      ctx.error = inner_ec.ec;
+                                                      return;
+                                                   }
+                                                   buffer.append(inner_buffer);
+                                                }
+                                             }
+                                             else {
+                                                // For primitive containers, we can't do recursive stencil
+                                                // This would require special handling for {{.}} syntax
+                                                ctx.error = error_code::syntax_error;
+                                                return;
+                                             }
+                                          }
+                                       }
+                                       else if constexpr (glaze_object_t<T>) {
+                                          auto& container = get_member(value, get<I>(reflect<T>::values));
+                                          condition = !empty_range(container);
+
+                                          // Process container iteration for regular sections
+                                          if (is_section && condition) {
+                                             using element_type = std::decay_t<decltype(*std::begin(container))>;
+                                             if constexpr (reflectable<element_type> || glaze_object_t<element_type>) {
+                                                for (const auto& item : container) {
+                                                   std::string inner_buffer;
+                                                   auto inner_ec = stencil<Opts>(inner_template, item, inner_buffer);
+                                                   if (inner_ec) {
+                                                      ctx.error = inner_ec.ec;
+                                                      return;
+                                                   }
+                                                   buffer.append(inner_buffer);
+                                                }
+                                             }
+                                             else {
+                                                // For primitive containers, we can't do recursive stencil
+                                                // This would require special handling for {{.}} syntax
+                                                ctx.error = error_code::syntax_error;
+                                                return;
+                                             }
+                                          }
+                                       }
+                                    }
+                                    else {
+                                       // For other types, default to false for sections
+                                       condition = false;
+                                    }
+                                 }
+                                 else {
+                                    ctx.error = error_code::unknown_key;
+                                 }
+                              },
+                              index);
+                        }
+                     }
+
+                     if (bool(ctx.error)) [[unlikely]] {
+                        return {ctx.error, ctx.custom_error_message, size_t(it - outer_start)};
+                     }
+
+                     // Handle inverted sections and boolean sections
+                     if (is_inverted_section) {
+                        // For inverted sections, show content if condition is false
+                        if (!condition) {
+                           std::string inner_buffer;
+                           auto inner_ec = stencil<Opts>(inner_template, value, inner_buffer);
+                           if (inner_ec) {
+                              return inner_ec;
+                           }
+                           buffer.append(inner_buffer);
+                        }
+                     }
+                     else if (is_section && !is_container) {
+                        // For boolean sections (non-containers), show content if condition is true
+                        if (condition) {
+                           std::string inner_buffer;
+                           auto inner_ec = stencil<Opts>(inner_template, value, inner_buffer);
+                           if (inner_ec) {
+                              return inner_ec;
+                           }
+                           buffer.append(inner_buffer);
+                        }
+                     }
+                     // Container iteration for regular sections was already handled above
+
+                     skip_whitespace();
+                     continue;
+                  }
+
+                  // Handle regular placeholder (double braces) or unescaped (triple braces)
+                  static constexpr auto N = reflect<T>::size;
+                  static constexpr auto HashInfo = hash_info<T>;
+
+                  const auto index =
+                     decode_hash_with_size<STENCIL, T, HashInfo, HashInfo.type>::op(start, end, key.size());
+
+                  if (index >= N) [[unlikely]] {
+                     ctx.error = error_code::unknown_key;
+                     return {ctx.error, ctx.custom_error_message, size_t(it - outer_start)};
+                  }
+                  else [[likely]] {
+                     // For triple braces, we need to expect three closing braces
+                     size_t expected_closing_braces = is_triple_brace ? 3 : 2;
+
+                     // Check for correct closing braces
+                     size_t closing_brace_count = 0;
+                     auto temp_it = it;
+                     while (temp_it < end && *temp_it == '}' && closing_brace_count < 3) {
+                        ++temp_it;
+                        ++closing_brace_count;
+                     }
+
+                     if (closing_brace_count < expected_closing_braces) {
+                        ctx.error = error_code::syntax_error;
+                        return {ctx.error, ctx.custom_error_message, size_t(it - outer_start)};
+                     }
+
+                     // Serialize the value
+                     std::string temp_buffer;
+                     static constexpr auto RawOpts =
+                        set_json<opt_true<Opts, &opts::raw>>(); // write out string like values without quotes
+
+                     visit<N>(
+                        [&]<size_t I>() {
+                           static constexpr auto TargetKey = get<I>(reflect<T>::keys);
+                           if ((TargetKey.size() == key.size()) && comparitor<TargetKey>(start)) [[likely]] {
+                              size_t ix = 0;
+                              temp_buffer.resize(2 * write_padding_bytes);
+
+                              if constexpr (reflectable<T>) {
+                                 serialize<JSON>::template op<RawOpts>(get_member(value, get<I>(to_tie(value))), ctx,
+                                                                       temp_buffer, ix);
+                              }
+                              else if constexpr (glaze_object_t<T>) {
+                                 serialize<JSON>::template op<RawOpts>(get_member(value, get<I>(reflect<T>::values)),
+                                                                       ctx, temp_buffer, ix);
+                              }
+
+                              temp_buffer.resize(ix);
+                           }
+                           else {
+                              ctx.error = error_code::unknown_key;
+                           }
+                        },
+                        index);
+
+                     if (bool(ctx.error)) [[unlikely]] {
+                        return {ctx.error, ctx.custom_error_message, size_t(it - outer_start)};
+                     }
+
+                     // Apply HTML escaping for double braces, leave unescaped for triple braces
+                     if (is_triple_brace) {
+                        buffer.append(temp_buffer);
+                     }
+                     else {
+                        if constexpr (Opts.format == MUSTACHE) {
+                           buffer.append(html_escape(temp_buffer));
+                        }
+                        else {
+                           buffer.append(temp_buffer);
+                        }
+                     }
+
+                     // Skip the closing braces
+                     it += expected_closing_braces;
+                     continue;
+                  }
+               }
+               else {
+                  buffer.append("{");
+                  // 'it' is already incremented past the first '{'
+               }
+            }
+            else {
+               buffer.push_back(*it);
+               ++it;
+            }
+         }
+      }
+
+      if (bool(ctx.error)) [[unlikely]] {
+         return {ctx.error, ctx.custom_error_message, size_t(it - outer_start)};
+      }
+
+      return {};
+   }
+
+   template <auto Opts = opts{.format = STENCIL}, class Template, class T>
+   [[nodiscard]] expected<std::string, error_ctx> stencil(Template&& layout, T&& value)
+   {
+      std::string buffer{};
+      auto ec = stencil<Opts>(std::forward<Template>(layout), std::forward<T>(value), buffer);
+      if (ec) {
+         return unexpected<error_ctx>(ec);
+      }
+      return {buffer};
+   }
+
+   template <auto Opts = opts{.format = MUSTACHE}, class Template, class T, resizable Buffer>
+      requires(Opts.format == MUSTACHE)
+   [[nodiscard]] error_ctx mustache(Template&& layout, T&& value, Buffer& buffer)
+   {
+      return stencil<Opts>(std::forward<Template>(layout), std::forward<T>(value), buffer);
+   }
+
+   template <auto Opts = opts{.format = MUSTACHE}, class Template, class T>
+      requires(Opts.format == MUSTACHE)
+   [[nodiscard]] expected<std::string, error_ctx> mustache(Template&& layout, T&& value)
+   {
+      std::string buffer{};
+      auto ec = stencil<Opts>(std::forward<Template>(layout), std::forward<T>(value), buffer);
+      if (ec) {
+         return unexpected<error_ctx>(ec);
+      }
+      return {buffer};
+   }
+}
diff --git a/deps/saucer/include/glaze/stencil/stencilcount.hpp b/deps/saucer/include/glaze/stencil/stencilcount.hpp
new file mode 100644
index 0000000..75a9d82
--- /dev/null
+++ b/deps/saucer/include/glaze/stencil/stencilcount.hpp
@@ -0,0 +1,183 @@
+// Glaze Library
+// For the license information refer to glaze.hpp
+
+#pragma once
+
+#include "glaze/core/read.hpp"
+#include "glaze/core/reflect.hpp"
+#include "glaze/core/write.hpp"
+#include "glaze/format/format_to.hpp"
+
+namespace glz
+{
+   template <auto Opts = opts{}, class Template, class T, resizable Buffer>
+   [[nodiscard]] error_ctx stencilcount(Template&& layout, T&& value, Buffer& buffer)
+   {
+      context ctx{};
+
+      if (layout.empty()) [[unlikely]] {
+         ctx.error = error_code::no_read_input;
+         return {ctx.error, ctx.custom_error_message, 0};
+      }
+
+      auto [it, end] = read_iterators<Opts, false>(layout);
+      auto outer_start = it;
+      if (layout.empty()) [[unlikely]] {
+         ctx.error = error_code::no_read_input;
+      }
+      if (not bool(ctx.error)) [[likely]] {
+         auto skip_whitespace = [&] {
+            while (whitespace_table[uint8_t(*it)]) {
+               ++it;
+            }
+         };
+
+         std::unordered_map<uint64_t, uint64_t> numbering{};
+         uint64_t major_count{};
+         uint64_t prev_count{};
+
+         while (it < end) {
+            switch (*it) {
+            case '{': {
+               ++it;
+               if (*it == '{') {
+                  ++it;
+                  skip_whitespace();
+
+                  uint64_t count{};
+                  while (*it == '+') {
+                     ++it;
+                     ++count;
+                  }
+
+                  if (count < prev_count) {
+                     numbering.clear();
+                  }
+
+                  if (count == 1) {
+                     ++major_count;
+                     format_to(buffer, major_count);
+                     buffer.append(".");
+                  }
+                  else if (count > 1) {
+                     format_to(buffer, major_count);
+
+                     for (size_t i = 1; i < count; ++i) {
+                        buffer.append(".");
+                        auto& x = numbering[i];
+                        if (i == (count - 1)) {
+                           ++x;
+                        }
+                        format_to(buffer, x);
+                     }
+                  }
+
+                  if (count > 0) {
+                     prev_count = count;
+                  }
+
+                  if (*it == '}') {
+                     ++it;
+                     if (*it == '}') {
+                        ++it;
+                        break;
+                     }
+                     else {
+                        buffer.append("}");
+                     }
+                     break;
+                  }
+
+                  auto start = it;
+                  while (it != end && *it != '}' && *it != ' ' && *it != '\t') {
+                     ++it;
+                  }
+
+                  const sv key{start, size_t(it - start)};
+
+                  skip_whitespace();
+
+                  static constexpr auto N = reflect<T>::size;
+                  static constexpr auto HashInfo = hash_info<T>;
+
+                  const auto index =
+                     decode_hash_with_size<STENCIL, T, HashInfo, HashInfo.type>::op(start, end, key.size());
+
+                  if (index < N) [[likely]] {
+                     static thread_local std::string temp{};
+                     visit<N>(
+                        [&]<size_t I>() {
+                           static constexpr auto TargetKey = get<I>(reflect<T>::keys);
+                           static constexpr auto Length = TargetKey.size();
+                           if ((Length == key.size()) && comparitor<TargetKey>(start)) [[likely]] {
+                              if constexpr (reflectable<T> && N > 0) {
+                                 std::ignore = write<opt_true<Opts, &opts::raw>>(
+                                    get_member(value, get<I>(to_tie(value))), temp, ctx);
+                              }
+                              else if constexpr (glaze_object_t<T> && N > 0) {
+                                 std::ignore = write<opt_true<Opts, &opts::raw>>(
+                                    get_member(value, get<I>(reflect<T>::values)), temp, ctx);
+                              }
+                           }
+                           else {
+                              ctx.error = error_code::unknown_key;
+                           }
+                        },
+                        index);
+
+                     if (bool(ctx.error)) [[unlikely]] {
+                        return {ctx.error, ctx.custom_error_message, size_t(it - start)};
+                     }
+
+                     buffer.append(temp);
+                  }
+                  else {
+                     // TODO: Is this an error?
+                  }
+
+                  skip_whitespace();
+
+                  if (*it == '}') {
+                     ++it;
+                     if (*it == '}') {
+                        ++it;
+                        break;
+                     }
+                     else {
+                        buffer.append("}");
+                     }
+                     break;
+                  }
+               }
+               else {
+                  buffer.push_back('{');
+               }
+
+               break;
+            }
+            default: {
+               buffer.push_back(*it);
+               ++it;
+            }
+            }
+         }
+      }
+
+      if (bool(ctx.error)) [[unlikely]] {
+         return {ctx.error, ctx.custom_error_message, size_t(it - outer_start)};
+      }
+
+      return {};
+   }
+
+   template <auto Opts = opts{}, class Template, class T>
+   [[nodiscard]] expected<std::string, error_ctx> stencilcount(Template&& layout, T&& value)
+   {
+      std::string buffer{};
+      auto ec = stencilcount(std::forward<Template>(layout), std::forward<T>(value), buffer);
+      if (ec) {
+         return unexpected<error_ctx>(ec);
+      }
+      return {buffer};
+   }
+}
diff --git a/deps/saucer/include/glaze/thread/async.hpp b/deps/saucer/include/glaze/thread/async.hpp
new file mode 100644
index 0000000..2f1c4b5
--- /dev/null
+++ b/deps/saucer/include/glaze/thread/async.hpp
@@ -0,0 +1,126 @@
+// Glaze Library
+// For the license information refer to glaze.hpp
+
+#pragma once
+
+#include <concepts>
+#include <mutex>
+#include <shared_mutex>
+#include <type_traits>
+#include <utility>
+
+#include "glaze/util/type_traits.hpp"
+
+// The purpose of glz::async is to create a thread-safe wrapper around a type
+// The only way to access the data is by supplying lambdas to `read` or `write`
+// methods, which feed underlying data into the lambda.
+// A lock is held for the duration of the call.
+
+// Example:
+// struct foo { int x{}; };
+// async<foo> s{};
+// s.write([](auto& value) { value.x = 42; });
+// s.read([](const auto& value) { std::cout << value.x << '\n'; });
+
+namespace glz
+{
+   template <class T, class Callable>
+   concept const_callable = std::invocable<Callable, const T&>;
+
+   template <class T, class Callable>
+   concept non_const_callable = std::invocable<Callable, T&&> || std::invocable<Callable, T&>;
+
+   template <class Arg, class Callable>
+   concept void_return = std::same_as<std::invoke_result_t<Callable, Arg>, void>;
+
+   template <class T>
+   class async
+   {
+      T data{};
+      mutable std::shared_mutex mtx{};
+
+     public:
+      async() = default;
+
+      template <class U>
+         requires(!is_specialization_v<std::decay_t<U>, async>)
+      async(U&& initial_value) : data(std::forward<U>(initial_value))
+      {}
+
+      async(const async& other)
+         requires(std::copy_constructible<T>)
+      {
+         std::shared_lock lock(other.mtx);
+         data = other.data;
+      }
+
+      async(async&& other) noexcept(std::is_nothrow_move_constructible_v<T>)
+         requires(std::move_constructible<T>)
+      {
+         std::unique_lock lock(other.mtx);
+         data = std::move(other.data);
+      }
+
+      async& operator=(const async& other)
+         requires(std::is_copy_assignable_v<T>)
+      {
+         if (this != &other) {
+            std::scoped_lock lock(mtx, other.mtx);
+            data = other.data;
+         }
+         return *this;
+      }
+
+      async& operator=(async&& other) noexcept(std::is_nothrow_move_assignable_v<T>)
+         requires(std::is_move_assignable_v<T>)
+      {
+         if (this != &other) {
+            std::scoped_lock lock(mtx, other.mtx);
+            data = std::move(other.data);
+         }
+         return *this;
+      }
+
+      T copy() const
+      {
+         std::shared_lock lock(mtx);
+         return data;
+      }
+
+      // Read with non-void return value.
+      template <class Callable>
+         requires(const_callable<T, Callable> && !void_return<const T&, Callable>)
+      auto read(Callable&& f) const -> std::invoke_result_t<Callable, const T&>
+      {
+         std::shared_lock lock(mtx);
+         return std::forward<Callable>(f)(data);
+      }
+
+      // Read with void return.
+      template <class Callable>
+         requires(const_callable<T, Callable> && void_return<const T&, Callable>)
+      void read(Callable&& f) const
+      {
+         std::shared_lock lock(mtx);
+         std::forward<Callable>(f)(data);
+      }
+
+      // Write with non-void return value.
+      template <class Callable>
+         requires(non_const_callable<T, Callable> && !void_return<T&, Callable>)
+      auto write(Callable&& f) -> std::invoke_result_t<Callable, T&>
+      {
+         std::unique_lock lock(mtx);
+         return std::forward<Callable>(f)(data);
+      }
+
+      // Write with void return.
+      template <class Callable>
+         requires(non_const_callable<T, Callable> && void_return<T&, Callable>)
+      void write(Callable&& f)
+      {
+         std::unique_lock lock(mtx);
+         std::forward<Callable>(f)(data);
+      }
+   };
+}
diff --git a/deps/saucer/include/glaze/thread/async_string.hpp b/deps/saucer/include/glaze/thread/async_string.hpp
new file mode 100644
index 0000000..4073b89
--- /dev/null
+++ b/deps/saucer/include/glaze/thread/async_string.hpp
@@ -0,0 +1,800 @@
+// Glaze Library
+// For the license information refer to glaze.hpp
+
+#pragma once
+
+#include <algorithm>
+#include <mutex>
+#include <shared_mutex>
+#include <string>
+#include <string_view>
+#include <utility>
+#include <version>
+
+#include "glaze/core/common.hpp"
+
+// Provides a thread safe wrapper around a std::string, which Glaze knows how to serialize/deserialize safely
+
+namespace glz
+{
+   struct async_string
+   {
+     private:
+      std::string str;
+      mutable std::shared_mutex mutex;
+
+     public:
+      async_string() = default;
+      async_string(const char* s) : str(s) {}
+      async_string(const std::string& s) : str(s) {}
+      async_string(std::string&& s) : str(std::move(s)) {}
+      async_string(const std::string_view& sv) : str(sv) {}
+
+      async_string(const async_string& other)
+      {
+         std::shared_lock lock(other.mutex);
+         str = other.str;
+      }
+
+      async_string(async_string&& other) noexcept
+      {
+         std::unique_lock lock(other.mutex);
+         str = std::move(other.str);
+      }
+
+      async_string& operator=(const async_string& other)
+      {
+         if (this != &other) {
+            std::unique_lock lock1(mutex, std::defer_lock);
+            std::shared_lock lock2(other.mutex, std::defer_lock);
+            std::lock(lock1, lock2);
+            str = other.str;
+         }
+         return *this;
+      }
+
+      async_string& operator=(async_string&& other) noexcept
+      {
+         if (this != &other) {
+            std::unique_lock lock1(mutex, std::defer_lock);
+            std::unique_lock lock2(other.mutex, std::defer_lock);
+            std::lock(lock1, lock2);
+            str = std::move(other.str);
+         }
+         return *this;
+      }
+
+      async_string& operator=(const std::string& s)
+      {
+         std::unique_lock lock(mutex);
+         str = s;
+         return *this;
+      }
+
+      async_string& operator=(std::string&& s)
+      {
+         std::unique_lock lock(mutex);
+         str = std::move(s);
+         return *this;
+      }
+
+      async_string& operator=(const char* s)
+      {
+         std::unique_lock lock(mutex);
+         str = s;
+         return *this;
+      }
+
+      async_string& operator=(const std::string_view& sv)
+      {
+         std::unique_lock lock(mutex);
+         str = sv;
+         return *this;
+      }
+
+      explicit operator std::string() const
+      {
+         std::shared_lock lock{mutex};
+         return str;
+      }
+
+      struct proxy
+      {
+         std::string* ptr{};
+         std::unique_lock<std::shared_mutex> lock{};
+
+        public:
+         proxy(std::string& p, std::unique_lock<std::shared_mutex>&& lock) noexcept : ptr{&p}, lock(std::move(lock)) {}
+
+         operator std::string_view() { return *ptr; }
+
+         std::string* operator->() noexcept { return ptr; }
+         const std::string* operator->() const noexcept { return ptr; }
+
+         std::string& operator*() noexcept { return *ptr; }
+         const std::string& operator*() const noexcept { return *ptr; }
+
+         std::string& value() noexcept { return *ptr; }
+         const std::string& value() const noexcept { return *ptr; }
+
+         // Size/capacity
+         [[nodiscard]] size_t size() const noexcept { return ptr->size(); }
+         [[nodiscard]] size_t length() const noexcept { return ptr->length(); }
+         [[nodiscard]] size_t max_size() const noexcept { return ptr->max_size(); }
+         [[nodiscard]] size_t capacity() const noexcept { return ptr->capacity(); }
+         [[nodiscard]] bool empty() const noexcept { return ptr->empty(); }
+         void reserve(size_t new_cap) { ptr->reserve(new_cap); }
+         void shrink_to_fit() { ptr->shrink_to_fit(); }
+
+         // Element access
+         char& operator[](size_t pos) { return (*ptr)[pos]; }
+         const char& operator[](size_t pos) const { return (*ptr)[pos]; }
+         char& at(size_t pos) { return ptr->at(pos); }
+         const char& at(size_t pos) const { return ptr->at(pos); }
+         char& front() { return ptr->front(); }
+         const char& front() const { return ptr->front(); }
+         char& back() { return ptr->back(); }
+         const char& back() const { return ptr->back(); }
+         char* data() noexcept { return ptr->data(); }
+         const char* data() const noexcept { return ptr->data(); }
+         const char* c_str() const noexcept { return ptr->c_str(); }
+
+         // Modifiers
+         void clear() noexcept { ptr->clear(); }
+         void insert(size_t pos, const std::string& str) { ptr->insert(pos, str); }
+         void insert(size_t pos, const std::string_view& sv) { ptr->insert(pos, sv); }
+         void insert(size_t pos, const char* s) { ptr->insert(pos, s); }
+         void insert(size_t pos, const char* s, size_t n) { ptr->insert(pos, s, n); }
+         void insert(size_t pos, size_t n, char c) { ptr->insert(pos, n, c); }
+         void erase(size_t pos = 0, size_t count = std::string::npos) { ptr->erase(pos, count); }
+         void push_back(char c) { ptr->push_back(c); }
+         void pop_back() { ptr->pop_back(); }
+
+         proxy& append(const std::string& str)
+         {
+            ptr->append(str);
+            return *this;
+         }
+         proxy& append(const std::string_view& sv)
+         {
+            ptr->append(sv);
+            return *this;
+         }
+         proxy& append(const char* s)
+         {
+            ptr->append(s);
+            return *this;
+         }
+         proxy& append(const char* s, size_t n)
+         {
+            ptr->append(s, n);
+            return *this;
+         }
+         proxy& append(size_t n, char c)
+         {
+            ptr->append(n, c);
+            return *this;
+         }
+
+         proxy& operator+=(const std::string& str)
+         {
+            ptr->operator+=(str);
+            return *this;
+         }
+         proxy& operator+=(const std::string_view& sv)
+         {
+            ptr->operator+=(sv);
+            return *this;
+         }
+         proxy& operator+=(const char* s)
+         {
+            ptr->operator+=(s);
+            return *this;
+         }
+         proxy& operator+=(char c)
+         {
+            ptr->operator+=(c);
+            return *this;
+         }
+
+         void resize(size_t count) { ptr->resize(count); }
+         void resize(size_t count, char ch) { ptr->resize(count, ch); }
+         void swap(std::string& other) { ptr->swap(other); }
+
+         // String operations
+         int compare(const std::string& str) const noexcept { return ptr->compare(str); }
+         int compare(const std::string_view& sv) const noexcept { return ptr->compare(sv); }
+         int compare(const char* s) const noexcept { return ptr->compare(s); }
+         int compare(size_t pos1, size_t count1, const std::string& str) const
+         {
+            return ptr->compare(pos1, count1, str);
+         }
+
+         std::string substr(size_t pos = 0, size_t count = std::string::npos) const { return ptr->substr(pos, count); }
+
+         bool starts_with(const std::string_view& sv) const noexcept { return ptr->starts_with(sv); }
+         bool starts_with(char c) const noexcept { return ptr->starts_with(c); }
+         bool starts_with(const char* s) const { return ptr->starts_with(s); }
+
+         bool ends_with(const std::string_view& sv) const noexcept { return ptr->ends_with(sv); }
+         bool ends_with(char c) const noexcept { return ptr->ends_with(c); }
+         bool ends_with(const char* s) const { return ptr->ends_with(s); }
+
+         // Search
+         size_t find(const std::string& str, size_t pos = 0) const noexcept { return ptr->find(str, pos); }
+         size_t find(const std::string_view& sv, size_t pos = 0) const noexcept { return ptr->find(sv, pos); }
+         size_t find(const char* s, size_t pos = 0) const { return ptr->find(s, pos); }
+         size_t find(const char* s, size_t pos, size_t count) const { return ptr->find(s, pos, count); }
+         size_t find(char ch, size_t pos = 0) const noexcept { return ptr->find(ch, pos); }
+
+         size_t rfind(const std::string& str, size_t pos = std::string::npos) const noexcept
+         {
+            return ptr->rfind(str, pos);
+         }
+         size_t rfind(const std::string_view& sv, size_t pos = std::string::npos) const noexcept
+         {
+            return ptr->rfind(sv, pos);
+         }
+         size_t rfind(const char* s, size_t pos = std::string::npos) const { return ptr->rfind(s, pos); }
+         size_t rfind(const char* s, size_t pos, size_t count) const { return ptr->rfind(s, pos, count); }
+         size_t rfind(char ch, size_t pos = std::string::npos) const noexcept { return ptr->rfind(ch, pos); }
+
+         size_t find_first_of(const std::string& str, size_t pos = 0) const noexcept
+         {
+            return ptr->find_first_of(str, pos);
+         }
+         size_t find_first_of(const std::string_view& sv, size_t pos = 0) const noexcept
+         {
+            return ptr->find_first_of(sv, pos);
+         }
+         size_t find_first_of(const char* s, size_t pos = 0) const { return ptr->find_first_of(s, pos); }
+         size_t find_first_of(const char* s, size_t pos, size_t count) const
+         {
+            return ptr->find_first_of(s, pos, count);
+         }
+         size_t find_first_of(char ch, size_t pos = 0) const noexcept { return ptr->find_first_of(ch, pos); }
+
+         size_t find_last_of(const std::string& str, size_t pos = std::string::npos) const noexcept
+         {
+            return ptr->find_last_of(str, pos);
+         }
+         size_t find_last_of(const std::string_view& sv, size_t pos = std::string::npos) const noexcept
+         {
+            return ptr->find_last_of(sv, pos);
+         }
+         size_t find_last_of(const char* s, size_t pos = std::string::npos) const { return ptr->find_last_of(s, pos); }
+         size_t find_last_of(const char* s, size_t pos, size_t count) const { return ptr->find_last_of(s, pos, count); }
+         size_t find_last_of(char ch, size_t pos = std::string::npos) const noexcept
+         {
+            return ptr->find_last_of(ch, pos);
+         }
+
+         size_t find_first_not_of(const std::string& str, size_t pos = 0) const noexcept
+         {
+            return ptr->find_first_not_of(str, pos);
+         }
+         size_t find_first_not_of(const std::string_view& sv, size_t pos = 0) const noexcept
+         {
+            return ptr->find_first_not_of(sv, pos);
+         }
+         size_t find_first_not_of(const char* s, size_t pos = 0) const { return ptr->find_first_not_of(s, pos); }
+         size_t find_first_not_of(const char* s, size_t pos, size_t count) const
+         {
+            return ptr->find_first_not_of(s, pos, count);
+         }
+         size_t find_first_not_of(char ch, size_t pos = 0) const noexcept { return ptr->find_first_not_of(ch, pos); }
+
+         size_t find_last_not_of(const std::string& str, size_t pos = std::string::npos) const noexcept
+         {
+            return ptr->find_last_not_of(str, pos);
+         }
+         size_t find_last_not_of(const std::string_view& sv, size_t pos = std::string::npos) const noexcept
+         {
+            return ptr->find_last_not_of(sv, pos);
+         }
+         size_t find_last_not_of(const char* s, size_t pos = std::string::npos) const
+         {
+            return ptr->find_last_not_of(s, pos);
+         }
+         size_t find_last_not_of(const char* s, size_t pos, size_t count) const
+         {
+            return ptr->find_last_not_of(s, pos, count);
+         }
+         size_t find_last_not_of(char ch, size_t pos = std::string::npos) const noexcept
+         {
+            return ptr->find_last_not_of(ch, pos);
+         }
+
+         // Additional functionality
+         proxy& replace(size_t pos, size_t count, const std::string& str)
+         {
+            ptr->replace(pos, count, str);
+            return *this;
+         }
+         proxy& replace(size_t pos, size_t count, const std::string_view& sv)
+         {
+            ptr->replace(pos, count, sv);
+            return *this;
+         }
+         proxy& replace(size_t pos, size_t count, const char* s)
+         {
+            ptr->replace(pos, count, s);
+            return *this;
+         }
+         proxy& replace(size_t pos, size_t count, const char* s, size_t count2)
+         {
+            ptr->replace(pos, count, s, count2);
+            return *this;
+         }
+         proxy& replace(size_t pos, size_t count, size_t count2, char ch)
+         {
+            ptr->replace(pos, count, count2, ch);
+            return *this;
+         }
+      };
+
+      proxy write() { return {str, std::unique_lock{mutex}}; }
+
+      struct const_proxy
+      {
+         const std::string* ptr{};
+         std::shared_lock<std::shared_mutex> lock{};
+
+        public:
+         const_proxy(const std::string& p, std::shared_lock<std::shared_mutex>&& lock) noexcept
+            : ptr{&p}, lock(std::move(lock))
+         {}
+
+         operator const std::string_view() const { return *ptr; }
+
+         const std::string* operator->() const noexcept { return ptr; }
+
+         const std::string& operator*() const noexcept { return *ptr; }
+
+         const std::string& value() const noexcept { return *ptr; }
+
+         // Size/capacity
+         [[nodiscard]] size_t size() const noexcept { return ptr->size(); }
+         [[nodiscard]] size_t length() const noexcept { return ptr->length(); }
+         [[nodiscard]] size_t max_size() const noexcept { return ptr->max_size(); }
+         [[nodiscard]] size_t capacity() const noexcept { return ptr->capacity(); }
+         [[nodiscard]] bool empty() const noexcept { return ptr->empty(); }
+
+         // Element access
+         const char& operator[](size_t pos) const { return (*ptr)[pos]; }
+         const char& at(size_t pos) const { return ptr->at(pos); }
+         const char& front() const { return ptr->front(); }
+         const char& back() const { return ptr->back(); }
+         const char* data() const noexcept { return ptr->data(); }
+         const char* c_str() const noexcept { return ptr->c_str(); }
+
+         // String operations
+         int compare(const std::string& str) const noexcept { return ptr->compare(str); }
+         int compare(const std::string_view& sv) const noexcept { return ptr->compare(sv); }
+         int compare(const char* s) const noexcept { return ptr->compare(s); }
+         int compare(size_t pos1, size_t count1, const std::string& str) const
+         {
+            return ptr->compare(pos1, count1, str);
+         }
+
+         std::string substr(size_t pos = 0, size_t count = std::string::npos) const { return ptr->substr(pos, count); }
+
+         bool starts_with(const std::string_view& sv) const noexcept { return ptr->starts_with(sv); }
+         bool starts_with(char c) const noexcept { return ptr->starts_with(c); }
+         bool starts_with(const char* s) const { return ptr->starts_with(s); }
+
+         bool ends_with(const std::string_view& sv) const noexcept { return ptr->ends_with(sv); }
+         bool ends_with(char c) const noexcept { return ptr->ends_with(c); }
+         bool ends_with(const char* s) const { return ptr->ends_with(s); }
+
+         // Search
+         size_t find(const std::string& str, size_t pos = 0) const noexcept { return ptr->find(str, pos); }
+         size_t find(const std::string_view& sv, size_t pos = 0) const noexcept { return ptr->find(sv, pos); }
+         size_t find(const char* s, size_t pos = 0) const { return ptr->find(s, pos); }
+         size_t find(const char* s, size_t pos, size_t count) const { return ptr->find(s, pos, count); }
+         size_t find(char ch, size_t pos = 0) const noexcept { return ptr->find(ch, pos); }
+
+         size_t rfind(const std::string& str, size_t pos = std::string::npos) const noexcept
+         {
+            return ptr->rfind(str, pos);
+         }
+         size_t rfind(const std::string_view& sv, size_t pos = std::string::npos) const noexcept
+         {
+            return ptr->rfind(sv, pos);
+         }
+         size_t rfind(const char* s, size_t pos = std::string::npos) const { return ptr->rfind(s, pos); }
+         size_t rfind(const char* s, size_t pos, size_t count) const { return ptr->rfind(s, pos, count); }
+         size_t rfind(char ch, size_t pos = std::string::npos) const noexcept { return ptr->rfind(ch, pos); }
+
+         size_t find_first_of(const std::string& str, size_t pos = 0) const noexcept
+         {
+            return ptr->find_first_of(str, pos);
+         }
+         size_t find_first_of(const std::string_view& sv, size_t pos = 0) const noexcept
+         {
+            return ptr->find_first_of(sv, pos);
+         }
+         size_t find_first_of(const char* s, size_t pos = 0) const { return ptr->find_first_of(s, pos); }
+         size_t find_first_of(const char* s, size_t pos, size_t count) const
+         {
+            return ptr->find_first_of(s, pos, count);
+         }
+         size_t find_first_of(char ch, size_t pos = 0) const noexcept { return ptr->find_first_of(ch, pos); }
+
+         size_t find_last_of(const std::string& str, size_t pos = std::string::npos) const noexcept
+         {
+            return ptr->find_last_of(str, pos);
+         }
+         size_t find_last_of(const std::string_view& sv, size_t pos = std::string::npos) const noexcept
+         {
+            return ptr->find_last_of(sv, pos);
+         }
+         size_t find_last_of(const char* s, size_t pos = std::string::npos) const { return ptr->find_last_of(s, pos); }
+         size_t find_last_of(const char* s, size_t pos, size_t count) const { return ptr->find_last_of(s, pos, count); }
+         size_t find_last_of(char ch, size_t pos = std::string::npos) const noexcept
+         {
+            return ptr->find_last_of(ch, pos);
+         }
+
+         size_t find_first_not_of(const std::string& str, size_t pos = 0) const noexcept
+         {
+            return ptr->find_first_not_of(str, pos);
+         }
+         size_t find_first_not_of(const std::string_view& sv, size_t pos = 0) const noexcept
+         {
+            return ptr->find_first_not_of(sv, pos);
+         }
+         size_t find_first_not_of(const char* s, size_t pos = 0) const { return ptr->find_first_not_of(s, pos); }
+         size_t find_first_not_of(const char* s, size_t pos, size_t count) const
+         {
+            return ptr->find_first_not_of(s, pos, count);
+         }
+         size_t find_first_not_of(char ch, size_t pos = 0) const noexcept { return ptr->find_first_not_of(ch, pos); }
+
+         size_t find_last_not_of(const std::string& str, size_t pos = std::string::npos) const noexcept
+         {
+            return ptr->find_last_not_of(str, pos);
+         }
+         size_t find_last_not_of(const std::string_view& sv, size_t pos = std::string::npos) const noexcept
+         {
+            return ptr->find_last_not_of(sv, pos);
+         }
+         size_t find_last_not_of(const char* s, size_t pos = std::string::npos) const
+         {
+            return ptr->find_last_not_of(s, pos);
+         }
+         size_t find_last_not_of(const char* s, size_t pos, size_t count) const
+         {
+            return ptr->find_last_not_of(s, pos, count);
+         }
+         size_t find_last_not_of(char ch, size_t pos = std::string::npos) const noexcept
+         {
+            return ptr->find_last_not_of(ch, pos);
+         }
+      };
+
+      const_proxy read() const { return {str, std::shared_lock{mutex}}; }
+
+      // Capacity
+      size_t size() const noexcept
+      {
+         std::shared_lock lock(mutex);
+         return str.size();
+      }
+
+      size_t length() const noexcept
+      {
+         std::shared_lock lock(mutex);
+         return str.length();
+      }
+
+      bool empty() const noexcept
+      {
+         std::shared_lock lock(mutex);
+         return str.empty();
+      }
+
+      // Modifiers
+      void clear() noexcept
+      {
+         std::unique_lock lock(mutex);
+         str.clear();
+      }
+
+      void push_back(char c)
+      {
+         std::unique_lock lock(mutex);
+         str.push_back(c);
+      }
+
+      void pop_back()
+      {
+         std::unique_lock lock(mutex);
+         str.pop_back();
+      }
+
+      template <class RHS>
+         requires(std::same_as<std::remove_cvref_t<RHS>, std::string>)
+      async_string& append(RHS&& s)
+      {
+         std::unique_lock lock(mutex);
+         str.append(std::forward<RHS>(s));
+         return *this;
+      }
+
+      async_string& append(const char* s, size_t count)
+      {
+         std::unique_lock lock(mutex);
+         str.append(s, count);
+         return *this;
+      }
+
+      async_string& append(const std::string_view& sv)
+      {
+         std::unique_lock lock(mutex);
+         str.append(sv);
+         return *this;
+      }
+
+      template <class RHS>
+         requires(std::same_as<std::remove_cvref_t<RHS>, async_string>)
+      async_string& append(RHS&& other)
+      {
+         std::unique_lock lock(mutex, std::defer_lock);
+         std::shared_lock lock2(other.mutex, std::defer_lock);
+         std::lock(lock, lock2);
+         str.append(other.str);
+         return *this;
+      }
+
+      template <class RHS>
+         requires(std::same_as<std::remove_cvref_t<RHS>, std::string>)
+      async_string& insert(size_t pos, RHS&& s)
+      {
+         std::unique_lock lock(mutex);
+         str.insert(pos, std::forward<RHS>(s));
+         return *this;
+      }
+
+      async_string& insert(size_t pos, const std::string_view& sv)
+      {
+         std::unique_lock lock(mutex);
+         str.insert(pos, sv);
+         return *this;
+      }
+
+      template <class RHS>
+         requires(std::same_as<std::remove_cvref_t<RHS>, async_string>)
+      async_string& insert(size_t pos, RHS&& other)
+      {
+         std::unique_lock lock(mutex, std::defer_lock);
+         std::shared_lock lock2(other.mutex, std::defer_lock);
+         std::lock(lock, lock2);
+         str.insert(pos, other.str);
+         return *this;
+      }
+
+      template <class RHS>
+         requires(std::same_as<std::remove_cvref_t<RHS>, std::string>)
+      async_string& operator+=(RHS&& s)
+      {
+         return append(std::forward<RHS>(s));
+      }
+
+      async_string& operator+=(const std::string_view& sv) { return append(sv); }
+
+      async_string& operator+=(char c)
+      {
+         std::unique_lock lock(mutex);
+         str += c;
+         return *this;
+      }
+
+      void reserve(size_t count)
+      {
+         std::unique_lock lock(mutex);
+         str.reserve(count);
+      }
+
+      void resize(size_t count)
+      {
+         std::unique_lock lock(mutex);
+         str.resize(count);
+      }
+
+      void resize(size_t count, const char ch)
+      {
+         std::unique_lock lock(mutex);
+         str.resize(count, ch);
+      }
+
+      // Element access
+      char at(size_t pos) const
+      {
+         std::shared_lock lock(mutex);
+         return str.at(pos);
+      }
+
+      char operator[](size_t pos) const
+      {
+         std::shared_lock lock(mutex);
+         return str[pos];
+      }
+
+      char front() const
+      {
+         std::shared_lock lock(mutex);
+         return str.front();
+      }
+
+      char back() const
+      {
+         std::shared_lock lock(mutex);
+         return str.back();
+      }
+
+      int compare(const async_string& other) const
+      {
+         std::scoped_lock lock{mutex, other.mutex};
+         return str.compare(other.str);
+      }
+
+      bool starts_with(const std::string_view other) const
+      {
+         std::shared_lock lock{mutex};
+         return str.starts_with(other);
+      }
+
+      bool ends_with(const std::string_view other) const
+      {
+         std::shared_lock lock{mutex};
+         return str.ends_with(other);
+      }
+
+      std::string substr(size_t pos = 0, size_t len = std::string::npos) const
+      {
+         std::shared_lock lock{mutex};
+         return str.substr(pos, len);
+      }
+
+      friend bool operator==(const async_string& lhs, const async_string& rhs)
+      {
+         if (&lhs == &rhs) return true;
+         std::shared_lock lock(lhs.mutex, std::defer_lock);
+         std::shared_lock lock2(rhs.mutex, std::defer_lock);
+         std::lock(lock, lock2);
+         return lhs.str == rhs.str;
+      }
+
+      // async_string != async_string
+      friend bool operator!=(const async_string& lhs, const async_string& rhs) { return !(lhs == rhs); }
+
+      // async_string == std::string_view
+      friend bool operator==(const async_string& lhs, std::string_view rhs)
+      {
+         std::shared_lock lock(lhs.mutex);
+         return lhs.str == rhs;
+      }
+
+      // std::string_view == async_string
+      friend bool operator==(std::string_view lhs, const async_string& rhs)
+      {
+         std::shared_lock lock(rhs.mutex);
+         return lhs == rhs.str;
+      }
+
+      // async_string != std::string_view
+      friend bool operator!=(const async_string& lhs, std::string_view rhs) { return !(lhs == rhs); }
+
+      // std::string_view != async_string
+      friend bool operator!=(std::string_view lhs, const async_string& rhs) { return !(lhs == rhs); }
+
+      // async_string == std::string
+      friend bool operator==(const async_string& lhs, const std::string& rhs)
+      {
+         std::shared_lock lock(lhs.mutex);
+         return lhs.str == rhs;
+      }
+
+      // std::string == async_string
+      friend bool operator==(const std::string& lhs, const async_string& rhs)
+      {
+         std::shared_lock lock(rhs.mutex);
+         return lhs == rhs.str;
+      }
+
+      // async_string != std::string
+      friend bool operator!=(const async_string& lhs, const std::string& rhs) { return !(lhs == rhs); }
+
+      // std::string != async_string
+      friend bool operator!=(const std::string& lhs, const async_string& rhs) { return !(lhs == rhs); }
+
+      // async_string == const char*
+      friend bool operator==(const async_string& lhs, const char* rhs)
+      {
+         std::shared_lock lock(lhs.mutex);
+         return lhs.str == rhs;
+      }
+
+      // const char* == async_string
+      friend bool operator==(const char* lhs, const async_string& rhs)
+      {
+         std::shared_lock lock(rhs.mutex);
+         return lhs == rhs.str;
+      }
+
+      // async_string != const char*
+      friend bool operator!=(const async_string& lhs, const char* rhs) { return !(lhs == rhs); }
+
+      // const char* != async_string
+      friend bool operator!=(const char* lhs, const async_string& rhs) { return !(lhs == rhs); }
+
+      friend bool operator<(const async_string& lhs, const async_string& rhs)
+      {
+         std::scoped_lock lock{lhs.mutex, rhs.mutex};
+         return lhs.str < rhs.str;
+      }
+
+      friend bool operator<=(const async_string& lhs, const async_string& rhs) { return !(rhs < lhs); }
+
+      friend bool operator>(const async_string& lhs, const async_string& rhs) { return rhs < lhs; }
+
+      friend bool operator>=(const async_string& lhs, const async_string& rhs) { return !(lhs < rhs); }
+
+      void swap(async_string& other)
+      {
+         if (this == &other) return;
+         std::scoped_lock lock{mutex, other.mutex};
+         str.swap(other.str);
+      }
+
+      friend void swap(async_string& lhs, async_string& rhs) { lhs.swap(rhs); }
+   };
+
+}
+
+namespace glz
+{
+   template <uint32_t Format>
+   struct from<Format, glz::async_string>
+   {
+      template <auto Opts>
+      static void op(auto&& value, is_context auto&& ctx, auto&& it, auto&& end) noexcept
+      {
+         auto proxy = value.write();
+         parse<Format>::template op<Opts>(*proxy, ctx, it, end);
+      }
+   };
+
+   template <uint32_t Format>
+   struct to<Format, glz::async_string>
+   {
+      template <auto Opts>
+      static void op(auto&& value, is_context auto&& ctx, auto&&... args) noexcept
+      {
+         auto proxy = value.read();
+         serialize<Format>::template op<Opts>(*proxy, ctx, args...);
+      }
+   };
+}
+
+// Allow formatting via std::format
+#ifdef __cpp_lib_format
+#include <format>
+namespace std
+{
+   template <>
+   struct formatter<glz::async_string>
+   {
+      std::formatter<std::string> formatter;
+
+      constexpr auto parse(format_parse_context& ctx) -> decltype(ctx.begin()) { return formatter.parse(ctx); }
+
+      template <class FormatContext>
+      auto format(const glz::async_string& s, FormatContext& ctx) const -> decltype(ctx.out())
+      {
+         return formatter.format(*s.read(), ctx);
+      }
+   };
+}
+#endif
diff --git a/deps/saucer/include/glaze/thread/async_vector.hpp b/deps/saucer/include/glaze/thread/async_vector.hpp
new file mode 100644
index 0000000..fd4bea8
--- /dev/null
+++ b/deps/saucer/include/glaze/thread/async_vector.hpp
@@ -0,0 +1,417 @@
+#pragma once
+
+#include <algorithm>
+#include <mutex>
+#include <shared_mutex>
+#include <utility>
+#include <vector>
+
+#ifndef GLZ_THROW_OR_ABORT
+#if __cpp_exceptions
+#define GLZ_THROW_OR_ABORT(EXC) (throw(EXC))
+#define GLZ_NOEXCEPT noexcept(false)
+#else
+#define GLZ_THROW_OR_ABORT(EXC) (std::abort())
+#define GLZ_NOEXCEPT noexcept(true)
+#endif
+#endif
+
+#include "glaze/thread/value_proxy.hpp"
+
+// Provides a thread-safe vector
+// Uses simple proxy objects with appropriate locks for read/write operations
+
+namespace glz
+{
+   template <class T>
+   struct async_vector
+   {
+     private:
+      std::vector<T> items;
+      mutable std::shared_mutex mutex;
+
+     public:
+      using value_type = T;
+      using size_type = std::size_t;
+      using difference_type = std::ptrdiff_t;
+      using reference = T&;
+      using const_reference = const T&;
+
+      // Constructors
+      async_vector() = default;
+
+      // Copy constructor
+      async_vector(const async_vector& other)
+      {
+         std::shared_lock lock(other.mutex);
+         items = other.items;
+      }
+
+      // Move constructor
+      async_vector(async_vector&& other) noexcept
+      {
+         std::unique_lock lock(other.mutex);
+         items = std::move(other.items);
+      }
+
+      // Copy assignment
+      async_vector& operator=(const async_vector& other)
+      {
+         if (this != &other) {
+            std::unique_lock lock1(mutex, std::defer_lock);
+            std::shared_lock lock2(other.mutex, std::defer_lock);
+            std::lock(lock1, lock2);
+            items = other.items;
+         }
+         return *this;
+      }
+
+      // Move assignment
+      async_vector& operator=(async_vector&& other) noexcept
+      {
+         if (this != &other) {
+            std::unique_lock lock1(mutex, std::defer_lock);
+            std::unique_lock lock2(other.mutex, std::defer_lock);
+            std::lock(lock1, lock2);
+            items = std::move(other.items);
+         }
+         return *this;
+      }
+
+      // Proxy for write access
+      struct proxy
+      {
+         using value_type = typename std::vector<T>::value_type;
+         using size_type = typename std::vector<T>::size_type;
+         using difference_type = typename std::vector<T>::difference_type;
+         using reference = typename std::vector<T>::reference;
+         using const_reference = typename std::vector<T>::const_reference;
+         using pointer = typename std::vector<T>::pointer;
+         using const_pointer = typename std::vector<T>::const_pointer;
+         using iterator = typename std::vector<T>::iterator;
+         using const_iterator = typename std::vector<T>::const_iterator;
+         using reverse_iterator = typename std::vector<T>::reverse_iterator;
+         using const_reverse_iterator = typename std::vector<T>::const_reverse_iterator;
+
+         std::vector<T>* ptr{};
+         std::unique_lock<std::shared_mutex> lock{};
+
+        public:
+         proxy(std::vector<T>& p, std::unique_lock<std::shared_mutex>&& lock) noexcept : ptr{&p}, lock(std::move(lock))
+         {}
+
+         // Size and capacity
+         bool empty() const noexcept { return ptr->empty(); }
+         size_type size() const noexcept { return ptr->size(); }
+         size_type max_size() const noexcept { return ptr->max_size(); }
+         size_type capacity() const noexcept { return ptr->capacity(); }
+         void reserve(size_type new_cap) { ptr->reserve(new_cap); }
+         void shrink_to_fit() { ptr->shrink_to_fit(); }
+         void resize(size_type count) { ptr->resize(count); }
+         void resize(size_type count, const value_type& value) { ptr->resize(count, value); }
+
+         // Element access
+         reference operator[](size_type pos) { return (*ptr)[pos]; }
+         const_reference operator[](size_type pos) const { return (*ptr)[pos]; }
+         reference at(size_type pos) { return ptr->at(pos); }
+         const_reference at(size_type pos) const { return ptr->at(pos); }
+         reference front() { return ptr->front(); }
+         const_reference front() const { return ptr->front(); }
+         reference back() { return ptr->back(); }
+         const_reference back() const { return ptr->back(); }
+         T* data() noexcept { return ptr->data(); }
+         const T* data() const noexcept { return ptr->data(); }
+
+         // Iterators
+         iterator begin() noexcept { return ptr->begin(); }
+         const_iterator begin() const noexcept { return ptr->begin(); }
+         const_iterator cbegin() const noexcept { return ptr->cbegin(); }
+
+         iterator end() noexcept { return ptr->end(); }
+         const_iterator end() const noexcept { return ptr->end(); }
+         const_iterator cend() const noexcept { return ptr->cend(); }
+
+         reverse_iterator rbegin() noexcept { return ptr->rbegin(); }
+         const_reverse_iterator rbegin() const noexcept { return ptr->rbegin(); }
+         const_reverse_iterator crbegin() const noexcept { return ptr->crbegin(); }
+
+         reverse_iterator rend() noexcept { return ptr->rend(); }
+         const_reverse_iterator rend() const noexcept { return ptr->rend(); }
+         const_reverse_iterator crend() const noexcept { return ptr->crend(); }
+
+         // Modifiers
+         void clear() { ptr->clear(); }
+
+         iterator insert(const_iterator pos, const T& value) { return ptr->insert(pos, value); }
+
+         iterator insert(const_iterator pos, T&& value) { return ptr->insert(pos, std::move(value)); }
+
+         iterator insert(const_iterator pos, size_type count, const T& value) { return ptr->insert(pos, count, value); }
+
+         template <class InputIt>
+         iterator insert(const_iterator pos, InputIt first, InputIt last)
+         {
+            return ptr->insert(pos, first, last);
+         }
+
+         iterator insert(const_iterator pos, std::initializer_list<T> ilist) { return ptr->insert(pos, ilist); }
+
+         template <class... Args>
+         iterator emplace(const_iterator pos, Args&&... args)
+         {
+            return ptr->emplace(pos, std::forward<Args>(args)...);
+         }
+
+         iterator erase(const_iterator pos) { return ptr->erase(pos); }
+
+         iterator erase(const_iterator first, const_iterator last) { return ptr->erase(first, last); }
+
+         void push_back(const T& value) { ptr->push_back(value); }
+
+         void push_back(T&& value) { ptr->push_back(std::move(value)); }
+
+         template <class... Args>
+         reference emplace_back(Args&&... args)
+         {
+            return ptr->emplace_back(std::forward<Args>(args)...);
+         }
+
+         void pop_back() { ptr->pop_back(); }
+
+         void swap(proxy& other) noexcept(noexcept(ptr->swap(*other.ptr))) { ptr->swap(*other.ptr); }
+
+         void swap(std::vector<T>& other) noexcept(noexcept(ptr->swap(other))) { ptr->swap(other); }
+
+         // Comparison operators
+         bool operator==(const proxy& other) const { return *ptr == *other.ptr; }
+
+         bool operator!=(const proxy& other) const { return *ptr != *other.ptr; }
+
+         bool operator<(const proxy& other) const { return *ptr < *other.ptr; }
+
+         bool operator<=(const proxy& other) const { return *ptr <= *other.ptr; }
+
+         bool operator>(const proxy& other) const { return *ptr > *other.ptr; }
+
+         bool operator>=(const proxy& other) const { return *ptr >= *other.ptr; }
+
+         // Allow access to the underlying vector for advanced operations
+         std::vector<T>* operator->() noexcept { return ptr; }
+         const std::vector<T>* operator->() const noexcept { return ptr; }
+
+         std::vector<T>& operator*() noexcept { return *ptr; }
+         const std::vector<T>& operator*() const noexcept { return *ptr; }
+
+         std::vector<T>& value() noexcept { return *ptr; }
+         const std::vector<T>& value() const noexcept { return *ptr; }
+      };
+
+      // Proxy for read access
+      struct const_proxy
+      {
+         using value_type = typename std::vector<T>::value_type;
+         using size_type = typename std::vector<T>::size_type;
+         using difference_type = typename std::vector<T>::difference_type;
+         using reference = typename std::vector<T>::reference;
+         using const_reference = typename std::vector<T>::const_reference;
+         using pointer = typename std::vector<T>::pointer;
+         using const_pointer = typename std::vector<T>::const_pointer;
+         using iterator = typename std::vector<T>::iterator;
+         using const_iterator = typename std::vector<T>::const_iterator;
+         using reverse_iterator = typename std::vector<T>::reverse_iterator;
+         using const_reverse_iterator = typename std::vector<T>::const_reverse_iterator;
+
+         const std::vector<T>* ptr{};
+         std::shared_lock<std::shared_mutex> lock{};
+
+        public:
+         const_proxy(const std::vector<T>& p, std::shared_lock<std::shared_mutex>&& lock) noexcept
+            : ptr{&p}, lock(std::move(lock))
+         {}
+
+         // Size and capacity
+         bool empty() const noexcept { return ptr->empty(); }
+         size_type size() const noexcept { return ptr->size(); }
+         size_type max_size() const noexcept { return ptr->max_size(); }
+         size_type capacity() const noexcept { return ptr->capacity(); }
+
+         // Iterators
+         const_iterator begin() const noexcept { return ptr->begin(); }
+         const_iterator cbegin() const noexcept { return ptr->cbegin(); }
+
+         const_iterator end() const noexcept { return ptr->end(); }
+         const_iterator cend() const noexcept { return ptr->cend(); }
+
+         const_reverse_iterator rbegin() const noexcept { return ptr->rbegin(); }
+         const_reverse_iterator crbegin() const noexcept { return ptr->crbegin(); }
+
+         const_reverse_iterator rend() const noexcept { return ptr->rend(); }
+         const_reverse_iterator crend() const noexcept { return ptr->crend(); }
+
+         // Element access
+         const T& operator[](size_type pos) const { return (*ptr)[pos]; }
+         const T& at(size_type pos) const { return ptr->at(pos); }
+         const T& front() const { return ptr->front(); }
+         const T& back() const { return ptr->back(); }
+
+         // Allow access to the underlying vector for advanced operations
+         const std::vector<T>* operator->() const noexcept { return ptr; }
+         const std::vector<T>& operator*() const noexcept { return *ptr; }
+         const std::vector<T>& value() const noexcept { return *ptr; }
+      };
+
+      // Core access methods
+      proxy write() { return {items, std::unique_lock{mutex}}; }
+      const_proxy read() const { return {items, std::shared_lock{mutex}}; }
+
+      // Common operations with their own locks (for convenience)
+      bool empty() const noexcept
+      {
+         std::shared_lock lock(mutex);
+         return items.empty();
+      }
+
+      size_type size() const noexcept
+      {
+         std::shared_lock lock(mutex);
+         return items.size();
+      }
+
+      void resize(size_type count)
+      {
+         std::unique_lock lock(mutex);
+         items.resize(count);
+      }
+
+      void resize(size_type count, const value_type& value)
+      {
+         std::unique_lock lock(mutex);
+         items.resize(count, value);
+      }
+
+      void clear() noexcept
+      {
+         std::unique_lock lock(mutex);
+         items.clear();
+      }
+
+      void push_back(const T& value)
+      {
+         std::unique_lock lock(mutex);
+         items.push_back(value);
+      }
+
+      void push_back(T&& value)
+      {
+         std::unique_lock lock(mutex);
+         items.push_back(std::move(value));
+      }
+
+      template <class... Args>
+      void emplace_back(Args&&... args)
+      {
+         std::unique_lock lock(mutex);
+         items.emplace_back(std::forward<Args>(args)...);
+      }
+
+      void pop_back()
+      {
+         std::unique_lock lock(mutex);
+         items.pop_back();
+      }
+
+      // Capacity methods
+      size_type max_size() const noexcept
+      {
+         std::shared_lock lock(mutex);
+         return items.max_size();
+      }
+
+      void reserve(size_type new_cap)
+      {
+         std::unique_lock lock(mutex);
+         items.reserve(new_cap);
+      }
+
+      size_type capacity() const noexcept
+      {
+         std::shared_lock lock(mutex);
+         return items.capacity();
+      }
+
+      void shrink_to_fit()
+      {
+         std::unique_lock lock(mutex);
+         items.shrink_to_fit();
+      }
+
+      // Swap operations
+      void swap(async_vector& other) noexcept
+      {
+         if (this == &other) return;
+         std::scoped_lock lock(mutex, other.mutex);
+         items.swap(other.items);
+      }
+
+      friend void swap(async_vector& a, async_vector& b) noexcept { a.swap(b); }
+
+      friend bool operator==(const async_vector& lhs, const async_vector& rhs)
+      {
+         if (&lhs == &rhs) return true;
+         std::shared_lock lock(lhs.mutex, std::defer_lock);
+         std::shared_lock lock2(rhs.mutex, std::defer_lock);
+         std::lock(lock, lock2);
+         return lhs.items == rhs.items;
+      }
+
+      // async_vector != async_vector
+      friend bool operator!=(const async_vector& lhs, const async_vector& rhs) { return !(lhs == rhs); }
+
+      // async_vector == const std::vector<T>&
+      friend bool operator==(const async_vector& lhs, const std::vector<T>& rhs)
+      {
+         std::shared_lock lock(lhs.mutex);
+         return lhs.items == rhs;
+      }
+
+      // const std::vector<T>& == async_vector
+      friend bool operator==(const std::vector<T>& lhs, const async_vector& rhs)
+      {
+         std::shared_lock lock(rhs.mutex);
+         return lhs == rhs.items;
+      }
+
+      // async_vector != const std::vector<T>&
+      friend bool operator!=(const async_vector& lhs, const std::vector<T>& rhs) { return !(lhs == rhs); }
+
+      // const std::vector<T>& != async_vector
+      friend bool operator!=(const std::vector<T>& lhs, const async_vector& rhs) { return !(lhs == rhs); }
+   };
+}
+
+namespace glz
+{
+   template <uint32_t Format, class T>
+      requires(is_specialization_v<T, glz::async_vector>)
+   struct from<Format, T>
+   {
+      template <auto Opts>
+      static void op(auto&& value, is_context auto&& ctx, auto&& it, auto&& end) noexcept
+      {
+         auto proxy = value.write();
+         parse<Format>::template op<Opts>(*proxy, ctx, it, end);
+      }
+   };
+
+   template <uint32_t Format, class T>
+      requires(is_specialization_v<T, glz::async_vector>)
+   struct to<Format, T>
+   {
+      template <auto Opts>
+      static void op(auto&& value, is_context auto&& ctx, auto&&... args) noexcept
+      {
+         auto proxy = value.read();
+         serialize<Format>::template op<Opts>(*proxy, ctx, args...);
+      }
+   };
+}
diff --git a/deps/saucer/include/glaze/thread/atomic.hpp b/deps/saucer/include/glaze/thread/atomic.hpp
new file mode 100644
index 0000000..2307ea5
--- /dev/null
+++ b/deps/saucer/include/glaze/thread/atomic.hpp
@@ -0,0 +1,48 @@
+// Glaze Library
+// For the license information refer to glaze.hpp
+
+#pragma once
+
+#include "glaze/core/common.hpp"
+
+// Supports serialization/deserialization of std::atomic
+
+namespace glz
+{
+   template <typename T>
+   concept is_atomic = requires(T a, typename std::remove_reference_t<decltype(a.load())>& expected,
+                                const typename std::remove_reference_t<decltype(a.load())>& desired) {
+      { a.is_lock_free() } -> std::convertible_to<bool>;
+      { a.store(desired) } noexcept;
+      { a.load() } -> std::same_as<typename std::remove_reference_t<decltype(a.load())>>;
+      { a.exchange(desired) } -> std::same_as<typename std::remove_reference_t<decltype(a.load())>>;
+      { a.compare_exchange_weak(expected, desired) } -> std::convertible_to<bool>;
+      { a.compare_exchange_strong(expected, desired) } -> std::convertible_to<bool>;
+   };
+
+   template <uint32_t Format, is_atomic T>
+      requires(not custom_read<T>)
+   struct from<Format, T>
+   {
+      template <auto Opts>
+      static void op(auto&& value, is_context auto&& ctx, auto&& it, auto&& end) noexcept
+      {
+         using V = typename T::value_type;
+         V temp{};
+         parse<Format>::template op<Opts>(temp, ctx, it, end);
+         value.store(temp);
+      }
+   };
+
+   template <uint32_t Format, is_atomic T>
+      requires(not custom_write<T>)
+   struct to<Format, T>
+   {
+      template <auto Opts>
+      static void op(auto&& value, is_context auto&& ctx, auto&&... args) noexcept
+      {
+         const auto v = value.load();
+         serialize<Format>::template op<Opts>(v, ctx, args...);
+      }
+   };
+}
diff --git a/deps/saucer/include/glaze/thread/guard.hpp b/deps/saucer/include/glaze/thread/guard.hpp
new file mode 100644
index 0000000..32766ea
--- /dev/null
+++ b/deps/saucer/include/glaze/thread/guard.hpp
@@ -0,0 +1,275 @@
+// Glaze Library
+// For the license information refer to glaze.hpp
+
+#pragma once
+
+/**
+ * @class guard
+ * @brief A copyable and comparable wrapper for std::atomic
+ * @tparam T The underlying value type
+ *
+ * The guard<T> class provides a wrapper around std::atomic<T> that adds copyability
+ * and comparability while maintaining thread-safety for individual operations.
+ * This allows for more intuitive usage patterns where atomic values need to be
+ * treated occasionally as regular values.
+ *
+ * Unlike std::atomic, guard<T> can be:
+ * - Copied (using atomic load operations)
+ * - Compared (between atoms and with raw values)
+ * - Used with familiar operator syntax
+ *
+ * @note While individual operations remain atomic, operations like comparison
+ * are not atomic as a whole, as they involve multiple loads. This wrapper is
+ * appropriate when you need the performance of atomics but occasionally need
+ * value semantics.
+ *
+ * Typical use cases:
+ * - Configuration values that are rarely updated but frequently read
+ * - Statistics and counters that need occasional comparison
+ * - Scenarios where atomic operations are needed but with more familiar syntax
+ *
+ * Example usage:
+ * @code
+ * guard<int> counter(0);
+ *
+ * // Thread-safe operations
+ * counter++;
+ * counter += 5;
+ *
+ * // Copyable
+ * guard<int> copy = counter;
+ *
+ * // Comparable
+ * if (counter > 10) { ... }
+ * if (counter == copy) { ... }
+ * @endcode
+ */
+
+#include <atomic>
+#include <concepts>
+
+#include "glaze/thread/atomic.hpp"
+
+namespace glz
+{
+   template <typename T>
+   class guard
+   {
+     private:
+      std::atomic<T> value;
+
+     public:
+      using value_type = T;
+
+      // Default constructor
+      constexpr guard() noexcept : value() {}
+
+      // Constructor with initial value
+      explicit constexpr guard(T desired) noexcept : value(desired) {}
+
+      guard(const guard& other) noexcept : value(other.load()) {}
+
+      guard(guard&& other) noexcept : value(other.load()) {}
+
+      guard& operator=(const guard& other) noexcept
+      {
+         store(other.load());
+         return *this;
+      }
+
+      guard& operator=(guard&& other) noexcept
+      {
+         store(other.load());
+         return *this;
+      }
+
+      // Assignment from T
+      guard& operator=(T desired) noexcept
+      {
+         store(desired);
+         return *this;
+      }
+
+      // Comparison operators
+      bool operator==(const guard& other) const noexcept { return load() == other.load(); }
+
+      bool operator!=(const guard& other) const noexcept { return load() != other.load(); }
+
+      bool operator<(const guard& other) const noexcept { return load() < other.load(); }
+
+      bool operator<=(const guard& other) const noexcept { return load() <= other.load(); }
+
+      bool operator>(const guard& other) const noexcept { return load() > other.load(); }
+
+      bool operator>=(const guard& other) const noexcept { return load() >= other.load(); }
+
+      // Comparison with T
+      bool operator==(const T& other) const noexcept { return load() == other; }
+
+      bool operator!=(const T& other) const noexcept { return load() != other; }
+
+      bool operator<(const T& other) const noexcept { return load() < other; }
+
+      bool operator<=(const T& other) const noexcept { return load() <= other; }
+
+      bool operator>(const T& other) const noexcept { return load() > other; }
+
+      bool operator>=(const T& other) const noexcept { return load() >= other; }
+
+      // Core atomic operations
+      T load(std::memory_order order = std::memory_order_seq_cst) const noexcept { return value.load(order); }
+
+      void store(T desired, std::memory_order order = std::memory_order_seq_cst) noexcept
+      {
+         value.store(desired, order);
+      }
+
+      T exchange(T desired, std::memory_order order = std::memory_order_seq_cst) noexcept
+      {
+         return value.exchange(desired, order);
+      }
+
+      bool compare_exchange_weak(T& expected, T desired, std::memory_order success = std::memory_order_seq_cst,
+                                 std::memory_order failure = std::memory_order_seq_cst) noexcept
+      {
+         return value.compare_exchange_weak(expected, desired, success, failure);
+      }
+
+      bool compare_exchange_strong(T& expected, T desired, std::memory_order success = std::memory_order_seq_cst,
+                                   std::memory_order failure = std::memory_order_seq_cst) noexcept
+      {
+         return value.compare_exchange_strong(expected, desired, success, failure);
+      }
+
+      // Conversion operator to T
+      operator T() const noexcept { return load(); }
+
+      // Additional atomic operations for arithmetic types
+      T fetch_add(T arg, std::memory_order order = std::memory_order_seq_cst) noexcept
+         requires std::integral<T>
+      {
+         return value.fetch_add(arg, order);
+      }
+
+      T fetch_sub(T arg, std::memory_order order = std::memory_order_seq_cst) noexcept
+         requires std::integral<T>
+      {
+         return value.fetch_sub(arg, order);
+      }
+
+      T fetch_and(T arg, std::memory_order order = std::memory_order_seq_cst) noexcept
+         requires std::integral<T>
+      {
+         return value.fetch_and(arg, order);
+      }
+
+      T fetch_or(T arg, std::memory_order order = std::memory_order_seq_cst) noexcept
+         requires std::integral<T>
+      {
+         return value.fetch_or(arg, order);
+      }
+
+      T fetch_xor(T arg, std::memory_order order = std::memory_order_seq_cst) noexcept
+         requires std::integral<T>
+      {
+         return value.fetch_xor(arg, order);
+      }
+
+      // Operator overloads for arithmetic types
+      T operator+=(T arg) noexcept
+         requires std::integral<T> || std::floating_point<T>
+      {
+         return value.fetch_add(arg) + arg;
+      }
+
+      T operator-=(T arg) noexcept
+         requires std::integral<T> || std::floating_point<T>
+      {
+         return value.fetch_sub(arg) - arg;
+      }
+
+      T operator&=(T arg) noexcept
+         requires std::integral<T>
+      {
+         return value.fetch_and(arg) & arg;
+      }
+
+      T operator|=(T arg) noexcept
+         requires std::integral<T>
+      {
+         return value.fetch_or(arg) | arg;
+      }
+
+      T operator^=(T arg) noexcept
+         requires std::integral<T>
+      {
+         return value.fetch_xor(arg) ^ arg;
+      }
+
+      // Increment/decrement operators
+      T operator++() noexcept
+         requires std::integral<T> || std::floating_point<T>
+      {
+         return fetch_add(1) + 1;
+      }
+
+      T operator++(int) noexcept
+         requires std::integral<T> || std::floating_point<T>
+      {
+         return fetch_add(1);
+      }
+
+      T operator--() noexcept
+         requires std::integral<T> || std::floating_point<T>
+      {
+         return fetch_sub(1) - 1;
+      }
+
+      T operator--(int) noexcept
+         requires std::integral<T> || std::floating_point<T>
+      {
+         return fetch_sub(1);
+      }
+
+      bool is_lock_free() const noexcept { return value.is_lock_free(); }
+
+      bool is_lock_free() const volatile noexcept { return value.is_lock_free(); }
+   };
+
+   // Non-member comparison operators
+   template <typename T>
+   bool operator==(const T& lhs, const guard<T>& rhs) noexcept
+   {
+      return lhs == rhs.load();
+   }
+
+   template <typename T>
+   bool operator!=(const T& lhs, const guard<T>& rhs) noexcept
+   {
+      return lhs != rhs.load();
+   }
+
+   template <typename T>
+   bool operator<(const T& lhs, const guard<T>& rhs) noexcept
+   {
+      return lhs < rhs.load();
+   }
+
+   template <typename T>
+   bool operator<=(const T& lhs, const guard<T>& rhs) noexcept
+   {
+      return lhs <= rhs.load();
+   }
+
+   template <typename T>
+   bool operator>(const T& lhs, const guard<T>& rhs) noexcept
+   {
+      return lhs > rhs.load();
+   }
+
+   template <typename T>
+   bool operator>=(const T& lhs, const guard<T>& rhs) noexcept
+   {
+      return lhs >= rhs.load();
+   }
+}
diff --git a/deps/saucer/include/glaze/thread/shared_async_map.hpp b/deps/saucer/include/glaze/thread/shared_async_map.hpp
new file mode 100644
index 0000000..434cc28
--- /dev/null
+++ b/deps/saucer/include/glaze/thread/shared_async_map.hpp
@@ -0,0 +1,612 @@
+#pragma once
+
+#include <algorithm>
+#include <cassert>
+#include <iterator>
+#include <memory>
+#include <mutex>
+#include <shared_mutex>
+#include <utility>
+#include <vector>
+
+#include "glaze/thread/value_proxy.hpp"
+#include "glaze/util/expected.hpp"
+
+#ifndef GLZ_THROW_OR_ABORT
+#if __cpp_exceptions
+#define GLZ_THROW_OR_ABORT(EXC) (throw(EXC))
+#define GLZ_NOEXCEPT noexcept(false)
+#else
+#define GLZ_THROW_OR_ABORT(EXC) (std::abort())
+#define GLZ_NOEXCEPT noexcept(true)
+#endif
+#endif
+
+// Provides a semi-safe flat map
+// This shared_async_map only provides thread safety when inserting/deletion
+// It is intended to store thread safe types for more efficient access
+
+// This shared_async_map is intended to hold thread safe value types (V)
+
+namespace glz
+{
+   template <class K, class V>
+   struct shared_async_map
+   {
+     private:
+      struct shared_state
+      {
+         std::vector<std::unique_ptr<std::pair<K, V>>> items;
+         mutable std::shared_mutex mutex;
+      };
+
+      std::shared_ptr<shared_state> state = std::make_shared<shared_state>();
+
+      // Helper function to perform binary search.
+      // Returns a pair of iterator and a boolean indicating if the key was found.
+      auto binary_search_key(const K& key) const
+      {
+         auto it = std::lower_bound(
+            state->items.cbegin(), state->items.cend(), key,
+            [](const std::unique_ptr<std::pair<K, V>>& item_ptr, const K& key) { return item_ptr->first < key; });
+         if (it != state->items.cend() && !(key < (*it)->first)) { // Equivalent to key == (*it)->first
+            return std::make_pair(it, true);
+         }
+         return std::make_pair(it, false);
+      }
+
+      auto binary_search_key(const K& key)
+      {
+         auto it = std::lower_bound(
+            state->items.begin(), state->items.end(), key,
+            [](const std::unique_ptr<std::pair<K, V>>& item_ptr, const K& key) { return item_ptr->first < key; });
+         if (it != state->items.end() && !(key < (*it)->first)) { // Equivalent to key == (*it)->first
+            return std::make_pair(it, true);
+         }
+         return std::make_pair(it, false);
+      }
+
+     public:
+      using key_type = K;
+      using mapped_type = V;
+      using value_type = std::pair<K, V>;
+      using const_value_type = const std::pair<K, V>;
+
+      // Forward declaration of iterator classes
+      class iterator;
+      class const_iterator;
+
+      // Iterator Class Definition
+      class iterator
+      {
+        public:
+         using iterator_category = std::forward_iterator_tag;
+         using value_type = shared_async_map::value_type;
+         using difference_type = std::ptrdiff_t;
+         using pointer = value_type*;
+         using reference = value_type&;
+
+        private:
+         typename std::vector<std::unique_ptr<std::pair<K, V>>>::iterator item_it;
+         std::shared_ptr<shared_state> state;
+         std::shared_ptr<std::shared_lock<std::shared_mutex>> shared_lock_ptr;
+         std::shared_ptr<std::unique_lock<std::shared_mutex>> unique_lock_ptr;
+
+        public:
+         iterator(typename std::vector<std::unique_ptr<std::pair<K, V>>>::iterator item_it,
+                  std::shared_ptr<shared_state> state,
+                  std::shared_ptr<std::shared_lock<std::shared_mutex>> existing_shared_lock = nullptr,
+                  std::shared_ptr<std::unique_lock<std::shared_mutex>> existing_unique_lock = nullptr)
+            : item_it(item_it),
+              state(state),
+              shared_lock_ptr(existing_shared_lock),
+              unique_lock_ptr(existing_unique_lock)
+         {
+            // Acquire a shared lock only if no lock is provided
+            if (!shared_lock_ptr && !unique_lock_ptr) {
+               shared_lock_ptr = std::make_shared<std::shared_lock<std::shared_mutex>>(state->mutex);
+            }
+         }
+
+         // Copy Constructor
+         iterator(const iterator& other)
+            : item_it(other.item_it),
+              state(other.state),
+              shared_lock_ptr(other.shared_lock_ptr),
+              unique_lock_ptr(other.unique_lock_ptr)
+         {}
+
+         // Move Constructor
+         iterator(iterator&& other) noexcept
+            : item_it(std::move(other.item_it)),
+              state(std::move(other.state)),
+              shared_lock_ptr(std::move(other.shared_lock_ptr)),
+              unique_lock_ptr(std::move(other.unique_lock_ptr))
+         {}
+
+         // Copy Assignment
+         iterator& operator=(const iterator& other)
+         {
+            if (this != &other) {
+               item_it = other.item_it;
+               state = other.state;
+               shared_lock_ptr = other.shared_lock_ptr;
+               unique_lock_ptr = other.unique_lock_ptr;
+            }
+            return *this;
+         }
+
+         // Pre-increment
+         iterator& operator++()
+         {
+            ++item_it;
+            return *this;
+         }
+
+         // Post-increment
+         iterator operator++(int)
+         {
+            iterator tmp(*this);
+            ++(*this);
+            return tmp;
+         }
+
+         reference operator*() const { return *(*item_it); }
+
+         pointer operator->() const { return (*item_it).get(); }
+
+         // Equality Comparison
+         bool operator==(const iterator& other) const noexcept { return item_it == other.item_it; }
+
+         // Inequality Comparison
+         bool operator!=(const iterator& other) const noexcept { return !(*this == other); }
+
+         // Comparison operators with iterator
+         bool operator<(const iterator& other) const noexcept { return item_it < other.item_it; }
+         bool operator>(const iterator& other) const noexcept { return item_it > other.item_it; }
+         bool operator<=(const iterator& other) const noexcept { return item_it <= other.item_it; }
+         bool operator>=(const iterator& other) const { return item_it >= other.item_it; }
+
+         // Comparison operators with const_iterator
+         bool operator<(const const_iterator& other) const noexcept { return item_it < other.item_it; }
+         bool operator>(const const_iterator& other) const noexcept { return item_it > other.item_it; }
+         bool operator<=(const const_iterator& other) const noexcept { return item_it <= other.item_it; }
+         bool operator>=(const const_iterator& other) const noexcept { return item_it >= other.item_it; }
+      };
+
+      class const_iterator
+      {
+        public:
+         using iterator_category = std::forward_iterator_tag;
+         using value_type = shared_async_map::const_value_type;
+         using difference_type = std::ptrdiff_t;
+         using pointer = const value_type*;
+         using reference = const value_type&;
+
+        private:
+         typename std::vector<std::unique_ptr<std::pair<K, V>>>::const_iterator item_it;
+         std::shared_ptr<shared_state> state;
+         std::shared_ptr<std::shared_lock<std::shared_mutex>> shared_lock_ptr;
+
+        public:
+         const_iterator(typename std::vector<std::unique_ptr<std::pair<K, V>>>::const_iterator item_it,
+                        std::shared_ptr<shared_state> state,
+                        std::shared_ptr<std::shared_lock<std::shared_mutex>> existing_shared_lock = nullptr)
+            : item_it(item_it), state(state), shared_lock_ptr(existing_shared_lock)
+         {
+            // Acquire a shared lock only if no lock is provided
+            if (!shared_lock_ptr) {
+               shared_lock_ptr = std::make_shared<std::shared_lock<std::shared_mutex>>(state->mutex);
+            }
+         }
+
+         // Copy Constructor
+         const_iterator(const const_iterator& other)
+            : item_it(other.item_it), state(other.state), shared_lock_ptr(other.shared_lock_ptr)
+         {}
+
+         // Move Constructor
+         const_iterator(const_iterator&& other) noexcept
+            : item_it(std::move(other.item_it)),
+              state(std::move(other.state)),
+              shared_lock_ptr(std::move(other.shared_lock_ptr))
+         {}
+
+         // Copy Assignment
+         const_iterator& operator=(const const_iterator& other)
+         {
+            if (this != &other) {
+               item_it = other.item_it;
+               state = other.state;
+               shared_lock_ptr = other.shared_lock_ptr;
+            }
+            return *this;
+         }
+
+         // Pre-increment
+         const_iterator& operator++()
+         {
+            ++item_it;
+            return *this;
+         }
+
+         // Post-increment
+         const_iterator operator++(int)
+         {
+            const_iterator tmp(*this);
+            ++(*this);
+            return tmp;
+         }
+
+         reference operator*() const { return *(*item_it); }
+
+         pointer operator->() const { return (*item_it).get(); }
+
+         // Equality Comparison
+         bool operator==(const const_iterator& other) const noexcept { return item_it == other.item_it; }
+
+         // Inequality Comparison
+         bool operator!=(const const_iterator& other) const noexcept { return !(*this == other); }
+
+         // Comparison operators with const_iterator
+         bool operator<(const const_iterator& other) const noexcept { return item_it < other.item_it; }
+         bool operator>(const const_iterator& other) const noexcept { return item_it > other.item_it; }
+         bool operator<=(const const_iterator& other) const noexcept { return item_it <= other.item_it; }
+         bool operator>=(const const_iterator& other) const noexcept { return item_it >= other.item_it; }
+
+         // Comparison operators with iterator
+         bool operator<(const iterator& other) const noexcept { return item_it < other.item_it; }
+         bool operator>(const iterator& other) const noexcept { return item_it > other.item_it; }
+         bool operator<=(const iterator& other) const noexcept { return item_it <= other.item_it; }
+         bool operator>=(const iterator& other) const noexcept { return item_it >= other.item_it; }
+      };
+
+      // Value Proxy Class Definition
+      class value_proxy
+      {
+        private:
+         V& value_ref;
+         std::shared_ptr<std::shared_lock<std::shared_mutex>> shared_lock_ptr;
+         std::shared_ptr<std::unique_lock<std::shared_mutex>> unique_lock_ptr;
+
+        public:
+         value_proxy(V& value_ref, std::shared_ptr<std::shared_lock<std::shared_mutex>> existing_shared_lock = nullptr,
+                     std::shared_ptr<std::unique_lock<std::shared_mutex>> existing_unique_lock = nullptr)
+            : value_ref(value_ref), shared_lock_ptr(existing_shared_lock), unique_lock_ptr(existing_unique_lock)
+         {
+            // Ensure that a lock is provided
+            assert(shared_lock_ptr || unique_lock_ptr);
+         }
+
+         static constexpr bool glaze_value_proxy = true;
+
+         // Disable Copy and Move
+         value_proxy(const value_proxy&) = delete;
+         value_proxy& operator=(const value_proxy&) = delete;
+         value_proxy(value_proxy&&) = delete;
+         value_proxy& operator=(value_proxy&&) = delete;
+
+         // Access the value
+         V& value() { return value_ref; }
+
+         const V& value() const { return value_ref; }
+
+         // Arrow Operator
+         V* operator->() { return &value_ref; }
+
+         const V* operator->() const { return &value_ref; }
+
+         V& operator*() { return value_ref; }
+
+         const V& operator*() const { return value_ref; }
+
+         // Implicit Conversion to V&
+         operator V&() { return value_ref; }
+
+         operator const V&() const { return value_ref; }
+
+         template <class T>
+         value_proxy& operator=(const T& other)
+         {
+            value_ref = other;
+            return *this;
+         }
+
+         bool operator==(const V& other) const { return value() == other; }
+      };
+
+      // Const Value Proxy Class Definition
+      class const_value_proxy
+      {
+        private:
+         const V& value_ref;
+         std::shared_ptr<std::shared_lock<std::shared_mutex>> shared_lock_ptr;
+
+        public:
+         const_value_proxy(const V& value_ref,
+                           std::shared_ptr<std::shared_lock<std::shared_mutex>> existing_shared_lock)
+            : value_ref(value_ref), shared_lock_ptr(existing_shared_lock)
+         {
+            // Ensure that a lock is provided
+            assert(shared_lock_ptr);
+         }
+
+         // Disable Copy and Move
+         const_value_proxy(const const_value_proxy&) = delete;
+         const_value_proxy& operator=(const const_value_proxy&) = delete;
+         const_value_proxy(const const_value_proxy&&) = delete;
+         const_value_proxy& operator=(const const_value_proxy&&) = delete;
+
+         // Access the value
+         const V& value() const { return value_ref; }
+
+         // Arrow Operator
+         const V* operator->() const { return &value_ref; }
+
+         const V& operator*() const { return value_ref; }
+
+         // Implicit Conversion to const V&
+         operator const V&() const { return value_ref; }
+
+         bool operator==(const V& other) const { return value() == other; }
+      };
+
+      value_proxy operator[](const K& key)
+      {
+         // Acquire a shared lock to search for the key
+         std::shared_lock<std::shared_mutex> shared_lock(state->mutex);
+         auto [it, found] = binary_search_key(key);
+
+         if (found) {
+            auto shared_lock_ptr = std::make_shared<std::shared_lock<std::shared_mutex>>(std::move(shared_lock));
+            return value_proxy((*it)->second, shared_lock_ptr);
+         }
+         else {
+            // Key doesn't exist; release the shared_lock
+            shared_lock.unlock();
+            // Acquire a unique lock to modify the map
+            std::unique_lock<std::shared_mutex> unique_lock(state->mutex);
+
+            // Double-check if the key was inserted by another thread
+            std::tie(it, found) = binary_search_key(key);
+
+            if (!found) {
+               // Insert a new element with default-constructed value
+               it = state->items.insert(
+                  it, std::make_unique<std::pair<K, V>>(std::piecewise_construct, std::forward_as_tuple(key),
+                                                        std::forward_as_tuple()));
+            }
+
+            unique_lock.unlock();
+            shared_lock.lock();
+
+            // Find the value once again in case a modification occurred
+            std::tie(it, found) = binary_search_key(key);
+
+            if (!found) {
+               GLZ_THROW_OR_ABORT(std::out_of_range("Key was removed by another thread"));
+            }
+
+            auto shared_lock_ptr = std::make_shared<std::shared_lock<std::shared_mutex>>(std::move(shared_lock));
+            return value_proxy((*it)->second, shared_lock_ptr);
+         }
+      }
+
+      // Insert method behaves like std::map::insert
+      std::pair<iterator, bool> insert(const std::pair<K, V>& pair)
+      {
+         auto unique_lock_ptr = std::make_shared<std::unique_lock<std::shared_mutex>>(state->mutex);
+
+         // Perform binary search to find the key
+         auto [it, found] = binary_search_key(pair.first);
+
+         if (found) {
+            return {iterator(it, state, nullptr, unique_lock_ptr), false};
+         }
+         else {
+            // Insert while maintaining sorted order
+            it = state->items.insert(it, std::make_unique<std::pair<K, V>>(pair));
+            return {iterator(it, state, nullptr, unique_lock_ptr), true};
+         }
+      }
+
+      template <class Key, class Value>
+      std::pair<iterator, bool> emplace(Key&& key, Value&& value)
+      {
+         auto unique_lock_ptr = std::make_shared<std::unique_lock<std::shared_mutex>>(state->mutex);
+
+         // Perform binary search to find the key
+         auto [it, found] = binary_search_key(key);
+
+         if (found) {
+            return {iterator(it, state, nullptr, unique_lock_ptr), false};
+         }
+         else {
+            // Insert while maintaining sorted order
+            it = state->items.insert(
+               it, std::make_unique<std::pair<K, V>>(std::forward<Key>(key), std::forward<Value>(value)));
+            return {iterator(it, state, nullptr, unique_lock_ptr), true};
+         }
+      }
+
+      // Emplace method
+      template <typename... Args>
+      std::pair<iterator, bool> emplace(const K& key, Args&&... args)
+      {
+         auto unique_lock_ptr = std::make_shared<std::unique_lock<std::shared_mutex>>(state->mutex);
+
+         // Perform binary search to find the key
+         auto [it, found] = binary_search_key(key);
+
+         if (found) {
+            return {iterator(it, state, nullptr, unique_lock_ptr), false};
+         }
+         else {
+            // Construct value in place while maintaining sorted order
+            it = state->items.insert(
+               it, std::make_unique<std::pair<K, V>>(std::piecewise_construct, std::forward_as_tuple(key),
+                                                     std::forward_as_tuple(std::forward<Args>(args)...)));
+            return {iterator(it, state, nullptr, unique_lock_ptr), true};
+         }
+      }
+
+      // Try_emplace method
+      template <typename... Args>
+      std::pair<iterator, bool> try_emplace(const K& key, Args&&... args)
+      {
+         return emplace(key, std::forward<Args>(args)...);
+      }
+
+      // Clear all elements
+      void clear()
+      {
+         std::unique_lock lock(state->mutex);
+         state->items.clear();
+      }
+
+      // Erase a key
+      void erase(const K& key)
+      {
+         std::unique_lock lock(state->mutex);
+
+         // Perform binary search to find the key
+         auto [it, found] = binary_search_key(key);
+
+         if (found) {
+            state->items.erase(it);
+         }
+      }
+
+      // Find an iterator to the key
+      iterator find(const K& key)
+      {
+         auto shared_lock_ptr = std::make_shared<std::shared_lock<std::shared_mutex>>(state->mutex);
+
+         // Perform binary search to find the key
+         auto [it, found] = binary_search_key(key);
+
+         if (found) {
+            return iterator(it, state, shared_lock_ptr);
+         }
+         else {
+            return end();
+         }
+      }
+
+      // Const version of find
+      const_iterator find(const K& key) const
+      {
+         auto shared_lock_ptr = std::make_shared<std::shared_lock<std::shared_mutex>>(state->mutex);
+
+         // Perform binary search to find the key
+         auto [it, found] = binary_search_key(key);
+
+         if (found) {
+            return const_iterator(it, state, shared_lock_ptr);
+         }
+         else {
+            return end();
+         }
+      }
+
+      // Access element with bounds checking (non-const)
+      value_proxy at(const K& key)
+      {
+         auto shared_lock_ptr = std::make_shared<std::shared_lock<std::shared_mutex>>(state->mutex);
+
+         // Perform binary search to find the key
+         auto [it, found] = binary_search_key(key);
+
+         if (found) {
+            return value_proxy((*it)->second, shared_lock_ptr);
+         }
+         else {
+            GLZ_THROW_OR_ABORT(std::out_of_range("Key not found"));
+         }
+      }
+
+      // Access element with bounds checking (const)
+      const_value_proxy at(const K& key) const
+      {
+         auto shared_lock_ptr = std::make_shared<std::shared_lock<std::shared_mutex>>(state->mutex);
+
+         // Perform binary search to find the key
+         auto [it, found] = binary_search_key(key);
+
+         if (found) {
+            return const_value_proxy((*it)->second, shared_lock_ptr);
+         }
+         else {
+            GLZ_THROW_OR_ABORT(std::out_of_range("Key not found"));
+         }
+      }
+
+      // Begin iterator (non-const)
+      iterator begin()
+      {
+         auto shared_lock_ptr = std::make_shared<std::shared_lock<std::shared_mutex>>(state->mutex);
+         return iterator(state->items.begin(), state, shared_lock_ptr);
+      }
+
+      // End iterator (non-const)
+      iterator end()
+      {
+         auto shared_lock_ptr = std::make_shared<std::shared_lock<std::shared_mutex>>(state->mutex);
+         return iterator(state->items.end(), state, shared_lock_ptr);
+      }
+
+      // Begin iterator (const)
+      const_iterator begin() const
+      {
+         auto shared_lock_ptr = std::make_shared<std::shared_lock<std::shared_mutex>>(state->mutex);
+         return const_iterator(state->items.cbegin(), state, shared_lock_ptr);
+      }
+
+      // End iterator (const)
+      const_iterator end() const
+      {
+         auto shared_lock_ptr = std::make_shared<std::shared_lock<std::shared_mutex>>(state->mutex);
+         return const_iterator(state->items.cend(), state, shared_lock_ptr);
+      }
+
+      const_iterator cbegin() const
+      {
+         auto shared_lock_ptr = std::make_shared<std::shared_lock<std::shared_mutex>>(state->mutex);
+         return const_iterator(state->items.cbegin(), state, shared_lock_ptr);
+      }
+
+      const_iterator cend() const
+      {
+         auto shared_lock_ptr = std::make_shared<std::shared_lock<std::shared_mutex>>(state->mutex);
+         return const_iterator(state->items.cend(), state, shared_lock_ptr);
+      }
+
+      // Count the number of elements with the given key (0 or 1)
+      size_t count(const K& key) const
+      {
+         std::shared_lock lock(state->mutex);
+         auto [it, found] = binary_search_key(key);
+         return found ? 1 : 0;
+      }
+
+      size_t size() const
+      {
+         std::shared_lock lock(state->mutex);
+         return state->items.size();
+      }
+
+      // Check if the map contains the key
+      bool contains(const K& key) const
+      {
+         std::shared_lock lock(state->mutex);
+         auto [it, found] = binary_search_key(key);
+         return found;
+      }
+
+      bool empty() const
+      {
+         std::shared_lock lock(state->mutex);
+         return state->items.size() == 0;
+      }
+   };
+}
diff --git a/deps/saucer/include/glaze/thread/shared_async_vector.hpp b/deps/saucer/include/glaze/thread/shared_async_vector.hpp
new file mode 100644
index 0000000..fd7dc2e
--- /dev/null
+++ b/deps/saucer/include/glaze/thread/shared_async_vector.hpp
@@ -0,0 +1,637 @@
+#pragma once
+
+#include <algorithm>
+#include <cassert>
+#include <iterator>
+#include <memory>
+#include <mutex>
+#include <shared_mutex>
+#include <utility>
+#include <vector>
+
+#include "glaze/thread/value_proxy.hpp"
+#include "glaze/util/expected.hpp"
+
+#ifndef GLZ_THROW_OR_ABORT
+#if __cpp_exceptions
+#define GLZ_THROW_OR_ABORT(EXC) (throw(EXC))
+#define GLZ_NOEXCEPT noexcept(false)
+#else
+#define GLZ_THROW_OR_ABORT(EXC) (std::abort())
+#define GLZ_NOEXCEPT noexcept(true)
+#endif
+#endif
+
+// Provides a thread-safe vector with shared ownership
+// This shared_async_vector allows multiple instances to share the same data and mutex
+// It ensures thread safety during read and write operations
+
+namespace glz
+{
+
+   template <class V>
+   struct shared_async_vector
+   {
+     private:
+      struct shared_state
+      {
+         std::vector<std::unique_ptr<V>> items;
+         mutable std::shared_mutex mutex;
+      };
+
+      std::shared_ptr<shared_state> state = std::make_shared<shared_state>();
+
+     public:
+      using value_type = V;
+      using size_type = std::size_t;
+      using difference_type = std::ptrdiff_t;
+      using reference = V&;
+      using const_reference = const V&;
+      using pointer = V*;
+      using const_pointer = const V*;
+
+      // Forward declaration of iterator classes
+      class iterator;
+      class const_iterator;
+
+      // Iterator Class Definition
+      class iterator
+      {
+        public:
+         using iterator_category = std::random_access_iterator_tag;
+         using value_type = V;
+         using difference_type = std::ptrdiff_t;
+         using pointer = V*;
+         using reference = V&;
+
+        private:
+         typename std::vector<std::unique_ptr<V>>::iterator item_it;
+         std::shared_ptr<shared_state> state;
+         std::shared_ptr<std::shared_lock<std::shared_mutex>> shared_lock_ptr;
+         std::shared_ptr<std::unique_lock<std::shared_mutex>> unique_lock_ptr;
+
+        public:
+         iterator(typename std::vector<std::unique_ptr<V>>::iterator item_it, std::shared_ptr<shared_state> state,
+                  std::shared_ptr<std::shared_lock<std::shared_mutex>> existing_shared_lock = nullptr,
+                  std::shared_ptr<std::unique_lock<std::shared_mutex>> existing_unique_lock = nullptr)
+            : item_it(item_it),
+              state(state),
+              shared_lock_ptr(existing_shared_lock),
+              unique_lock_ptr(existing_unique_lock)
+         {
+            // Acquire a shared lock only if no lock is provided
+            if (!shared_lock_ptr && !unique_lock_ptr) {
+               shared_lock_ptr = std::make_shared<std::shared_lock<std::shared_mutex>>(state->mutex);
+            }
+         }
+
+         // Copy Constructor
+         iterator(const iterator& other)
+            : item_it(other.item_it),
+              state(other.state),
+              shared_lock_ptr(other.shared_lock_ptr),
+              unique_lock_ptr(other.unique_lock_ptr)
+         {}
+
+         // Move Constructor
+         iterator(iterator&& other) noexcept
+            : item_it(std::move(other.item_it)),
+              state(std::move(other.state)),
+              shared_lock_ptr(std::move(other.shared_lock_ptr)),
+              unique_lock_ptr(std::move(other.unique_lock_ptr))
+         {}
+
+         // Copy Assignment
+         iterator& operator=(const iterator& other)
+         {
+            if (this != &other) {
+               item_it = other.item_it;
+               state = other.state;
+               shared_lock_ptr = other.shared_lock_ptr;
+               unique_lock_ptr = other.unique_lock_ptr;
+            }
+            return *this;
+         }
+
+         friend struct shared_async_vector<V>;
+
+         // Dereference operators
+         reference operator*() const { return *(*item_it); }
+         pointer operator->() const { return (*item_it).get(); }
+
+         // Increment and Decrement operators
+         iterator& operator++()
+         {
+            ++item_it;
+            return *this;
+         }
+
+         iterator operator++(int)
+         {
+            iterator tmp(*this);
+            ++(*this);
+            return tmp;
+         }
+
+         iterator& operator--()
+         {
+            --item_it;
+            return *this;
+         }
+
+         iterator operator--(int)
+         {
+            iterator tmp(*this);
+            --(*this);
+            return tmp;
+         }
+
+         // Arithmetic operators
+         iterator operator+(difference_type n) const
+         {
+            return iterator(item_it + n, state, shared_lock_ptr, unique_lock_ptr);
+         }
+
+         iterator& operator+=(difference_type n)
+         {
+            item_it += n;
+            return *this;
+         }
+
+         iterator operator-(difference_type n) const
+         {
+            return iterator(item_it - n, state, shared_lock_ptr, unique_lock_ptr);
+         }
+
+         iterator& operator-=(difference_type n)
+         {
+            item_it -= n;
+            return *this;
+         }
+
+         difference_type operator-(const iterator& other) const { return item_it - other.item_it; }
+
+         // Comparison operators
+         bool operator==(const iterator& other) const noexcept { return item_it == other.item_it; }
+         bool operator!=(const iterator& other) const noexcept { return item_it != other.item_it; }
+         bool operator<(const iterator& other) const noexcept { return item_it < other.item_it; }
+         bool operator>(const iterator& other) const noexcept { return item_it > other.item_it; }
+         bool operator<=(const iterator& other) const noexcept { return item_it <= other.item_it; }
+         bool operator>=(const iterator& other) const noexcept { return item_it >= other.item_it; }
+
+         // Access operator
+         reference operator[](difference_type n) const { return *(*(item_it + n)); }
+      };
+
+      // Const Iterator Class Definition
+      class const_iterator
+      {
+        public:
+         using iterator_category = std::random_access_iterator_tag;
+         using value_type = V;
+         using difference_type = std::ptrdiff_t;
+         using pointer = const V*;
+         using reference = const V&;
+
+        private:
+         typename std::vector<std::unique_ptr<V>>::const_iterator item_it;
+         std::shared_ptr<shared_state> state;
+         std::shared_ptr<std::shared_lock<std::shared_mutex>> shared_lock_ptr;
+
+        public:
+         const_iterator(typename std::vector<std::unique_ptr<V>>::const_iterator item_it,
+                        std::shared_ptr<shared_state> state,
+                        std::shared_ptr<std::shared_lock<std::shared_mutex>> existing_shared_lock = nullptr)
+            : item_it(item_it), state(state), shared_lock_ptr(existing_shared_lock)
+         {
+            // Acquire a shared lock only if no lock is provided
+            if (!shared_lock_ptr) {
+               shared_lock_ptr = std::make_shared<std::shared_lock<std::shared_mutex>>(state->mutex);
+            }
+         }
+
+         // Copy Constructor
+         const_iterator(const const_iterator& other)
+            : item_it(other.item_it), state(other.state), shared_lock_ptr(other.shared_lock_ptr)
+         {}
+
+         // Move Constructor
+         const_iterator(const_iterator&& other) noexcept
+            : item_it(std::move(other.item_it)),
+              state(std::move(other.state)),
+              shared_lock_ptr(std::move(other.shared_lock_ptr))
+         {}
+
+         // Copy Assignment
+         const_iterator& operator=(const const_iterator& other)
+         {
+            if (this != &other) {
+               item_it = other.item_it;
+               state = other.state;
+               shared_lock_ptr = other.shared_lock_ptr;
+            }
+            return *this;
+         }
+
+         friend struct shared_async_vector<V>;
+
+         // Dereference operators
+         reference operator*() const { return *(*item_it); }
+         pointer operator->() const { return (*item_it).get(); }
+
+         // Increment and Decrement operators
+         const_iterator& operator++()
+         {
+            ++item_it;
+            return *this;
+         }
+
+         const_iterator operator++(int)
+         {
+            const_iterator tmp(*this);
+            ++(*this);
+            return tmp;
+         }
+
+         const_iterator& operator--()
+         {
+            --item_it;
+            return *this;
+         }
+
+         const_iterator operator--(int)
+         {
+            const_iterator tmp(*this);
+            --(*this);
+            return tmp;
+         }
+
+         // Arithmetic operators
+         const_iterator operator+(difference_type n) const
+         {
+            return const_iterator(item_it + n, state, shared_lock_ptr);
+         }
+
+         const_iterator& operator+=(difference_type n)
+         {
+            item_it += n;
+            return *this;
+         }
+
+         const_iterator operator-(difference_type n) const
+         {
+            return const_iterator(item_it - n, state, shared_lock_ptr);
+         }
+
+         const_iterator& operator-=(difference_type n)
+         {
+            item_it -= n;
+            return *this;
+         }
+
+         difference_type operator-(const const_iterator& other) const { return item_it - other.item_it; }
+
+         // Comparison operators
+         bool operator==(const const_iterator& other) const noexcept { return item_it == other.item_it; }
+         bool operator!=(const const_iterator& other) const noexcept { return item_it != other.item_it; }
+         bool operator<(const const_iterator& other) const noexcept { return item_it < other.item_it; }
+         bool operator>(const const_iterator& other) const noexcept { return item_it > other.item_it; }
+         bool operator<=(const const_iterator& other) const noexcept { return item_it <= other.item_it; }
+         bool operator>=(const const_iterator& other) const noexcept { return item_it >= other.item_it; }
+
+         // Access operator
+         reference operator[](difference_type n) const { return *(*(item_it + n)); }
+      };
+
+      // Value Proxy Class Definition
+      class value_proxy
+      {
+        private:
+         V& value_ref;
+         std::shared_ptr<std::shared_lock<std::shared_mutex>> shared_lock_ptr;
+         std::shared_ptr<std::unique_lock<std::shared_mutex>> unique_lock_ptr;
+
+        public:
+         value_proxy(V& value_ref, std::shared_ptr<std::shared_lock<std::shared_mutex>> existing_shared_lock = nullptr,
+                     std::shared_ptr<std::unique_lock<std::shared_mutex>> existing_unique_lock = nullptr)
+            : value_ref(value_ref), shared_lock_ptr(existing_shared_lock), unique_lock_ptr(existing_unique_lock)
+         {
+            // Ensure that a lock is provided
+            assert(shared_lock_ptr || unique_lock_ptr);
+         }
+
+         static constexpr bool glaze_value_proxy = true;
+
+         // Disable Copy and Move
+         value_proxy(const value_proxy&) = delete;
+         value_proxy& operator=(const value_proxy&) = delete;
+         value_proxy(value_proxy&&) = delete;
+         value_proxy& operator=(value_proxy&&) = delete;
+
+         // Access the value
+         V& value() { return value_ref; }
+
+         const V& value() const { return value_ref; }
+
+         // Arrow Operator
+         V* operator->() { return &value_ref; }
+
+         const V* operator->() const { return &value_ref; }
+
+         V& operator*() { return value_ref; }
+
+         const V& operator*() const { return value_ref; }
+
+         // Implicit Conversion to V&
+         operator V&() { return value_ref; }
+
+         operator const V&() const { return value_ref; }
+
+         template <class T>
+         value_proxy& operator=(const T& other)
+         {
+            value_ref = other;
+            return *this;
+         }
+
+         bool operator==(const V& other) const { return value() == other; }
+      };
+
+      // Const Value Proxy Class Definition
+      class const_value_proxy
+      {
+        private:
+         const V& value_ref;
+         std::shared_ptr<std::shared_lock<std::shared_mutex>> shared_lock_ptr;
+
+        public:
+         const_value_proxy(const V& value_ref,
+                           std::shared_ptr<std::shared_lock<std::shared_mutex>> existing_shared_lock)
+            : value_ref(value_ref), shared_lock_ptr(existing_shared_lock)
+         {
+            // Ensure that a lock is provided
+            assert(shared_lock_ptr);
+         }
+
+         // Disable Copy and Move
+         const_value_proxy(const const_value_proxy&) = delete;
+         const_value_proxy& operator=(const const_value_proxy&) = delete;
+         const_value_proxy(const_value_proxy&&) = delete;
+         const_value_proxy& operator=(const const_value_proxy&&) = delete;
+
+         // Access the value
+         const V& value() const { return value_ref; }
+
+         // Arrow Operator
+         const V* operator->() const { return &value_ref; }
+
+         const V& operator*() const { return value_ref; }
+
+         // Implicit Conversion to const V&
+         operator const V&() const { return value_ref; }
+
+         bool operator==(const V& other) const { return value() == other; }
+      };
+
+      // Element Access Methods
+      value_proxy operator[](size_type pos)
+      {
+         auto shared_lock_ptr = std::make_shared<std::shared_lock<std::shared_mutex>>(state->mutex);
+         return value_proxy(*state->items[pos], shared_lock_ptr);
+      }
+
+      const_value_proxy operator[](size_type pos) const
+      {
+         auto shared_lock_ptr = std::make_shared<std::shared_lock<std::shared_mutex>>(state->mutex);
+         return const_value_proxy(*state->items[pos], shared_lock_ptr);
+      }
+
+      value_proxy at(size_type pos)
+      {
+         auto shared_lock_ptr = std::make_shared<std::shared_lock<std::shared_mutex>>(state->mutex);
+         if (pos >= state->items.size()) {
+            GLZ_THROW_OR_ABORT(std::out_of_range("Index out of range"));
+         }
+         return value_proxy(*state->items[pos], shared_lock_ptr);
+      }
+
+      const_value_proxy at(size_type pos) const
+      {
+         auto shared_lock_ptr = std::make_shared<std::shared_lock<std::shared_mutex>>(state->mutex);
+         if (pos >= state->items.size()) {
+            GLZ_THROW_OR_ABORT(std::out_of_range("Index out of range"));
+         }
+         return const_value_proxy(*state->items[pos], shared_lock_ptr);
+      }
+
+      value_proxy front()
+      {
+         auto shared_lock_ptr = std::make_shared<std::shared_lock<std::shared_mutex>>(state->mutex);
+         return value_proxy(*state->items.front(), shared_lock_ptr);
+      }
+
+      const_value_proxy front() const
+      {
+         auto shared_lock_ptr = std::make_shared<std::shared_lock<std::shared_mutex>>(state->mutex);
+         return const_value_proxy(*state->items.front(), shared_lock_ptr);
+      }
+
+      value_proxy back()
+      {
+         auto shared_lock_ptr = std::make_shared<std::shared_lock<std::shared_mutex>>(state->mutex);
+         return value_proxy(*state->items.back(), shared_lock_ptr);
+      }
+
+      const_value_proxy back() const
+      {
+         auto shared_lock_ptr = std::make_shared<std::shared_lock<std::shared_mutex>>(state->mutex);
+         return const_value_proxy(*state->items.back(), shared_lock_ptr);
+      }
+
+      // Capacity Methods
+      bool empty() const
+      {
+         std::shared_lock lock(state->mutex);
+         return state->items.empty();
+      }
+
+      size_type size() const
+      {
+         std::shared_lock lock(state->mutex);
+         return state->items.size();
+      }
+
+      size_type max_size() const
+      {
+         std::shared_lock lock(state->mutex);
+         return state->items.max_size();
+      }
+
+      void reserve(size_type new_cap)
+      {
+         std::unique_lock lock(state->mutex);
+         state->items.reserve(new_cap);
+      }
+
+      size_type capacity() const
+      {
+         std::shared_lock lock(state->mutex);
+         return state->items.capacity();
+      }
+
+      void shrink_to_fit()
+      {
+         std::unique_lock lock(state->mutex);
+         state->items.shrink_to_fit();
+      }
+
+      // Modifiers
+      void clear()
+      {
+         std::unique_lock lock(state->mutex);
+         state->items.clear();
+      }
+
+      void push_back(const V& value)
+      {
+         std::unique_lock lock(state->mutex);
+         state->items.push_back(std::make_unique<V>(value));
+      }
+
+      template <class... Args>
+      void emplace_back(Args&&... args)
+      {
+         std::unique_lock lock(state->mutex);
+         state->items.emplace_back(std::make_unique<V>(std::forward<Args>(args)...));
+      }
+
+      void pop_back()
+      {
+         std::unique_lock lock(state->mutex);
+         state->items.pop_back();
+      }
+
+      iterator insert(const_iterator pos, const V& value)
+      {
+         auto unique_lock_ptr = std::make_shared<std::unique_lock<std::shared_mutex>>(state->mutex);
+         auto it = state->items.insert(pos.item_it, std::make_unique<V>(value));
+         return iterator(it, state, nullptr, unique_lock_ptr);
+      }
+
+      iterator insert(const_iterator pos, V&& value)
+      {
+         auto unique_lock_ptr = std::make_shared<std::unique_lock<std::shared_mutex>>(state->mutex);
+         auto it = state->items.insert(pos.item_it, std::make_unique<V>(std::move(value)));
+         return iterator(it, state, nullptr, unique_lock_ptr);
+      }
+
+      template <class... Args>
+      iterator emplace(const_iterator pos, Args&&... args)
+      {
+         auto unique_lock_ptr = std::make_shared<std::unique_lock<std::shared_mutex>>(state->mutex);
+         auto it = state->items.emplace(pos.item_it, std::make_unique<V>(std::forward<Args>(args)...));
+         return iterator(it, state, nullptr, unique_lock_ptr);
+      }
+
+      iterator erase(iterator pos)
+      {
+         auto unique_lock_ptr = std::make_shared<std::unique_lock<std::shared_mutex>>(state->mutex);
+         auto it = state->items.erase(pos.item_it);
+         return iterator(it, state, nullptr, unique_lock_ptr);
+      }
+
+      iterator erase(iterator first, iterator last)
+      {
+         auto unique_lock_ptr = std::make_shared<std::unique_lock<std::shared_mutex>>(state->mutex);
+         auto it = state->items.erase(first.item_it, last.item_it);
+         return iterator(it, state, nullptr, unique_lock_ptr);
+      }
+
+      iterator erase(const_iterator pos)
+      {
+         auto unique_lock_ptr = std::make_shared<std::unique_lock<std::shared_mutex>>(state->mutex);
+         auto it = state->items.erase(pos.item_it);
+         return iterator(it, state, nullptr, unique_lock_ptr);
+      }
+
+      iterator erase(const_iterator first, const_iterator last)
+      {
+         auto unique_lock_ptr = std::make_shared<std::unique_lock<std::shared_mutex>>(state->mutex);
+         auto it = state->items.erase(first.item_it, last.item_it);
+         return iterator(it, state, nullptr, unique_lock_ptr);
+      }
+
+      void resize(size_type count)
+      {
+         std::unique_lock lock(state->mutex);
+         if (count < state->items.size()) {
+            state->items.resize(count);
+         }
+         else {
+            while (state->items.size() < count) {
+               state->items.emplace_back(std::make_unique<V>());
+            }
+         }
+      }
+
+      void resize(size_type count, const V& value)
+      {
+         std::unique_lock lock(state->mutex);
+         if (count < state->items.size()) {
+            state->items.resize(count);
+         }
+         else {
+            while (state->items.size() < count) {
+               state->items.emplace_back(std::make_unique<V>(value));
+            }
+         }
+      }
+
+      void swap(shared_async_vector& other)
+      {
+         if (state == other.state) return;
+
+         std::unique_lock<std::shared_mutex> lock1(state->mutex, std::defer_lock);
+         std::unique_lock<std::shared_mutex> lock2(other.state->mutex, std::defer_lock);
+         std::lock(lock1, lock2);
+         state->items.swap(other.state->items);
+      }
+
+      // Iterators
+      iterator begin()
+      {
+         auto shared_lock_ptr = std::make_shared<std::shared_lock<std::shared_mutex>>(state->mutex);
+         return iterator(state->items.begin(), state, shared_lock_ptr);
+      }
+
+      const_iterator begin() const
+      {
+         auto shared_lock_ptr = std::make_shared<std::shared_lock<std::shared_mutex>>(state->mutex);
+         return const_iterator(state->items.cbegin(), state, shared_lock_ptr);
+      }
+
+      const_iterator cbegin() const
+      {
+         auto shared_lock_ptr = std::make_shared<std::shared_lock<std::shared_mutex>>(state->mutex);
+         return const_iterator(state->items.cbegin(), state, shared_lock_ptr);
+      }
+
+      iterator end()
+      {
+         auto shared_lock_ptr = std::make_shared<std::shared_lock<std::shared_mutex>>(state->mutex);
+         return iterator(state->items.end(), state, shared_lock_ptr);
+      }
+
+      const_iterator end() const
+      {
+         auto shared_lock_ptr = std::make_shared<std::shared_lock<std::shared_mutex>>(state->mutex);
+         return const_iterator(state->items.cend(), state, shared_lock_ptr);
+      }
+
+      const_iterator cend() const
+      {
+         auto shared_lock_ptr = std::make_shared<std::shared_lock<std::shared_mutex>>(state->mutex);
+         return const_iterator(state->items.cend(), state, shared_lock_ptr);
+      }
+   };
+}
diff --git a/deps/saucer/include/glaze/thread/threadpool.hpp b/deps/saucer/include/glaze/thread/threadpool.hpp
index e4b70e2..dd5e35f 100644
--- a/deps/saucer/include/glaze/thread/threadpool.hpp
+++ b/deps/saucer/include/glaze/thread/threadpool.hpp
@@ -5,9 +5,9 @@
 
 #include <atomic>
 #include <condition_variable>
+#include <deque>
 #include <functional>
 #include <future>
-#include <list>
 #include <mutex>
 #include <thread>
 #include <vector>
@@ -50,7 +50,10 @@ namespace glz
 
                      // Notify that work is finished
                      --working;
-                     done_cv.notify_all();
+                     lock.lock();
+                     if (queue.empty() && (working == 0)) {
+                        done_cv.notify_one();
+                     }
                   }
                }
             });
@@ -152,7 +155,7 @@ namespace glz
       {
          std::unique_lock lock(mtx);
          if (queue.empty() && (working == 0)) return;
-         done_cv.wait(lock, [&] { return queue.empty() && (working == 0); });
+         done_cv.wait(lock);
       }
 
       size_t size() const { return threads.size(); }
@@ -172,7 +175,7 @@ namespace glz
       {
          // Close the queue and finish all the remaining work
          {
-            std::unique_lock lock(mtx);
+            std::lock_guard lock(mtx);
             closed = true;
             work_cv.notify_all();
          }
diff --git a/deps/saucer/include/glaze/thread/value_proxy.hpp b/deps/saucer/include/glaze/thread/value_proxy.hpp
new file mode 100644
index 0000000..af23def
--- /dev/null
+++ b/deps/saucer/include/glaze/thread/value_proxy.hpp
@@ -0,0 +1,22 @@
+// Glaze Library
+// For the license information refer to glaze.hpp
+
+#pragma once
+
+#include "glaze/core/common.hpp"
+
+namespace glz
+{
+   template <class T>
+   concept is_value_proxy = requires { T::glaze_value_proxy; };
+
+   template <uint32_t Format, is_value_proxy T>
+   struct from<Format, T>
+   {
+      template <auto Opts>
+      static void op(auto&& value, is_context auto&& ctx, auto&& it, auto&& end)
+      {
+         parse<JSON>::op<Opts>(value.value(), ctx, it, end);
+      }
+   };
+}
diff --git a/deps/saucer/include/glaze/toml.hpp b/deps/saucer/include/glaze/toml.hpp
new file mode 100644
index 0000000..1e128a7
--- /dev/null
+++ b/deps/saucer/include/glaze/toml.hpp
@@ -0,0 +1,7 @@
+// Glaze Library
+// For the license information refer to glaze.hpp
+
+#pragma once
+
+#include "glaze/toml/read.hpp"
+#include "glaze/toml/write.hpp"
diff --git a/deps/saucer/include/glaze/toml/opts.hpp b/deps/saucer/include/glaze/toml/opts.hpp
new file mode 100644
index 0000000..85b8887
--- /dev/null
+++ b/deps/saucer/include/glaze/toml/opts.hpp
@@ -0,0 +1,31 @@
+#pragma once
+
+#include <glaze/core/opts.hpp>
+
+namespace glz::toml
+{
+
+   enum struct opts_internal : uint32_t {
+      none = 0,
+      internal_struct = 1 << 0, // Currently in an inner struct
+   };
+
+   struct toml_opts
+   {
+      uint32_t format = TOML;
+      bool error_on_unknown_keys{true};
+
+      uint32_t internal{}; // default to 0
+   };
+
+   consteval bool check_is_internal(auto&& o) { return o.internal & uint32_t(opts_internal::internal_struct); }
+
+   template <auto Opts>
+   constexpr auto is_internal_on()
+   {
+      auto ret = Opts;
+      ret.internal |= uint32_t(opts_internal::internal_struct);
+      return ret;
+   }
+
+} // namespace glz::toml
diff --git a/deps/saucer/include/glaze/toml/read.hpp b/deps/saucer/include/glaze/toml/read.hpp
new file mode 100644
index 0000000..c070917
--- /dev/null
+++ b/deps/saucer/include/glaze/toml/read.hpp
@@ -0,0 +1,945 @@
+// Glaze Library
+// For the license information refer to glaze.hpp
+
+#pragma once
+
+#include <cctype>
+#include <charconv>
+#include <iostream>
+
+#include "glaze/core/common.hpp"
+// #include "glaze/core/opts.hpp"
+#include "glaze/core/read.hpp"
+#include "glaze/core/reflect.hpp"
+#include "glaze/file/file_ops.hpp"
+#include "glaze/toml/opts.hpp"
+#include "glaze/util/glaze_fast_float.hpp"
+#include "glaze/util/parse.hpp"
+#include "glaze/util/type_traits.hpp"
+
+namespace glz
+{
+   template <>
+   struct parse<TOML>
+   {
+      template <auto Opts, class T, is_context Ctx, class It0, class It1>
+      GLZ_ALWAYS_INLINE static void op(T&& value, Ctx&& ctx, It0&& it, It1&& end)
+      {
+         from<TOML, std::decay_t<T>>::template op<Opts>(std::forward<T>(value), std::forward<Ctx>(ctx),
+                                                        std::forward<It0>(it), std::forward<It1>(end));
+      }
+   };
+
+   // Skip whitespace and comments
+   template <class It, class End>
+   GLZ_ALWAYS_INLINE void skip_ws_and_comments(It&& it, End&& end) noexcept
+   {
+      while (it != end) {
+         if (*it == ' ' || *it == '\t') {
+            ++it;
+         }
+         else if (*it == '#') {
+            // Skip comment to end of line
+            while (it != end && *it != '\n' && *it != '\r') {
+               ++it;
+            }
+         }
+         else {
+            break;
+         }
+      }
+   }
+
+   // Skip to next line
+   template <class Ctx, class It, class End>
+   GLZ_ALWAYS_INLINE bool skip_to_next_line(Ctx&, It&& it, End&& end) noexcept
+   {
+      while (it != end && *it != '\n' && *it != '\r') {
+         ++it;
+      }
+
+      if (it == end) {
+         return false;
+      }
+
+      if (*it == '\r') {
+         ++it;
+         if (it != end && *it == '\n') {
+            ++it;
+         }
+      }
+      else if (*it == '\n') {
+         ++it;
+      }
+
+      return true;
+   }
+
+   // Parse TOML key (bare key or quoted key)
+   template <class Ctx, class It, class End>
+   GLZ_ALWAYS_INLINE bool parse_toml_key(std::string& key, Ctx& ctx, It&& it, End&& end) noexcept
+   {
+      key.clear();
+      skip_ws_and_comments(it, end);
+
+      if (it == end) {
+         ctx.error = error_code::unexpected_end;
+         return false;
+      }
+
+      if (*it == '"') {
+         // Quoted key
+         ++it;
+         while (it != end && *it != '"') {
+            if (*it == '\\') {
+               ++it;
+               if (it == end) {
+                  ctx.error = error_code::unexpected_end;
+                  return false;
+               }
+               switch (*it) {
+               case '"':
+                  key.push_back('"');
+                  break;
+               case '\\':
+                  key.push_back('\\');
+                  break;
+               case 'n':
+                  key.push_back('\n');
+                  break;
+               case 't':
+                  key.push_back('\t');
+                  break;
+               case 'r':
+                  key.push_back('\r');
+                  break;
+               default:
+                  key.push_back('\\');
+                  key.push_back(*it);
+                  break;
+               }
+            }
+            else {
+               key.push_back(*it);
+            }
+            ++it;
+         }
+
+         if (it == end || *it != '"') {
+            ctx.error = error_code::syntax_error;
+            return false;
+         }
+         ++it; // Skip closing quote
+      }
+      else {
+         // Bare key
+         while (it != end && (std::isalnum(*it) || *it == '_' || *it == '-')) {
+            key.push_back(*it);
+            ++it;
+         }
+
+         if (key.empty()) {
+            ctx.error = error_code::syntax_error;
+            return false;
+         }
+      }
+
+      return true;
+   }
+
+   template <class Ctx, class It, class End>
+   GLZ_ALWAYS_INLINE bool parse_toml_key(std::vector<std::string>& keys, Ctx& ctx, It& it, End end) noexcept
+   {
+      keys.clear();
+      skip_ws_and_comments(it, end);
+
+      if (it == end) {
+         ctx.error = error_code::unexpected_end;
+         return false;
+      }
+
+      while (true) {
+         std::string key;
+
+         if (it == end) {
+            ctx.error = error_code::unexpected_end;
+            return false;
+         }
+
+         if (*it == '"') {
+            ++it;
+            while (it != end && *it != '"') {
+               if (*it == '\\') {
+                  ++it;
+                  if (it == end) {
+                     ctx.error = error_code::unexpected_end;
+                     return false;
+                  }
+                  switch (*it) {
+                  case '"':
+                     key.push_back('"');
+                     break;
+                  case '\\':
+                     key.push_back('\\');
+                     break;
+                  case 'n':
+                     key.push_back('\n');
+                     break;
+                  case 't':
+                     key.push_back('\t');
+                     break;
+                  case 'r':
+                     key.push_back('\r');
+                     break;
+                  default:
+                     key.push_back('\\');
+                     key.push_back(*it);
+                     break;
+                  }
+               }
+               else {
+                  key.push_back(*it);
+               }
+               ++it;
+            }
+
+            if (it == end || *it != '"') {
+               ctx.error = error_code::syntax_error;
+               return false;
+            }
+            ++it; // skip closing quote
+         }
+         else {
+            while (it != end && (std::isalnum(*it) || *it == '_' || *it == '-')) {
+               key.push_back(*it);
+               ++it;
+            }
+
+            if (key.empty()) {
+               ctx.error = error_code::syntax_error;
+               return false;
+            }
+         }
+
+         keys.push_back(std::move(key));
+
+         skip_ws_and_comments(it, end);
+
+         if (it == end || *it != '.') {
+            break;
+         }
+
+         ++it; // skip '.', We know it's '.' because we've checked before
+         skip_ws_and_comments(it, end);
+
+         if (it == end) {
+            ctx.error = error_code::unexpected_end;
+            return false;
+         }
+      }
+
+      return true;
+   }
+
+   template <glaze_value_t T>
+   struct from<TOML, T>
+   {
+      template <auto Opts, is_context Ctx, class It0, class It1>
+      static void op(auto&& value, Ctx&& ctx, It0&& it, It1&& end)
+      {
+         using V = decltype(get_member(std::declval<T>(), meta_wrapper_v<T>));
+         from<TOML, V>::template op<Opts>(get_member(value, meta_wrapper_v<T>), std::forward<Ctx>(ctx),
+                                          std::forward<It0>(it), std::forward<It1>(end));
+      }
+   };
+
+   template <num_t T>
+   struct from<TOML, T>
+   {
+      template <auto Opts, class It>
+      static void op(auto&& value, is_context auto&& ctx, It&& it, auto&& end) noexcept
+      {
+         if (bool(ctx.error)) [[unlikely]] {
+            return;
+         }
+
+         skip_ws_and_comments(it, end);
+
+         if (it == end) [[unlikely]] {
+            ctx.error = error_code::unexpected_end;
+            return;
+         }
+
+         using V = decay_keep_volatile_t<decltype(value)>;
+         if constexpr (int_t<V>) {
+            if constexpr (std::is_unsigned_v<V>) {
+               uint64_t i{};
+               if (*it == '-') [[unlikely]] {
+                  ctx.error = error_code::parse_number_failure;
+                  return;
+               }
+
+               if (not glz::atoi(i, it, end)) [[unlikely]] {
+                  ctx.error = error_code::parse_number_failure;
+                  return;
+               }
+
+               if (i > (std::numeric_limits<V>::max)()) [[unlikely]] {
+                  ctx.error = error_code::parse_number_failure;
+                  return;
+               }
+               value = static_cast<V>(i);
+            }
+            else {
+               uint64_t i{};
+               int sign = 1;
+               if (*it == '-') {
+                  sign = -1;
+                  ++it;
+                  if (it == end) [[unlikely]] {
+                     ctx.error = error_code::unexpected_end;
+                     return;
+                  }
+               }
+               if (not glz::atoi(i, it, end)) [[unlikely]] {
+                  ctx.error = error_code::parse_number_failure;
+                  return;
+               }
+
+               if (i > (std::numeric_limits<V>::max)()) [[unlikely]] {
+                  ctx.error = error_code::parse_number_failure;
+                  return;
+               }
+               value = sign * static_cast<V>(i);
+            }
+         }
+         else {
+            auto [ptr, ec] = glz::from_chars<false>(it, end, value); // Always treat as non-null-terminated
+            if (ec != std::errc()) [[unlikely]] {
+               ctx.error = error_code::parse_number_failure;
+               return;
+            }
+            it = ptr;
+         }
+      }
+   };
+
+   template <string_t T>
+   struct from<TOML, T>
+   {
+      template <auto Opts, class It>
+      static void op(auto&& value, is_context auto&& ctx, It&& it, auto&& end)
+      {
+         if (bool(ctx.error)) [[unlikely]] {
+            return;
+         }
+
+         value.clear();
+         skip_ws_and_comments(it, end);
+
+         if (it == end) {
+            ctx.error = error_code::unexpected_end;
+            return;
+         }
+
+         if (it + 2 < end && *it == '"' && *(it + 1) == '"' && *(it + 2) == '"') {
+            // Basic Multiline String
+            it += 3; // Skip """
+            if (it != end && *it == '\n') { // Skip initial newline
+               ++it;
+            }
+            else if (it + 1 < end && *it == '\r' && *(it + 1) == '\n') { // Skip initial CRLF
+               it += 2;
+            }
+
+            while (it + 2 < end && !(*it == '"' && *(it + 1) == '"' && *(it + 2) == '"')) {
+               if (*it == '\\') {
+                  ++it;
+                  if (it == end) {
+                     ctx.error = error_code::unexpected_end;
+                     return;
+                  }
+                  switch (*it) {
+                  case '"':
+                     value.push_back('"');
+                     break;
+                  case '\\':
+                     value.push_back('\\');
+                     break;
+                  case 'n':
+                     value.push_back('\n');
+                     break;
+                  case 't':
+                     value.push_back('\t');
+                     break;
+                  case 'r':
+                     value.push_back('\r');
+                     break;
+                  case 'b':
+                     value.push_back('\b');
+                     break;
+                  case 'f':
+                     value.push_back('\f');
+                     break;
+                  // TOML: Any other character is an error for escape sequences in basic strings
+                  // However, we also need to handle escaped newlines for line trimming
+                  case '\n': /* ignore escaped newline */
+                     // Trim all whitespace after escaped newline until non-whitespace or actual newline
+                     while (it + 1 < end &&
+                            (*(it + 1) == ' ' || *(it + 1) == '\t' || *(it + 1) == '\r' || *(it + 1) == '\n')) {
+                        ++it;
+                        if (*it == '\n') break; // Stop if we hit an actual newline
+                     }
+                     break;
+                  case '\r': // part of CRLF, handle similar to \n
+                     if (it + 1 < end && *(it + 1) == '\n') ++it;
+                     while (it + 1 < end &&
+                            (*(it + 1) == ' ' || *(it + 1) == '\t' || *(it + 1) == '\r' || *(it + 1) == '\n')) {
+                        ++it;
+                        if (*it == '\n') break;
+                     }
+                     break;
+                  default:
+                     // In TOML, an unknown escape sequence is an error.
+                     // For simplicity here, we might just append them or flag an error.
+                     // Glaze JSON parser often appends, let's be stricter for TOML.
+                     ctx.error = error_code::syntax_error;
+                     return;
+                  }
+               }
+               else {
+                  value.push_back(*it);
+               }
+               ++it;
+            }
+
+            if (it + 2 >= end || !(*it == '"' && *(it + 1) == '"' && *(it + 2) == '"')) {
+               ctx.error = error_code::syntax_error; // Unterminated multiline string
+               return;
+            }
+            it += 3; // Skip closing """
+         }
+         else if (*it == '"') {
+            // Basic string
+            ++it; // Skip opening quote
+
+            while (it != end && *it != '"') {
+               if (*it == '\\') {
+                  ++it;
+                  if (it == end) {
+                     ctx.error = error_code::unexpected_end;
+                     return;
+                  }
+                  switch (*it) {
+                  case '"':
+                     value.push_back('"');
+                     break;
+                  case '\\':
+                     value.push_back('\\');
+                     break;
+                  case 'n':
+                     value.push_back('\n');
+                     break;
+                  case 't':
+                     value.push_back('\t');
+                     break;
+                  case 'r':
+                     value.push_back('\r');
+                     break;
+                  case 'b':
+                     value.push_back('\b');
+                     break;
+                  case 'f':
+                     value.push_back('\f');
+                     break;
+                  default:
+                     ctx.error = error_code::syntax_error;
+                     return;
+                  }
+               }
+               else if (*it == '\n' || *it == '\r') { // Newlines not allowed in single-line basic strings
+                  ctx.error = error_code::syntax_error;
+                  return;
+               }
+               else {
+                  value.push_back(*it);
+               }
+               ++it;
+            }
+
+            if (it == end || *it != '"') {
+               ctx.error = error_code::syntax_error;
+               return;
+            }
+            ++it; // Skip closing quote
+         }
+         else if (it + 2 < end && *it == '\'' && *(it + 1) == '\'' && *(it + 2) == '\'') {
+            // Literal Multiline String
+            it += 3; // Skip '''
+            if (it != end && *it == '\n') { // Skip initial newline
+               ++it;
+            }
+            else if (it + 1 < end && *it == '\r' && *(it + 1) == '\n') { // Skip initial CRLF
+               it += 2;
+            }
+
+            while (it + 2 < end && !(*it == '\'' && *(it + 1) == '\'' && *(it + 2) == '\'')) {
+               value.push_back(*it);
+               ++it;
+            }
+
+            if (it + 2 >= end || !(*it == '\'' && *(it + 1) == '\'' && *(it + 2) == '\'')) {
+               ctx.error = error_code::syntax_error; // Unterminated multiline literal string
+               return;
+            }
+            it += 3; // Skip closing '''
+         }
+         else if (*it == '\'') {
+            // Literal string
+            ++it; // Skip opening quote
+
+            while (it != end && *it != '\'') {
+               if (*it == '\n' || *it == '\r') { // Newlines not allowed in single-line literal strings
+                  ctx.error = error_code::syntax_error;
+                  return;
+               }
+               value.push_back(*it);
+               ++it;
+            }
+
+            if (it == end || *it != '\'') {
+               ctx.error = error_code::syntax_error;
+               return;
+            }
+            ++it; // Skip closing quote
+         }
+         else {
+            // Bare string (not typical in TOML values, but handle it if necessary for some edge cases)
+            // TOML spec does not allow bare strings for values. This path should ideally not be hit for valid TOML.
+            // If it is, it's likely an error or a deviation.
+            // For now, let's assume this is an error according to strict TOML.
+            ctx.error = error_code::syntax_error;
+            return;
+            /*
+            while (it != end && *it != '\n' && *it != '\r' && *it != '#') {
+               value.push_back(*it);
+               ++it;
+            }
+
+            // Trim trailing whitespace
+            while (!value.empty() && (value.back() == ' ' || value.back() == '\t')) {
+               value.pop_back();
+            }
+            */
+         }
+      }
+   };
+
+   template <bool_t T>
+   struct from<TOML, T>
+   {
+      template <auto Opts, class It>
+      static void op(auto&& value, is_context auto&& ctx, It&& it, auto&& end) noexcept
+      {
+         if (bool(ctx.error)) [[unlikely]] {
+            return;
+         }
+
+         skip_ws_and_comments(it, end);
+
+         if (it == end) [[unlikely]] {
+            ctx.error = error_code::unexpected_end;
+            return;
+         }
+
+         if (it + 4 <= end &&
+             std::string_view(it, 4) == "true") { // TODO: Maybe we can use the bool_true from header.hpp
+            value = true;
+            it += 4;
+         }
+         else if (it + 5 <= end &&
+                  std::string_view(it, 5) == "false") { // TODO: Maybe we can use the bool_false from header.hpp
+            value = false;
+            it += 5;
+         }
+         else {
+            ctx.error = error_code::expected_true_or_false;
+            return;
+         }
+      }
+   };
+
+   template <readable_array_t T>
+   struct from<TOML, T>
+   {
+      template <auto Opts, class It>
+      static void op(auto&& value, is_context auto&& ctx, It&& it, auto&& end)
+      {
+         if (bool(ctx.error)) [[unlikely]] {
+            return;
+         }
+
+         skip_ws_and_comments(it, end);
+
+         if (it == end || *it != '[') {
+            ctx.error = error_code::syntax_error;
+            return;
+         }
+
+         ++it; // Skip '['
+         skip_ws_and_comments(it, end);
+
+         // Handle empty array
+         if (it != end && *it == ']') {
+            ++it;
+            return;
+         }
+
+         size_t index = 0;
+         while (it != end) {
+            using value_type = typename std::decay_t<T>::value_type;
+
+            if constexpr (emplace_backable<T>) {
+               auto& element = value.emplace_back();
+               from<TOML, value_type>::template op<Opts>(element, ctx, it, end);
+            }
+            else {
+               // For fixed-size arrays like std::array
+               if (index >= value.size()) {
+                  ctx.error = error_code::exceeded_static_array_size;
+                  return;
+               }
+               from<TOML, value_type>::template op<Opts>(value[index], ctx, it, end);
+               ++index;
+            }
+
+            if (bool(ctx.error)) {
+               return;
+            }
+
+            skip_ws_and_comments(it, end);
+
+            if (it == end) {
+               ctx.error = error_code::unexpected_end;
+               return;
+            }
+
+            if (*it == ']') {
+               ++it;
+               break;
+            }
+            else if (*it == ',') {
+               ++it;
+               skip_ws_and_comments(it, end);
+            }
+            else {
+               ctx.error = error_code::syntax_error;
+               return;
+            }
+         }
+      }
+   };
+
+   namespace detail
+   {
+      template <auto Opts, class T, class It, class End, class Ctx>
+      GLZ_ALWAYS_INLINE void parse_toml_object_members(T&& value, It&& it, End&& end, Ctx&& ctx, bool is_inline_table)
+      {
+         static constexpr auto N = reflect<std::decay_t<T>>::size;
+         static constexpr auto HashInfo = hash_info<std::decay_t<T>>;
+         // TODO: Think if we should make inline table a constexpr to reduce runtime checks
+         // TODO: Think if it's feasible to write a function to find out the deepest nested structure
+         // and use it instead of vector
+
+         while (it != end) {
+            skip_ws_and_comments(it, end);
+
+            if (it == end) {
+               if (is_inline_table) ctx.error = error_code::unexpected_end; // Inline table must end with '}'
+               break;
+            }
+
+            if (is_inline_table && *it == '}') {
+               ++it; // Consume '}'
+               return; // End of inline table
+            }
+
+            // Skip empty lines (only if not in an inline table, inline tables don't have newlines)
+            if (!is_inline_table && (*it == '\n' || *it == '\r')) {
+               skip_to_next_line(ctx, it, end);
+               continue;
+            }
+
+            std::string key_str;
+            // std::vector<std::string> key_str; // TODO: std::string is used temporarily, we may swap it to view later
+            // on or as said before completely switch to array
+
+            // Handle section headers [section] (only if not in an inline table)
+            if (!is_inline_table && *it == '[') {
+               // For now, skip section headers - we'll implement nested object support later
+               // Or, this could be where we handle table arrays or nested tables.
+               // For the current task, we are focusing on inline tables.
+               // This part might need to be more sophisticated for full TOML table support.
+               skip_to_next_line(ctx, it, end);
+               continue;
+            }
+
+            if (!parse_toml_key(key_str, ctx, it, end)) {
+               return;
+            }
+
+            skip_ws_and_comments(it, end);
+
+            if (it == end || *it != '=') {
+               ctx.error = error_code::syntax_error;
+               return;
+            }
+
+            ++it; // Skip '='
+            skip_ws_and_comments(it, end);
+
+            if (it == end) {
+               ctx.error = error_code::unexpected_end; // Value expected
+               return;
+            }
+
+            const auto index = decode_hash_with_size<TOML, std::decay_t<T>, HashInfo, HashInfo.type>::op(
+               key_str.data(), key_str.data() + key_str.size(), key_str.size());
+
+            if (index < N) [[likely]] {
+               visit<N>(
+                  [&]<size_t I>() {
+                     if (I == index) {
+                        decltype(auto) member_obj = [&]() -> decltype(auto) {
+                           if constexpr (reflectable<std::decay_t<T>>) {
+                              // For reflectable types, to_tie provides access to members
+                              return get<I>(to_tie(value));
+                           }
+                           else {
+                              // For glaze_object_t, reflect<T>::values gives member metadata
+                              // and get_member accesses the actual member value
+                              return get_member(value, get<I>(reflect<std::decay_t<T>>::values));
+                           }
+                        }();
+
+                        // member_obj is now a reference to the actual member or its wrapper
+                        using member_type = std::decay_t<decltype(member_obj)>;
+                        from<TOML, member_type>::template op<Opts>(member_obj, ctx, it, end);
+                     }
+                  },
+                  index);
+
+               if (bool(ctx.error)) [[unlikely]] {
+                  return;
+               }
+            }
+            else {
+               // Unknown key
+               // TODO: Add option to error on unknown keys or ignore them
+               // For now, skip the value associated with the unknown key.
+               // This requires parsing the value to know where it ends.
+               // A simpler skip to next line might not work for inline tables or complex values.
+               // For now, let's try a simple skip to comma or end of line/table.
+               while (it != end) {
+                  if (is_inline_table && (*it == ',' || *it == '}')) break;
+                  if (!is_inline_table && (*it == '\n' || *it == '\r')) break;
+                  ++it;
+               }
+            }
+
+            skip_ws_and_comments(it, end);
+            if (it == end) {
+               if (is_inline_table) ctx.error = error_code::unexpected_end; // Inline table must end with '}'
+               break;
+            }
+
+            if (is_inline_table) {
+               if (*it == '}') {
+                  // Handled at the start of the loop
+                  continue;
+               }
+               else if (*it == ',') {
+                  ++it; // Consume comma
+                  skip_ws_and_comments(it, end);
+                  if (it != end && *it == '}') { // Trailing comma case like { key = "val", }
+                     // This is allowed by TOML v1.0.0 for inline tables
+                     // The '}' will be consumed at the start of the next iteration.
+                  }
+               }
+               else {
+                  ctx.error = error_code::syntax_error; // Expected comma or '}'
+                  return;
+               }
+            }
+            else {
+               // For top-level or standard tables, expect newline or EOF
+               if (it != end && (*it == '\n' || *it == '\r')) {
+                  skip_to_next_line(ctx, it, end);
+               }
+               else if (it != end && *it != '#') { // If not a comment, it's an error unless it's EOF
+                  // Could be an issue if there's no newline before EOF for the last key-value
+               }
+            }
+         }
+      }
+   }
+
+   template <auto Opts, class T>
+   GLZ_ALWAYS_INLINE bool resolve_nested(T& root, std::span<std::string> path, auto& ctx, auto& it, auto& end)
+   {
+      if constexpr (!(glz::reflectable<T> || glz::glaze_object_t<T>)) {
+         return true;
+      }
+      else {
+         static constexpr auto N = reflect<std::decay_t<T>>::size;
+         static constexpr auto HashInfo = hash_info<std::decay_t<T>>;
+         const auto index = decode_hash_with_size<TOML, std::decay_t<T>, HashInfo, HashInfo.type>::op(
+            path.front().data(), path.front().data() + path.front().size(), path.front().size());
+         if (index < N) [[likely]] {
+            visit<N>(
+               [&]<size_t I>() {
+                  if (I == index) {
+                     decltype(auto) member_obj = [&]() -> decltype(auto) {
+                        if constexpr (reflectable<std::decay_t<T>>) {
+                           return get<I>(to_tie(root));
+                        }
+                        else {
+                           return get_member(root, get<I>(reflect<std::decay_t<T>>::values));
+                        }
+                     }();
+
+                     if (!(path.size() - 1)) {
+                        using member_type = std::decay_t<decltype(member_obj)>;
+                        from<TOML, member_type>::template op<toml::is_internal_on<Opts>()>(member_obj, ctx, it, end);
+                     }
+                     else {
+                        return resolve_nested<Opts>(member_obj, path.subspan(1), ctx, it, end);
+                     }
+                  }
+                  return !bool(ctx.error);
+               },
+               index);
+         }
+         return !bool(ctx.error);
+      }
+   }
+
+   template <class T>
+      requires((glaze_object_t<T> || reflectable<T>) && not custom_read<T>)
+   struct from<TOML, T>
+   {
+      template <auto Opts, class It>
+      static void op(auto&& value, is_context auto&& ctx, It&& it, auto&& end)
+      {
+         while (it != end) {
+            // TODO: Introduce OPTS here
+            skip_ws_and_comments(it, end);
+            if (it == end) { // Empty input for an object is valid (empty object)
+               return;
+            }
+            if (*it == '\n' || *it == '\r') {
+               skip_to_next_line(ctx, it, end);
+               continue;
+            }
+
+            // TODO: We probably should reorder that so that we dont check against less used inline table more often
+            if (*it == '{') { // Check if it's an inline table
+               ++it; // Consume '{'
+               skip_ws_and_comments(it, end);
+               if (it != end && *it == '}') { // Empty inline table {}
+                  ++it;
+                  return;
+               }
+               // TODO: Rewrite logic here, for now it works just fine so we leave it.
+               detail::parse_toml_object_members<Opts>(value, it, end, ctx, true); // true for is_inline_table
+               // The parse_toml_object_members should consume the final '}' if successful
+            }
+            else if (*it == '[') { // Normal table
+               std::vector<std::string> path;
+
+               if constexpr (toml::check_is_internal(Opts)) {
+                  return; // is it's internal we return to root.
+               }
+               else {
+                  ++it;
+                  if (*it == '[') { // Array of tables
+
+                     ++it; // skip the second bracket
+                     ctx.error = error_code::feature_not_supported;
+                     return;
+                     // TODO: the logic should ideally branch here, because arrays should ignore multiple defenition
+                     // errors And should also use push back version but for now we just error out, will support
+                     // later
+                  }
+                  skip_ws_and_comments(it, end);
+
+                  if (!parse_toml_key(path, ctx, it, end)) {
+                     return;
+                  }
+                  if (it == end || *it != ']') {
+                     ctx.error = error_code::syntax_error;
+                     return;
+                  }
+                  it++; // skip ']'
+                  if (!resolve_nested<Opts>(value, std::span{path}, ctx, it, end)) {
+                     return;
+                  }
+               }
+            }
+            else {
+               std::vector<std::string> path;
+               skip_ws_and_comments(it, end);
+
+               if (!parse_toml_key(path, ctx, it, end)) {
+                  return;
+               }
+
+               if (it == end || *it != '=') {
+                  ctx.error = error_code::syntax_error;
+                  return;
+               }
+
+               ++it; // Skip '='
+               skip_ws_and_comments(it, end);
+
+               if (it == end) {
+                  ctx.error = error_code::unexpected_end; // Value expected
+                  return;
+               }
+               if (!resolve_nested<Opts>(value, std::span{path}, ctx, it, end)) {
+                  return;
+               }
+            }
+         }
+      }
+   };
+
+   template <read_supported<TOML> T, class Buffer>
+   [[nodiscard]] inline auto read_toml(T&& value, Buffer&& buffer)
+   {
+      return read<opts{.format = TOML}>(value, std::forward<Buffer>(buffer));
+   }
+
+   template <read_supported<TOML> T, class Buffer>
+   [[nodiscard]] inline auto read_toml(Buffer&& buffer)
+   {
+      T value{};
+      read<opts{.format = TOML}>(value, std::forward<Buffer>(buffer));
+      return value;
+   }
+
+   template <read_supported<TOML> T, is_buffer Buffer>
+   [[nodiscard]] inline error_ctx read_file_toml(T& value, const sv file_name, Buffer&& buffer)
+   {
+      context ctx{};
+      ctx.current_file = file_name;
+
+      const auto ec = file_to_buffer(buffer, ctx.current_file);
+
+      if (bool(ec)) {
+         return {ec};
+      }
+
+      return read<opts{.format = TOML}>(value, buffer, ctx);
+   }
+}
diff --git a/deps/saucer/include/glaze/toml/write.hpp b/deps/saucer/include/glaze/toml/write.hpp
new file mode 100644
index 0000000..92fa2fc
--- /dev/null
+++ b/deps/saucer/include/glaze/toml/write.hpp
@@ -0,0 +1,581 @@
+// Glaze Library
+// For the license information refer to glaze.hpp
+
+#pragma once
+
+#include "glaze/core/opts.hpp"
+#include "glaze/core/reflect.hpp"
+#include "glaze/core/to.hpp"
+#include "glaze/core/wrappers.hpp"
+#include "glaze/core/write.hpp"
+#include "glaze/core/write_chars.hpp"
+#include "glaze/util/dump.hpp"
+#include "glaze/util/for_each.hpp"
+#include "glaze/util/itoa.hpp"
+#include "glaze/util/parse.hpp"
+
+namespace glz
+{
+   template <>
+   struct serialize<TOML>
+   {
+      template <auto Opts, class T, is_context Ctx, class B, class IX>
+      GLZ_ALWAYS_INLINE static void op(T&& value, Ctx&& ctx, B&& b, IX&& ix)
+      {
+         to<TOML, std::remove_cvref_t<T>>::template op<Opts>(std::forward<T>(value), std::forward<Ctx>(ctx),
+                                                             std::forward<B>(b), std::forward<IX>(ix));
+      }
+   };
+
+   template <class T>
+      requires(glaze_value_t<T> && !custom_write<T>)
+   struct to<TOML, T>
+   {
+      template <auto Opts, class Value, is_context Ctx, class B, class IX>
+      GLZ_ALWAYS_INLINE static void op(Value&& value, Ctx&& ctx, B&& b, IX&& ix)
+      {
+         using V = std::remove_cvref_t<decltype(get_member(std::declval<Value>(), meta_wrapper_v<T>))>;
+         to<TOML, V>::template op<Opts>(get_member(std::forward<Value>(value), meta_wrapper_v<T>),
+                                        std::forward<Ctx>(ctx), std::forward<B>(b), std::forward<IX>(ix));
+      }
+   };
+
+   template <nullable_like T>
+   struct to<TOML, T>
+   {
+      template <auto Opts>
+      GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, auto&& b, auto&& ix)
+      {
+         if (value) {
+            serialize<TOML>::op<Opts>(*value, ctx, b, ix);
+         }
+      }
+   };
+
+   template <boolean_like T>
+   struct to<TOML, T>
+   {
+      template <auto Opts, class B>
+      GLZ_ALWAYS_INLINE static void op(const bool value, is_context auto&&, B&& b, auto&& ix)
+      {
+         static constexpr auto checked = not check_write_unchecked(Opts);
+         if constexpr (checked && vector_like<B>) {
+            if (const auto n = ix + 8; n > b.size()) [[unlikely]] {
+               b.resize(2 * n);
+            }
+         }
+
+         if constexpr (Opts.bools_as_numbers) {
+            if (value) {
+               std::memcpy(&b[ix], "1", 1);
+            }
+            else {
+               std::memcpy(&b[ix], "0", 1);
+            }
+            ++ix;
+         }
+         else {
+            if (value) {
+               std::memcpy(&b[ix], "true", 4);
+               ix += 4;
+            }
+            else {
+               std::memcpy(&b[ix], "false", 5);
+               ix += 5;
+            }
+         }
+      }
+   };
+
+   template <num_t T>
+   struct to<TOML, T>
+   {
+      template <auto Opts, class B>
+      GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, B&& b, auto&& ix)
+      {
+         if constexpr (Opts.quoted_num) {
+            std::memcpy(&b[ix], "\"", 1);
+            ++ix;
+            write_chars::op<Opts>(value, ctx, b, ix);
+            std::memcpy(&b[ix], "\"", 1);
+            ++ix;
+         }
+         else {
+            write_chars::op<Opts>(value, ctx, b, ix);
+         }
+      }
+   };
+
+   constexpr std::array<uint16_t, 256> char_escape_table = [] {
+      auto combine = [](const char chars[2]) -> uint16_t { return uint16_t(chars[0]) | (uint16_t(chars[1]) << 8); };
+
+      std::array<uint16_t, 256> t{};
+      t['\b'] = combine(R"(\b)");
+      t['\t'] = combine(R"(\t)");
+      t['\n'] = combine(R"(\n)");
+      t['\f'] = combine(R"(\f)");
+      t['\r'] = combine(R"(\r)");
+      t['\"'] = combine(R"(\")");
+      t['\\'] = combine(R"(\\)");
+      return t;
+   }();
+
+   template <class T>
+      requires str_t<T> || char_t<T>
+   struct to<TOML, T>
+   {
+      template <auto Opts, class B>
+      static void op(auto&& value, is_context auto&&, B&& b, auto&& ix)
+      {
+         if constexpr (Opts.number) {
+            dump_maybe_empty(value, b, ix);
+         }
+         else if constexpr (char_t<T>) {
+            if constexpr (Opts.raw) {
+               dump(value, b, ix);
+            }
+            else {
+               if constexpr (resizable<B>) {
+                  const auto k = ix + 8;
+                  if (k > b.size()) [[unlikely]] {
+                     b.resize(2 * k);
+                  }
+               }
+
+               std::memcpy(&b[ix], "\"", 1);
+               ++ix;
+               if (const auto escaped = char_escape_table[uint8_t(value)]; escaped) {
+                  std::memcpy(&b[ix], &escaped, 2);
+                  ix += 2;
+               }
+               else if (value == '\0') {
+                  // null character treated as empty string
+               }
+               else {
+                  std::memcpy(&b[ix], &value, 1);
+                  ++ix;
+               }
+               std::memcpy(&b[ix], "\"", 1);
+               ++ix;
+            }
+         }
+         else {
+            if constexpr (Opts.raw_string) {
+               const sv str = [&]() -> const sv {
+                  if constexpr (!char_array_t<T> && std::is_pointer_v<std::decay_t<T>>) {
+                     return value ? value : "";
+                  }
+                  else {
+                     return value;
+                  }
+               }();
+
+               if constexpr (resizable<B>) {
+                  const auto n = str.size();
+                  const auto k = ix + 8 + n;
+                  if (k > b.size()) [[unlikely]] {
+                     b.resize(2 * k);
+                  }
+               }
+
+               std::memcpy(&b[ix], "\"", 1);
+               ++ix;
+               if (str.size()) [[likely]] {
+                  const auto n = str.size();
+                  std::memcpy(&b[ix], str.data(), n);
+                  ix += n;
+               }
+               std::memcpy(&b[ix], "\"", 1);
+               ++ix;
+            }
+            else {
+               const sv str = [&]() -> const sv {
+                  if constexpr (!char_array_t<T> && std::is_pointer_v<std::decay_t<T>>) {
+                     return value ? value : "";
+                  }
+                  else if constexpr (array_char_t<T>) {
+                     return *value.data() ? sv{value.data()} : "";
+                  }
+                  else {
+                     return value;
+                  }
+               }();
+               const auto n = str.size();
+               if constexpr (resizable<B>) {
+                  const auto k = ix + 10 + 2 * n;
+                  if (k > b.size()) [[unlikely]] {
+                     b.resize(2 * k);
+                  }
+               }
+
+               if constexpr (Opts.raw) {
+                  const auto n = str.size();
+                  if (n) {
+                     std::memcpy(&b[ix], str.data(), n);
+                     ix += n;
+                  }
+               }
+               else {
+                  std::memcpy(&b[ix], "\"", 1);
+                  ++ix;
+                  const auto* c = str.data();
+                  const auto* const e = c + n;
+                  const auto start = &b[ix];
+                  auto data = start;
+
+                  if (n > 7) {
+                     for (const auto end_m7 = e - 7; c < end_m7;) {
+                        std::memcpy(data, c, 8);
+                        uint64_t swar;
+                        std::memcpy(&swar, c, 8);
+
+                        constexpr uint64_t lo7_mask = repeat_byte8(0b01111111);
+                        const uint64_t lo7 = swar & lo7_mask;
+                        const uint64_t quote = (lo7 ^ repeat_byte8('"')) + lo7_mask;
+                        const uint64_t backslash = (lo7 ^ repeat_byte8('\\')) + lo7_mask;
+                        const uint64_t less_32 = (swar & repeat_byte8(0b01100000)) + lo7_mask;
+                        uint64_t next = ~((quote & backslash & less_32) | swar);
+
+                        next &= repeat_byte8(0b10000000);
+                        if (next == 0) {
+                           data += 8;
+                           c += 8;
+                           continue;
+                        }
+
+                        const auto length = (countr_zero(next) >> 3);
+                        c += length;
+                        data += length;
+
+                        std::memcpy(data, &char_escape_table[uint8_t(*c)], 2);
+                        data += 2;
+                        ++c;
+                     }
+                  }
+
+                  for (; c < e; ++c) {
+                     if (const auto escaped = char_escape_table[uint8_t(*c)]; escaped) {
+                        std::memcpy(data, &escaped, 2);
+                        data += 2;
+                     }
+                     else {
+                        std::memcpy(data, c, 1);
+                        ++data;
+                     }
+                  }
+
+                  ix += size_t(data - start);
+
+                  std::memcpy(&b[ix], "\"", 1);
+                  ++ix;
+               }
+            }
+         }
+      }
+   };
+
+   template <auto Opts, bool minified_check = true, class B>
+      requires(Opts.format == TOML)
+   GLZ_ALWAYS_INLINE void write_array_entry_separator(is_context auto&&, B&& b, auto&& ix)
+   {
+      if constexpr (vector_like<B>) {
+         if constexpr (minified_check) {
+            if (ix >= b.size()) [[unlikely]] {
+               b.resize(2 * ix);
+            }
+         }
+      }
+      std::memcpy(&b[ix], ", ", 2);
+      ix += 2;
+   }
+
+   template <auto Opts, bool minified_check = true, class B>
+      requires(Opts.format == TOML)
+   GLZ_ALWAYS_INLINE void write_object_entry_separator(is_context auto&&, B&& b, auto&& ix)
+   {
+      std::memcpy(&b[ix], "\n", 1);
+      ++ix;
+   }
+
+   template <class T>
+      requires(glaze_object_t<T> || reflectable<T>)
+   struct to<TOML, T>
+   {
+      template <auto Options, class V, class B>
+         requires(not std::is_pointer_v<std::remove_cvref_t<V>>)
+      static void op(V&& value, is_context auto&& ctx, B&& b, auto&& ix)
+      {
+         // Do not write opening/closing braces.
+         static constexpr auto N = reflect<T>::size;
+         decltype(auto) t = [&]() -> decltype(auto) {
+            if constexpr (reflectable<T>) {
+               return to_tie(value);
+            }
+            else {
+               return nullptr;
+            }
+         }();
+
+         static constexpr auto padding = round_up_to_nearest_16(maximum_key_size<T> + write_padding_bytes);
+         bool first = true;
+
+         for_each<N>([&]<size_t I>() {
+            using val_t = field_t<T, I>;
+
+            if constexpr (always_skipped<val_t>)
+               return;
+            else {
+               if constexpr (null_t<val_t>) {
+                  if constexpr (always_null_t<val_t>)
+                     return;
+                  else {
+                     const auto is_null = [&]() {
+                        decltype(auto) element = [&]() -> decltype(auto) {
+                           if constexpr (reflectable<T>) {
+                              return get<I>(t);
+                           }
+                           else {
+                              return get<I>(reflect<T>::values);
+                           }
+                        };
+
+                        if constexpr (nullable_wrapper<val_t>)
+                           return !bool(element()(value).val);
+                        else if constexpr (nullable_value_t<val_t>)
+                           return !get_member(value, element()).has_value();
+                        else
+                           return !bool(get_member(value, element()));
+                     }();
+                     if (is_null) return;
+                  }
+               }
+
+               maybe_pad<padding>(b, ix);
+
+               // --- Check if this field is a nested object ---
+               if constexpr (glaze_object_t<val_t> || reflectable<val_t>) {
+                  // Print the table header (e.g. "[inner]") for the nested object.
+                  if (!first) {
+                     std::memcpy(&b[ix], "\n", 1);
+                     ++ix;
+                  }
+                  else {
+                     first = false;
+                  }
+                  static constexpr auto key = glz::get<I>(reflect<T>::keys);
+                  std::memcpy(&b[ix], "[", 1);
+                  ++ix;
+                  std::memcpy(&b[ix], key.data(), key.size());
+                  ix += key.size();
+                  std::memcpy(&b[ix], "]\n", 2);
+                  ix += 2;
+
+                  // Serialize the nested object.
+                  if constexpr (reflectable<T>) {
+                     to<TOML, val_t>::template op<Options>(get_member(value, get<I>(t)), ctx, b, ix);
+                  }
+                  else {
+                     to<TOML, val_t>::template op<Options>(get_member(value, get<I>(reflect<T>::values)), ctx, b, ix);
+                  }
+                  // Add an extra newline to separate this table section from following keys.
+                  std::memcpy(&b[ix], "\n", 1);
+                  ++ix;
+               }
+               else {
+                  // --- Field is not an object, so output a key/value pair ---
+                  if (!first) {
+                     std::memcpy(&b[ix], "\n", 1);
+                     ++ix;
+                  }
+                  else {
+                     first = false;
+                  }
+                  static constexpr auto key = glz::get<I>(reflect<T>::keys);
+                  std::memcpy(&b[ix], key.data(), key.size());
+                  ix += key.size();
+
+                  std::memcpy(&b[ix], " = ", 3);
+                  ix += 3;
+
+                  if constexpr (reflectable<T>) {
+                     to<TOML, val_t>::template op<Options>(get_member(value, get<I>(t)), ctx, b, ix);
+                  }
+                  else {
+                     to<TOML, val_t>::template op<Options>(get_member(value, get<I>(reflect<T>::values)), ctx, b, ix);
+                  }
+               }
+            }
+         });
+      }
+   };
+
+   template <class T>
+      requires(writable_array_t<T> || writable_map_t<T>)
+   struct to<TOML, T>
+   {
+      static constexpr bool map_like_array = writable_array_t<T> && pair_t<range_value_t<T>>;
+
+      // --- Array-like container writer ---
+      template <auto Opts, class B>
+         requires(writable_array_t<T> && (map_like_array ? check_concatenate(Opts) == false : true))
+      GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, B&& b, auto&& ix)
+      {
+         if (empty_range(value)) {
+            dump<"[]">(b, ix);
+         }
+         else {
+            if constexpr (has_size<T>) {
+               const auto n = value.size();
+               if constexpr (vector_like<B>) {
+                  // Use 2 bytes per separator (", ")
+                  static constexpr auto comma_padding = 2;
+                  if (const auto k = ix + n * comma_padding + write_padding_bytes; k > b.size()) [[unlikely]] {
+                     b.resize(2 * k);
+                  }
+               }
+               std::memcpy(&b[ix], "[", 1);
+               ++ix;
+               auto it = std::begin(value);
+               using val_t = std::remove_cvref_t<decltype(*it)>;
+               to<TOML, val_t>::template op<Opts>(*it, ctx, b, ix);
+               ++it;
+               for (const auto fin = std::end(value); it != fin; ++it) {
+                  write_array_entry_separator<Opts>(ctx, b, ix);
+                  to<TOML, val_t>::template op<Opts>(*it, ctx, b, ix);
+               }
+               std::memcpy(&b[ix], "]", 1);
+               ++ix;
+            }
+            else {
+               if constexpr (vector_like<B>) {
+                  if (const auto k = ix + write_padding_bytes; k > b.size()) [[unlikely]] {
+                     b.resize(2 * k);
+                  }
+               }
+               std::memcpy(&b[ix], "[", 1);
+               ++ix;
+               auto it = std::begin(value);
+               using val_t = std::remove_cvref_t<decltype(*it)>;
+               to<TOML, val_t>::template op<Opts>(*it, ctx, b, ix);
+               ++it;
+               for (const auto fin = std::end(value); it != fin; ++it) {
+                  write_array_entry_separator<Opts>(ctx, b, ix);
+                  to<TOML, val_t>::template op<Opts>(*it, ctx, b, ix);
+               }
+               dump<']'>(b, ix);
+            }
+         }
+      }
+
+      // --- Map-like container writer ---
+      template <auto Opts, class B>
+         requires(writable_map_t<T> || (map_like_array && check_concatenate(Opts) == true))
+      static void op(auto&& value, is_context auto&& ctx, B&& b, auto&& ix)
+      {
+         bool first = true;
+         for (auto&& [key, val] : value) {
+            if (!first) {
+               write_object_entry_separator<Opts>(ctx, b, ix);
+            }
+            else {
+               first = false;
+            }
+            // Write the key as a bare key
+            std::memcpy(&b[ix], key.data(), key.size());
+            ix += key.size();
+            std::memcpy(&b[ix], " = ", 3);
+            ix += 3;
+            to<TOML, decltype(val)>::template op<Opts>(val, ctx, b, ix);
+         }
+      }
+   };
+
+   // (The remainder of the code – for C arrays, tuples, includers, etc. – is unchanged.)
+   template <nullable_t T>
+      requires(std::is_array_v<T>)
+   struct to<TOML, T>
+   {
+      template <auto Opts, class V, size_t N, class... Args>
+      GLZ_ALWAYS_INLINE static void op(const V (&value)[N], is_context auto&& ctx, Args&&... args)
+      {
+         serialize<TOML>::op<Opts>(std::span{value, N}, ctx, std::forward<Args>(args)...);
+      }
+   };
+
+   template <class T>
+      requires glaze_array_t<T> || tuple_t<std::decay_t<T>> || is_std_tuple<T>
+   struct to<TOML, T>
+   {
+      template <auto Opts, class... Args>
+      static void op(auto&& value, is_context auto&& ctx, Args&&... args)
+      {
+         static constexpr auto N = []() constexpr {
+            if constexpr (glaze_array_t<std::decay_t<T>>) {
+               return glz::tuple_size_v<meta_t<std::decay_t<T>>>;
+            }
+            else {
+               return glz::tuple_size_v<std::decay_t<T>>;
+            }
+         }();
+
+         dump<'['>(args...);
+         using V = std::decay_t<T>;
+         for_each<N>([&]<size_t I>() {
+            if constexpr (glaze_array_t<V>) {
+               serialize<TOML>::op<Opts>(get_member(value, glz::get<I>(meta_v<T>)), ctx, args...);
+            }
+            else if constexpr (is_std_tuple<T>) {
+               using Value = core_t<decltype(std::get<I>(value))>;
+               to<TOML, Value>::template op<Opts>(std::get<I>(value), ctx, args...);
+            }
+            else {
+               using Value = core_t<decltype(glz::get<I>(value))>;
+               to<TOML, Value>::template op<Opts>(glz::get<I>(value), ctx, args...);
+            }
+            constexpr bool needs_comma = I < N - 1;
+            if constexpr (needs_comma) {
+               write_array_entry_separator<Opts>(ctx, args...);
+            }
+         });
+         dump<']'>(args...);
+      }
+   };
+
+   template <is_includer T>
+   struct to<TOML, T>
+   {
+      template <auto Opts, class... Args>
+      GLZ_ALWAYS_INLINE static void op(auto&&, is_context auto&&, Args&&... args)
+      {
+         dump<R"("")">(args...); // dump an empty string
+      }
+   };
+
+   template <write_supported<TOML> T, output_buffer Buffer>
+   [[nodiscard]] error_ctx write_toml(T&& value, Buffer&& buffer)
+   {
+      return write<opts{.format = TOML}>(std::forward<T>(value), std::forward<Buffer>(buffer));
+   }
+
+   template <write_supported<TOML> T, raw_buffer Buffer>
+   [[nodiscard]] glz::expected<size_t, error_ctx> write_toml(T&& value, Buffer&& buffer)
+   {
+      return write<opts{.format = TOML}>(std::forward<T>(value), std::forward<Buffer>(buffer));
+   }
+
+   template <write_supported<TOML> T>
+   [[nodiscard]] glz::expected<std::string, error_ctx> write_toml(T&& value)
+   {
+      return write<opts{.format = TOML}>(std::forward<T>(value));
+   }
+
+   template <auto Opts = opts{.format = TOML}, write_supported<TOML> T>
+   [[nodiscard]] error_ctx write_file_toml(T&& value, const sv file_name, auto&& buffer)
+   {
+      const auto ec = write<set_toml<Opts>()>(std::forward<T>(value), buffer);
+      if (bool(ec)) [[unlikely]] {
+         return ec;
+      }
+      return {buffer_to_file(buffer, file_name)};
+   }
+}
diff --git a/deps/saucer/include/glaze/trace/trace.hpp b/deps/saucer/include/glaze/trace/trace.hpp
index 8e9a53e..47788f1 100644
--- a/deps/saucer/include/glaze/trace/trace.hpp
+++ b/deps/saucer/include/glaze/trace/trace.hpp
@@ -34,10 +34,10 @@ namespace glz
    {
       static constexpr sv name = "glz::display_time_unit";
       using enum display_time_unit;
-      static constexpr auto value = enumerate_no_reflect("s", s, //
-                                                         "ms", ms, //
-                                                         "us", us, //
-                                                         "ns", ns);
+      static constexpr auto value = enumerate("s", s, //
+                                              "ms", ms, //
+                                              "us", us, //
+                                              "ns", ns);
    };
 
    struct trace_event
@@ -55,59 +55,66 @@ namespace glz
       glz::raw_json args = "{}"; // metadata
    };
 
+   template <bool Enabled = true>
    struct trace
    {
-      std::deque<trace_event> traceEvents{};
+      std::atomic<bool> disabled = false;
       display_time_unit displayTimeUnit = display_time_unit::ms;
-
+      std::deque<trace_event> traceEvents{};
       std::optional<std::chrono::time_point<std::chrono::steady_clock>> t0{}; // the time of the first event
-
-      std::atomic<bool> disabled = false;
       std::mutex mtx{};
 
+      void clear() { traceEvents.clear(); }
+
       template <class... Args>
          requires(sizeof...(Args) <= 1)
       void begin(const std::string_view name, Args&&... args) noexcept
       {
-         if (disabled) {
-            return;
+         if constexpr (Enabled) {
+            if (disabled) {
+               return;
+            }
+            duration(name, 'B', std::forward<Args>(args)...);
          }
-         duration(name, 'B', std::forward<Args>(args)...);
       }
 
       template <class... Args>
          requires(sizeof...(Args) <= 1)
       void end(const std::string_view name, Args&&... args) noexcept
       {
-         if (disabled) {
-            return;
+         if constexpr (Enabled) {
+            if (disabled) {
+               return;
+            }
+            duration(name, 'E', std::forward<Args>(args)...);
          }
-         duration(name, 'E', std::forward<Args>(args)...);
       }
 
       template <class... Args>
          requires(sizeof...(Args) <= 1)
       void duration(const std::string_view name, const char phase, Args&&... args) noexcept
       {
-         if (disabled) {
-            return;
-         }
+         if constexpr (Enabled) {
+            if (disabled) {
+               return;
+            }
 
-         const auto tnow = std::chrono::steady_clock::now();
-         trace_event* event{};
-         {
-            std::unique_lock lock{mtx};
-            if (!t0) {
-               t0 = tnow;
+            const auto tnow = std::chrono::steady_clock::now();
+            trace_event* event{};
+            {
+               std::unique_lock lock{mtx};
+               if (!t0) {
+                  t0 = tnow;
+               }
+               event = &traceEvents.emplace_back();
+            }
+            event->name = name;
+            event->ph = phase;
+            event->ts = std::chrono::duration_cast<std::chrono::microseconds>(tnow - t0.value()).count();
+            event->tid = std::hash<std::thread::id>{}(std::this_thread::get_id());
+            if constexpr (sizeof...(Args) > 0) {
+               std::ignore = glz::write_json(std::forward<Args>(args)..., event->args.str);
             }
-            event = &traceEvents.emplace_back();
-         }
-         event->name = name;
-         event->ph = phase;
-         event->ts = std::chrono::duration_cast<std::chrono::microseconds>(tnow - t0.value()).count();
-         event->tid = std::hash<std::thread::id>{}(std::this_thread::get_id());
-         if constexpr (sizeof...(Args) > 0) {
-            std::ignore = glz::write_json(std::forward<Args>(args)..., event->args.str);
          }
       }
 
@@ -115,135 +122,121 @@ namespace glz
          requires(sizeof...(Args) <= 1)
       void async_begin(const std::string_view name, Args&&... args) noexcept
       {
-         if (disabled) {
-            return;
+         if constexpr (Enabled) {
+            if (disabled) {
+               return;
+            }
+            async(name, 'b', std::forward<Args>(args)...);
          }
-         async(name, 'b', std::forward<Args>(args)...);
       }
 
       template <class... Args>
          requires(sizeof...(Args) <= 1)
       void async_end(const std::string_view name, Args&&... args) noexcept
       {
-         if (disabled) {
-            return;
+         if constexpr (Enabled) {
+            if (disabled) {
+               return;
+            }
+            async(name, 'e', std::forward<Args>(args)...);
          }
-         async(name, 'e', std::forward<Args>(args)...);
       }
 
       template <class... Args>
          requires(sizeof...(Args) <= 1)
       void async(const std::string_view name, const char phase, Args&&... args) noexcept
       {
-         if (disabled) {
-            return;
-         }
+         if constexpr (Enabled) {
+            if (disabled) {
+               return;
+            }
 
-         const auto tnow = std::chrono::steady_clock::now();
-         trace_event* event{};
-         {
-            std::unique_lock lock{mtx};
-            if (!t0) {
-               t0 = tnow;
+            const auto tnow = std::chrono::steady_clock::now();
+            trace_event* event{};
+            {
+               std::unique_lock lock{mtx};
+               if (!t0) {
+                  t0 = tnow;
+               }
+               event = &traceEvents.emplace_back();
+            }
+            event->name = name;
+            event->ph = phase;
+            event->ts = std::chrono::duration_cast<std::chrono::microseconds>(tnow - t0.value()).count();
+            event->tid = std::hash<std::thread::id>{}(std::this_thread::get_id());
+            event->id = std::hash<std::string_view>{}(name);
+            if constexpr (sizeof...(Args) > 0) {
+               std::ignore = glz::write_json(std::forward<Args>(args)..., event->args.str);
             }
-            event = &traceEvents.emplace_back();
-         }
-         event->name = name;
-         event->ph = phase;
-         event->ts = std::chrono::duration_cast<std::chrono::microseconds>(tnow - t0.value()).count();
-         event->tid = std::hash<std::thread::id>{}(std::this_thread::get_id());
-         event->id = std::hash<std::string_view>{}(name);
-         if constexpr (sizeof...(Args) > 0) {
-            std::ignore = glz::write_json(std::forward<Args>(args)..., event->args.str);
          }
       }
-   };
 
-   template <>
-   struct meta<trace>
-   {
-      using T = trace;
-      static constexpr auto value = object(&T::traceEvents, &T::displayTimeUnit);
-   };
-
-   // Global approach to user a trace
-   // instead of calling: my_trace.begin("my event");
-   // you can call: glz::trace_begin("my event");
-   template <size_t I>
-   inline trace& global_trace() noexcept
-   {
-      static trace trc{};
-      return trc;
-   }
+      // Automatically adds the end event when it leave scope
+      struct duration_scoper final
+      {
+         trace& tr;
 
-   template <size_t I>
-   inline void enable_trace() noexcept
-   {
-      global_trace<0>().disabled = false;
-   }
+         duration_scoper(trace& tr, const std::string_view name) noexcept : tr(tr), name(name)
+         {
+            if constexpr (Enabled) {
+               if (not tr.disabled) {
+                  tr.begin(name);
+               }
+            }
+         }
+         ~duration_scoper() noexcept
+         {
+            if constexpr (Enabled) {
+               if (not tr.disabled) {
+                  tr.end(name);
+               }
+            }
+         }
 
-   template <size_t I>
-   inline void disable_trace() noexcept
-   {
-      global_trace<0>().disabled = true;
-   }
+         const std::string_view name{};
+      };
 
-   template <opts Opts = opts{}>
-   [[nodiscard]] error_ctx write_file_trace(const std::string& file_name, auto&& buffer) noexcept
-   {
-      const auto ec = write<set_json<Opts>()>(global_trace<0>(), buffer);
-      if (bool(ec)) [[unlikely]] {
-         return ec;
-      }
-      return {buffer_to_file(buffer, file_name)};
-   }
+      struct async_scoper final
+      {
+         trace& tr;
 
-   template <class... Args>
-      requires(sizeof...(Args) <= 1)
-   constexpr void trace_begin(const std::string_view name, Args&&... args) noexcept
-   {
-      auto& trc = global_trace<0>();
-      trc.begin(name, std::forward<Args>(args)...);
-   }
+         async_scoper(trace& tr, const std::string_view name) noexcept : tr(tr), name(name)
+         {
+            if constexpr (Enabled) {
+               if (not tr.disabled) {
+                  tr.async_begin(name);
+               }
+            }
+         }
+         ~async_scoper() noexcept
+         {
+            if constexpr (Enabled) {
+               if (not tr.disabled) {
+                  tr.async_end(name);
+               }
+            }
+         }
 
-   template <class... Args>
-      requires(sizeof...(Args) <= 1)
-   constexpr void trace_end(const std::string_view name, Args&&... args) noexcept
-   {
-      auto& trc = global_trace<0>();
-      trc.end(name, std::forward<Args>(args)...);
-   }
+         const std::string_view name{};
+      };
 
-   template <class... Args>
-      requires(sizeof...(Args) <= 1)
-   constexpr void trace_async_begin(const std::string_view name, Args&&... args) noexcept
-   {
-      auto& trc = global_trace<0>();
-      trc.async_begin(name, std::forward<Args>(args)...);
-   }
+      duration_scoper scope(const std::string_view name) { return {*this, name}; }
 
-   template <class... Args>
-      requires(sizeof...(Args) <= 1)
-   constexpr void trace_async_end(const std::string_view name, Args&&... args) noexcept
-   {
-      auto& trc = global_trace<0>();
-      trc.async_end(name, std::forward<Args>(args)...);
-   }
+      async_scoper async_scope(const std::string_view name) { return {*this, name}; }
+   };
 
-   // Automatically adds the end event when it leave scope
-   struct duration_trace final
+   template <>
+   struct meta<trace<true>>
    {
-      duration_trace(const std::string_view name) noexcept : name(name) { trace_begin(name); }
-      ~duration_trace() noexcept { trace_end(name); }
-
-      const std::string_view name{};
+      using T = trace<true>;
+      static constexpr auto value = object(&T::traceEvents, &T::displayTimeUnit);
    };
 
-   struct async_trace final
+   template <>
+   struct meta<trace<false>>
    {
-      async_trace(const std::string_view name) noexcept : name(name) { trace_async_begin(name); }
-      ~async_trace() noexcept { trace_async_end(name); }
-
-      const std::string_view name{};
+      using T = trace<false>;
+      // Compile time disabled trace writes out an empty object
+      static constexpr auto value = object();
    };
 }
diff --git a/deps/saucer/include/glaze/tuplet/tuple.hpp b/deps/saucer/include/glaze/tuplet/tuple.hpp
index c01664c..7a382a3 100644
--- a/deps/saucer/include/glaze/tuplet/tuple.hpp
+++ b/deps/saucer/include/glaze/tuplet/tuple.hpp
@@ -1,56 +1,52 @@
-// source: https://github.com/codeinred/tuplet
+// Glaze Library
+// For the license information refer to glaze.hpp
+
+// original source (significantly refactored): https://github.com/codeinred/tuplet
 
 #pragma once
 
 #include <compare>
+#include <concepts>
 #include <cstddef>
 #include <type_traits>
 #include <utility>
 
+#include "glaze/util/inline.hpp"
+
 #if (__has_cpp_attribute(no_unique_address))
-#define TUPLET_NO_UNIQUE_ADDRESS [[no_unique_address]]
+#define GLZ_NO_UNIQUE_ADDRESS [[no_unique_address]]
 #elif (__has_cpp_attribute(msvc::no_unique_address)) || ((defined _MSC_VER) && (!defined __clang__))
 // Note __has_cpp_attribute(msvc::no_unique_address) itself doesn't work as
 // of 19.30.30709, even though the attribute itself is supported. See
 // https://github.com/llvm/llvm-project/issues/49358#issuecomment-981041089
-#define TUPLET_NO_UNIQUE_ADDRESS [[msvc::no_unique_address]]
+#define GLZ_NO_UNIQUE_ADDRESS [[msvc::no_unique_address]]
 #else
 // no_unique_address is not available.
-#define TUPLET_NO_UNIQUE_ADDRESS
+#define GLZ_NO_UNIQUE_ADDRESS
 #endif
 
 namespace glz
 {
-
    // tuplet concepts and traits
    namespace tuplet
    {
       template <class T>
       using identity_t = T;
 
-      // Obtains T::type
       template <class T>
       using type_t = typename T::type;
 
       template <size_t I>
       using tag = std::integral_constant<size_t, I>;
 
-      template <size_t I>
-      constexpr tag<I> tag_v{};
-
       template <size_t N>
       using tag_range = std::make_index_sequence<N>;
 
-      template <class T, class U>
-      concept same_as = std::is_same_v<T, U> && std::is_same_v<U, T>;
-
       template <class T, class U>
       concept other_than = !std::is_same_v<std::decay_t<T>, U>;
 
       template <class Tup>
       using base_list_t = typename std::decay_t<Tup>::base_list;
-      template <class Tup>
-      using element_list_t = typename std::decay_t<Tup>::element_list;
 
       template <class Tuple>
       concept base_list_tuple = requires() { typename std::decay_t<Tuple>::base_list; };
@@ -66,27 +62,23 @@ namespace glz
 
       template <class T>
       concept ordered = requires(const T& t) {
-         {
-            t <=> t
-         };
+         { t <=> t };
       };
       template <class T>
       concept equality_comparable = requires(const T& t) {
-         {
-            t == t
-         } -> same_as<bool>;
+         { t == t } -> std::same_as<bool>;
       };
    } // namespace tuplet
 
+   template <class... T>
+   struct tuple;
+
    // tuplet::type_list implementation
    // tuplet::type_map implementation
    // tuplet::tuple_elem implementation
    // tuplet::deduce_elems
    namespace tuplet
    {
-      template <class... T>
-      struct tuple;
-
       template <class... T>
       struct type_list
       {};
@@ -114,7 +106,7 @@ namespace glz
          static T decl_elem(tag<I>);
          using type = T;
 
-         TUPLET_NO_UNIQUE_ADDRESS T value;
+         GLZ_NO_UNIQUE_ADDRESS T value;
 
          constexpr decltype(auto) operator[](tag<I>) & { return (value); }
          constexpr decltype(auto) operator[](tag<I>) const& { return (value); }
@@ -133,13 +125,14 @@ namespace glz
             return value == other.value;
          }
       };
-      template <class T>
-      using unwrap_ref_decay_t = typename std::unwrap_ref_decay<T>::type;
    } // namespace tuplet
 
-   // tuplet::detail::get_tuple_base implementation
-   // tuplet::detail::apply_impl
-   namespace tuplet::detail
+   template <class T>
+   using unwrap_ref_decay_t = typename std::unwrap_ref_decay<T>::type;
+
+   // tuplet::get_tuple_base implementation
+   // tuplet::apply_impl
+   namespace tuplet
    {
       template <class A, class... T>
       struct get_tuple_base;
@@ -183,320 +176,228 @@ namespace glz
       {
          return {{{static_cast<type_t<Outer>&&>(tup.identity_t<Outer>::value).identity_t<Inner>::value}...}};
       }
-   } // namespace tuplet::detail
-
-   // tuplet::tuple implementation
-   namespace tuplet
-   {
-      template <class... T>
-      using tuple_base_t = typename detail::get_tuple_base<tag_range<sizeof...(T)>, T...>::type;
 
       template <class... T>
-      struct tuple : tuple_base_t<T...>
-      {
-         static constexpr auto glaze_reflect = false;
-         constexpr static size_t N = sizeof...(T);
-         using super = tuple_base_t<T...>;
-         using super::operator[];
-         using base_list = typename super::base_list;
-         using element_list = type_list<T...>;
-         using super::decl_elem;
-
-         template <other_than<tuple> U> // Preserves default assignments
-         constexpr auto& operator=(U&& tup)
-         {
-            using tuple2 = std::decay_t<U>;
-            if (base_list_tuple<tuple2>) {
-               eq_impl(static_cast<U&&>(tup), base_list(), typename tuple2::base_list());
-            }
-            else {
-               eq_impl(static_cast<U&&>(tup), tag_range<N>());
-            }
-            return *this;
-         }
-
-         // TODO: currently segfaults clang
-         /*template <assignable_to<T>... U>
-         constexpr auto& assign(U&&... values) {
-            assign_impl(base_list(), static_cast<U&&>(values)...);
-            return *this;
-         }*/
-
-         auto operator<=>(const tuple&) const = default;
-         bool operator==(const tuple&) const = default;
-
-         // Applies a function to every element of the tuple. The order is the
-         // declaration order, so first the function will be applied to element 0,
-         // then element 1, then element 2, and so on, where element N is identified
-         // by get<N>
-         template <class F>
-         constexpr void for_each(F&& func) &
-         {
-            for_each_impl(base_list(), static_cast<F&&>(func));
-         }
-         template <class F>
-         constexpr void for_each(F&& func) const&
-         {
-            for_each_impl(base_list(), static_cast<F&&>(func));
-         }
-         template <class F>
-         constexpr void for_each(F&& func) &&
-         {
-            static_cast<tuple&&>(*this).for_each_impl(base_list(), static_cast<F&&>(func));
-         }
-
-         // Applies a function to each element successively, until one returns a
-         // truthy value. Returns true if any application returned a truthy value,
-         // and false otherwise
-         template <class F>
-         constexpr bool any(F&& func) &
-         {
-            return any_impl(base_list(), static_cast<F&&>(func));
-         }
-         template <class F>
-         constexpr bool any(F&& func) const&
-         {
-            return any_impl(base_list(), static_cast<F&&>(func));
-         }
-         template <class F>
-         constexpr bool any(F&& func) &&
-         {
-            return static_cast<tuple&&>(*this).any_impl(base_list(), static_cast<F&&>(func));
-         }
-
-         // Applies a function to each element successively, until one returns a
-         // falsy value. Returns true if every application returned a truthy value,
-         // and false otherwise
-         template <class F>
-         constexpr bool all(F&& func) &
-         {
-            return all_impl(base_list(), static_cast<F&&>(func));
-         }
-         template <class F>
-         constexpr bool all(F&& func) const&
-         {
-            return all_impl(base_list(), static_cast<F&&>(func));
-         }
-         template <class F>
-         constexpr bool all(F&& func) &&
-         {
-            return static_cast<tuple&&>(*this).all_impl(base_list(), static_cast<F&&>(func));
-         }
-
-         // Map a function over every element in the tuple, using the values to
-         // construct a new tuple
-         template <class F>
-         constexpr auto map(F&& func) &
-         {
-            return map_impl(base_list(), static_cast<F&&>(func));
-         }
-         template <class F>
-         constexpr auto map(F&& func) const&
-         {
-            return map_impl(base_list(), static_cast<F&&>(func));
-         }
-         template <class F>
-         constexpr auto map(F&& func) &&
-         {
-            return static_cast<tuple&&>(*this).map_impl(base_list(), static_cast<F&&>(func));
-         }
+      using tuple_base_t = typename get_tuple_base<tag_range<sizeof...(T)>, T...>::type;
+   }
 
-        private:
-         template <class U, class... B1, class... B2>
-         constexpr void eq_impl(U&& u, type_list<B1...>, type_list<B2...>)
-         {
-            // See:
-            // https://developercommunity.visualstudio.com/t/fold-expressions-unreliable-in-171-with-c20/1676476
-            (void(B1::value = static_cast<U&&>(u).B2::value), ...);
-         }
-         template <class U, size_t... I>
-         constexpr void eq_impl(U&& u, std::index_sequence<I...>)
-         {
-            (void(tuple_elem<I, T>::value = get<I>(static_cast<U&&>(u))), ...);
+   template <class... T>
+   struct tuple : tuplet::tuple_base_t<T...>
+   {
+      static constexpr auto glaze_reflect = false;
+      static constexpr size_t N = sizeof...(T);
+      using super = tuplet::tuple_base_t<T...>;
+      using super::operator[];
+      using base_list = typename super::base_list;
+      using super::decl_elem;
+
+      template <tuplet::other_than<tuple> U> // Preserves default assignments
+      constexpr auto& operator=(U&& tup)
+      {
+         using tuple2 = std::decay_t<U>;
+         if constexpr (tuplet::base_list_tuple<tuple2>) {
+            eq_impl(static_cast<U&&>(tup), base_list(), typename tuple2::base_list());
          }
-         template <class... U, class... B>
-         constexpr void assign_impl(type_list<B...>, U&&... u)
-         {
-            (void(B::value = static_cast<U&&>(u)), ...);
+         else {
+            eq_impl(static_cast<U&&>(tup), tuplet::tag_range<N>());
          }
+         return *this;
+      }
 
-         template <class F, class... B>
-         constexpr void for_each_impl(type_list<B...>, F&& func) &
-         {
-            (void(func(B::value)), ...);
-         }
-         template <class F, class... B>
-         constexpr void for_each_impl(type_list<B...>, F&& func) const&
-         {
-            (void(func(B::value)), ...);
-         }
-         template <class F, class... B>
-         constexpr void for_each_impl(type_list<B...>, F&& func) &&
-         {
-            (void(func(static_cast<T&&>(B::value))), ...);
-         }
+      // TODO: currently segfaults clang
+      /*template <assignable_to<T>... U>
+      constexpr auto& assign(U&&... values) {
+         assign_impl(base_list(), static_cast<U&&>(values)...);
+         return *this;
+      }*/
+
+      auto operator<=>(const tuple&) const = default;
+      bool operator==(const tuple&) const = default;
+
+      // Applies a function to every element of the tuple. The order is the
+      // declaration order, so first the function will be applied to element 0,
+      // then element 1, then element 2, and so on, where element N is identified
+      // by get<N>
+      template <class F>
+      constexpr void for_each(F&& func) &
+      {
+         for_each_impl(base_list(), static_cast<F&&>(func));
+      }
+      template <class F>
+      constexpr void for_each(F&& func) const&
+      {
+         for_each_impl(base_list(), static_cast<F&&>(func));
+      }
+      template <class F>
+      constexpr void for_each(F&& func) &&
+      {
+         static_cast<tuple&&>(*this).for_each_impl(base_list(), static_cast<F&&>(func));
+      }
 
-         template <class F, class... B>
-         constexpr bool any_impl(type_list<B...>, F&& func) &
-         {
-            return (bool(func(B::value)) || ...);
-         }
-         template <class F, class... B>
-         constexpr bool any_impl(type_list<B...>, F&& func) const&
-         {
-            return (bool(func(B::value)) || ...);
-         }
-         template <class F, class... B>
-         constexpr bool any_impl(type_list<B...>, F&& func) &&
-         {
-            return (bool(func(static_cast<T&&>(B::value))) || ...);
-         }
+      // Applies a function to each element successively, until one returns a
+      // truthy value. Returns true if any application returned a truthy value,
+      // and false otherwise
+      template <class F>
+      constexpr bool any(F&& func) &
+      {
+         return any_impl(base_list(), static_cast<F&&>(func));
+      }
+      template <class F>
+      constexpr bool any(F&& func) const&
+      {
+         return any_impl(base_list(), static_cast<F&&>(func));
+      }
+      template <class F>
+      constexpr bool any(F&& func) &&
+      {
+         return static_cast<tuple&&>(*this).any_impl(base_list(), static_cast<F&&>(func));
+      }
 
-         template <class F, class... B>
-         constexpr bool all_impl(type_list<B...>, F&& func) &
-         {
-            return (bool(func(B::value)) && ...);
-         }
-         template <class F, class... B>
-         constexpr bool all_impl(type_list<B...>, F&& func) const&
-         {
-            return (bool(func(B::value)) && ...);
-         }
-         template <class F, class... B>
-         constexpr bool all_impl(type_list<B...>, F&& func) &&
-         {
-            return (bool(func(static_cast<T&&>(B::value))) && ...);
-         }
+      // Applies a function to each element successively, until one returns a
+      // falsy value. Returns true if every application returned a truthy value,
+      // and false otherwise
+      template <class F>
+      constexpr bool all(F&& func) &
+      {
+         return all_impl(base_list(), static_cast<F&&>(func));
+      }
+      template <class F>
+      constexpr bool all(F&& func) const&
+      {
+         return all_impl(base_list(), static_cast<F&&>(func));
+      }
+      template <class F>
+      constexpr bool all(F&& func) &&
+      {
+         return static_cast<tuple&&>(*this).all_impl(base_list(), static_cast<F&&>(func));
+      }
 
-         template <class F, class... B>
-         constexpr auto map_impl(type_list<B...>, F&& func) & -> tuple<unwrap_ref_decay_t<decltype(func(B::value))>...>
-         {
-            return {func(B::value)...};
-         }
-         template <class F, class... B>
-         constexpr auto map_impl(type_list<B...>,
-                                 F&& func) const& -> tuple<unwrap_ref_decay_t<decltype(func(B::value))>...>
-         {
-            return {func(B::value)...};
-         }
-         template <class F, class... B>
-         constexpr auto map_impl(
-            type_list<B...>, F&& func) && -> tuple<unwrap_ref_decay_t<decltype(func(static_cast<T&&>(B::value)))>...>
-         {
-            return {func(static_cast<T&&>(B::value))...};
-         }
-      };
-      template <>
-      struct tuple<> : tuple_base_t<>
+     private:
+      template <class U, class... B1, class... B2>
+      constexpr void eq_impl(U&& u, tuplet::type_list<B1...>, tuplet::type_list<B2...>)
+      {
+         // See:
+         // https://developercommunity.visualstudio.com/t/fold-expressions-unreliable-in-171-with-c20/1676476
+         (void(B1::value = static_cast<U&&>(u).B2::value), ...);
+      }
+      template <class U, size_t... I>
+      constexpr void eq_impl(U&& u, std::index_sequence<I...>)
       {
-         constexpr static size_t N = 0;
-         using super = tuple_base_t<>;
-         using base_list = type_list<>;
-         using element_list = type_list<>;
+         (void(tuplet::tuple_elem<I, T>::value = get<I>(static_cast<U&&>(u))), ...);
+      }
+      template <class... U, class... B>
+      constexpr void assign_impl(tuplet::type_list<B...>, U&&... u)
+      {
+         (void(B::value = static_cast<U&&>(u)), ...);
+      }
 
-         template <other_than<tuple> U> // Preserves default assignments
-            requires stateless<U> // Check that U is similarly stateless
-         constexpr auto& operator=(U&&) noexcept
-         {
-            return *this;
-         }
+      template <class F, class... B>
+      constexpr void for_each_impl(tuplet::type_list<B...>, F&& func) &
+      {
+         (void(func(B::value)), ...);
+      }
+      template <class F, class... B>
+      constexpr void for_each_impl(tuplet::type_list<B...>, F&& func) const&
+      {
+         (void(func(B::value)), ...);
+      }
+      template <class F, class... B>
+      constexpr void for_each_impl(tuplet::type_list<B...>, F&& func) &&
+      {
+         (void(func(static_cast<T&&>(B::value))), ...);
+      }
 
-         constexpr auto& assign() noexcept { return *this; }
-         auto operator<=>(const tuple&) const = default;
-         bool operator==(const tuple&) const = default;
-
-         // Applies a function to every element of the tuple. The order is the
-         // declaration order, so first the function will be applied to element 0,
-         // then element 1, then element 2, and so on, where element N is identified
-         // by get<N>
-         //
-         // (Does nothing when invoked on empty tuple)
-         template <class F>
-         constexpr void for_each(F&&) const noexcept
-         {}
-
-         // Applies a function to each element successively, until one returns a
-         // truthy value. Returns true if any application returned a truthy value,
-         // and false otherwise
-         //
-         // (Returns false for empty tuple)
-         template <class F>
-         constexpr bool any(F&&) const noexcept
-         {
-            return false;
-         }
+      template <class F, class... B>
+      constexpr bool any_impl(tuplet::type_list<B...>, F&& func) &
+      {
+         return (bool(func(B::value)) || ...);
+      }
+      template <class F, class... B>
+      constexpr bool any_impl(tuplet::type_list<B...>, F&& func) const&
+      {
+         return (bool(func(B::value)) || ...);
+      }
+      template <class F, class... B>
+      constexpr bool any_impl(tuplet::type_list<B...>, F&& func) &&
+      {
+         return (bool(func(static_cast<T&&>(B::value))) || ...);
+      }
 
-         // Applies a function to each element successively, until one returns a
-         // falsy value. Returns true if every application returned a truthy value,
-         // and false otherwise
-         //
-         // (Returns true for empty tuple)
-         template <class F>
-         constexpr bool all(F&&) const noexcept
-         {
-            return true;
-         }
+      template <class F, class... B>
+      constexpr bool all_impl(tuplet::type_list<B...>, F&& func) &
+      {
+         return (bool(func(B::value)) && ...);
+      }
+      template <class F, class... B>
+      constexpr bool all_impl(tuplet::type_list<B...>, F&& func) const&
+      {
+         return (bool(func(B::value)) && ...);
+      }
+      template <class F, class... B>
+      constexpr bool all_impl(tuplet::type_list<B...>, F&& func) &&
+      {
+         return (bool(func(static_cast<T&&>(B::value))) && ...);
+      }
+   };
+   template <>
+   struct tuple<> : tuplet::tuple_base_t<>
+   {
+      constexpr static size_t N = 0;
+      using super = tuplet::tuple_base_t<>;
+      using base_list = tuplet::type_list<>;
 
-         // Map a function over every element in the tuple, using the values to
-         // construct a new tuple
-         //
-         // (Returns empty tuple when invoked on empty tuple)
-         template <class F>
-         constexpr auto map(F&&) const noexcept
-         {
-            return tuple{};
-         }
-      };
-      template <class... Ts>
-      tuple(Ts...) -> tuple<unwrap_ref_decay_t<Ts>...>;
-   } // namespace tuplet
+      template <tuplet::other_than<tuple> U> // Preserves default assignments
+         requires tuplet::stateless<U> // Check that U is similarly stateless
+      constexpr auto& operator=(U&&) noexcept
+      {
+         return *this;
+      }
 
-   // tuplet::pair implementation
-   namespace tuplet
-   {
-      template <class First, class Second>
-      struct pair
-      {
-         constexpr static size_t N = 2;
-         TUPLET_NO_UNIQUE_ADDRESS First first;
-         TUPLET_NO_UNIQUE_ADDRESS Second second;
-
-         constexpr decltype(auto) operator[](tag<0>) & { return (first); }
-         constexpr decltype(auto) operator[](tag<0>) const& { return (first); }
-         constexpr decltype(auto) operator[](tag<0>) && { return (std::move(*this).first); }
-         constexpr decltype(auto) operator[](tag<1>) & { return (second); }
-         constexpr decltype(auto) operator[](tag<1>) const& { return (second); }
-         constexpr decltype(auto) operator[](tag<1>) && { return (std::move(*this).second); }
-
-         template <other_than<pair> Type> // Preserves default assignments
-         constexpr auto& operator=(Type&& tup)
-         {
-            auto&& [a, b] = static_cast<Type&&>(tup);
-            first = static_cast<decltype(a)&&>(a);
-            second = static_cast<decltype(b)&&>(b);
-            return *this;
-         }
+      constexpr auto& assign() noexcept { return *this; }
+      auto operator<=>(const tuple&) const = default;
+      bool operator==(const tuple&) const = default;
+
+      // Applies a function to every element of the tuple. The order is the
+      // declaration order, so first the function will be applied to element 0,
+      // then element 1, then element 2, and so on, where element N is identified
+      // by get<N>
+      //
+      // (Does nothing when invoked on empty tuple)
+      template <class F>
+      constexpr void for_each(F&&) const noexcept
+      {}
+
+      // Applies a function to each element successively, until one returns a
+      // truthy value. Returns true if any application returned a truthy value,
+      // and false otherwise
+      //
+      // (Returns false for empty tuple)
+      template <class F>
+      constexpr bool any(F&&) const noexcept
+      {
+         return false;
+      }
 
-         template <assignable_to<First> F2, assignable_to<Second> S2>
-         constexpr auto& assign(F2&& f, S2&& s)
-         {
-            first = static_cast<F2&&>(f);
-            second = static_cast<S2&&>(s);
-            return *this;
-         }
-         auto operator<=>(const pair&) const = default;
-         bool operator==(const pair&) const = default;
-      };
-      template <class A, class B>
-      pair(A, B) -> pair<unwrap_ref_decay_t<A>, unwrap_ref_decay_t<B>>;
-   } // namespace tuplet
+      // Applies a function to each element successively, until one returns a
+      // falsy value. Returns true if every application returned a truthy value,
+      // and false otherwise
+      //
+      // (Returns true for empty tuple)
+      template <class F>
+      constexpr bool all(F&&) const noexcept
+      {
+         return true;
+      }
+   };
+   template <class... Ts>
+   tuple(Ts...) -> tuple<unwrap_ref_decay_t<Ts>...>;
 
    // tuplet::convert implementation
    namespace tuplet
    {
       // Converts from one tuple type to any other tuple or U
       template <class Tuple>
-      struct convert
+      struct convert final
       {
          using base_list = typename std::decay_t<Tuple>::base_list;
          Tuple tuple;
@@ -525,13 +426,13 @@ namespace glz
    // glz::tie implementation
    // glz::apply implementation
    template <size_t I, tuplet::indexable Tup>
-   constexpr decltype(auto) get(Tup&& tup)
+   GLZ_ALWAYS_INLINE constexpr decltype(auto) get(Tup&& tup) noexcept
    {
       return static_cast<Tup&&>(tup)[tuplet::tag<I>()];
    }
 
    template <class... T>
-   constexpr tuplet::tuple<T&...> tie(T&... t)
+   constexpr tuple<T&...> tie(T&... t)
    {
       return {t...};
    }
@@ -539,23 +440,8 @@ namespace glz
    template <class F, tuplet::base_list_tuple Tup>
    constexpr decltype(auto) apply(F&& func, Tup&& tup)
    {
-      return tuplet::detail::apply_impl(static_cast<F&&>(func), static_cast<Tup&&>(tup),
-                                        typename std::decay_t<Tup>::base_list());
-   }
-   template <class F, class A, class B>
-   constexpr decltype(auto) apply(F&& func, tuplet::pair<A, B>& pair)
-   {
-      return static_cast<F&&>(func)(pair.first, pair.second);
-   }
-   template <class F, class A, class B>
-   constexpr decltype(auto) apply(F&& func, const tuplet::pair<A, B>& pair)
-   {
-      return static_cast<F&&>(func)(pair.first, pair.second);
-   }
-   template <class F, class A, class B>
-   constexpr decltype(auto) apply(F&& func, tuplet::pair<A, B>&& pair)
-   {
-      return static_cast<F&&>(func)(std::move(pair).first, std::move(pair).second);
+      return tuplet::apply_impl(static_cast<F&&>(func), static_cast<Tup&&>(tup),
+                                typename std::decay_t<Tup>::base_list());
    }
 
    // tuplet::tuple_cat implementation
@@ -592,9 +478,9 @@ namespace glz
             using big_tuple = tuple<std::decay_t<T>...>;
 #endif
             using outer_bases = base_list_t<big_tuple>;
-            constexpr auto outer = detail::get_outer_bases(outer_bases{});
-            constexpr auto inner = detail::get_inner_bases(outer_bases{});
-            return detail::cat_impl(big_tuple{{{std::forward<T>(ts)}...}}, outer, inner);
+            constexpr auto outer = get_outer_bases(outer_bases{});
+            constexpr auto inner = get_inner_bases(outer_bases{});
+            return cat_impl(big_tuple{{{std::forward<T>(ts)}...}}, outer, inner);
          }
       }
 
@@ -614,6 +500,7 @@ namespace glz
 
 #include <array>
 #include <tuple>
+#include <variant>
 
 namespace glz
 {
@@ -654,23 +541,12 @@ namespace glz
    };
 
    template <class... T>
-   struct tuple_size<glz::tuplet::tuple<T...>> : std::integral_constant<size_t, sizeof...(T)>
+   struct tuple_size<glz::tuple<T...>> : std::integral_constant<size_t, sizeof...(T)>
    {};
 
    template <size_t I, class... T>
-   struct tuple_element<I, glz::tuplet::tuple<T...>>
-   {
-      using type = decltype(glz::tuplet::tuple<T...>::decl_elem(glz::tuplet::tag<I>()));
-   };
-
-   template <class A, class B>
-   struct tuple_size<glz::tuplet::pair<A, B>> : std::integral_constant<size_t, 2>
-   {};
-
-   template <size_t I, class A, class B>
-   struct tuple_element<I, glz::tuplet::pair<A, B>>
+   struct tuple_element<I, glz::tuple<T...>>
    {
-      static_assert(I < 2, "tuplet::pair only has 2 elements");
-      using type = std::conditional_t<I == 0, A, B>;
+      using type = decltype(glz::tuple<T...>::decl_elem(glz::tuplet::tag<I>()));
    };
 }
diff --git a/deps/saucer/include/glaze/util/any.hpp b/deps/saucer/include/glaze/util/any.hpp
deleted file mode 100644
index 1a42a03..0000000
--- a/deps/saucer/include/glaze/util/any.hpp
+++ /dev/null
@@ -1,237 +0,0 @@
-// Glaze Library
-// For the license information refer to glaze.hpp
-
-#pragma once
-
-// originally from: https://codereview.stackexchange.com/questions/219075/implementation-of-stdany
-
-#include <concepts>
-#include <memory>
-#include <utility>
-
-#include "glaze/api/trait.hpp"
-
-namespace glz
-{
-   template <class T>
-   struct is_in_place_type_t : std::false_type
-   {};
-
-   template <class T>
-   struct is_in_place_type_t<std::in_place_type_t<T>> : std::true_type
-   {};
-
-   template <class T>
-   concept is_in_place_type = is_in_place_type_t<T>::value;
-
-   template <class T, class List, class... Args>
-   concept init_list_constructible = std::constructible_from<std::decay_t<T>, std::initializer_list<List>&, Args...>;
-
-   template <class T>
-   concept copy_constructible = std::copy_constructible<std::decay_t<T>>;
-
-   struct any
-   {
-      constexpr any() noexcept = default;
-      ~any() = default;
-
-      any(const any& other)
-      {
-         if (other.instance) {
-            instance = other.instance->clone();
-         }
-      }
-
-      any(any&& other) noexcept : instance(std::move(other.instance)) {}
-
-      template <class T>
-         requires(!std::same_as<std::decay_t<T>, any> && !is_in_place_type<T> && copy_constructible<T>)
-      any(T&& value)
-      {
-         emplace<std::decay_t<T>>(std::forward<T>(value));
-      }
-
-      template <class T, class... Args>
-         requires(std::constructible_from<std::decay_t<T>, Args...> && copy_constructible<T>)
-      explicit any(std::in_place_type_t<T>, Args&&... args)
-      {
-         emplace<std::decay_t<T>>(std::forward<Args>(args)...);
-      }
-
-      template <class T, class List, class... Args>
-         requires(init_list_constructible<T, List, Args...> && copy_constructible<T>)
-      explicit any(std::in_place_type_t<T>, std::initializer_list<List> list, Args&&... args)
-      {
-         emplace<std::decay_t<T>>(list, std::forward<Args>(args)...);
-      }
-
-      any& operator=(const any& rhs)
-      {
-         any(rhs).swap(*this);
-         return *this;
-      }
-
-      any& operator=(any&& rhs) noexcept
-      {
-         std::move(rhs).swap(*this);
-         return *this;
-      }
-
-      template <class T>
-         requires(!std::is_same_v<std::decay_t<T>, any> && copy_constructible<T>)
-      any& operator=(T&& rhs)
-      {
-         any(std::forward<T>(rhs)).swap(*this);
-         return *this;
-      }
-
-      template <class T, class... Args>
-         requires(std::constructible_from<std::decay_t<T>, Args...> && copy_constructible<T>)
-      std::decay_t<T>& emplace(Args&&... args)
-      {
-         using D = std::decay_t<T>;
-         auto new_inst = std::make_unique<storage_impl<D>>(std::forward<Args>(args)...);
-         D& value = new_inst->value;
-         instance = std::move(new_inst);
-         return value;
-      }
-
-      template <class T, class List, class... Args>
-         requires(init_list_constructible<T, List, Args...> && copy_constructible<T>)
-      std::decay_t<T>& emplace(std::initializer_list<List> list, Args&&... args)
-      {
-         using D = std::decay_t<T>;
-         auto new_inst = std::make_unique<storage_impl<D>>(list, std::forward<Args>(args)...);
-         D& value = new_inst->value;
-         instance = std::move(new_inst);
-         return value;
-      }
-
-      void reset() noexcept { instance.reset(); }
-
-      void* data() { return instance->data(); }
-
-      void swap(any& other) noexcept { std::swap(instance, other.instance); }
-
-      bool has_value() const noexcept { return bool(instance); }
-
-      friend void swap(any& lhs, any& rhs) { lhs.swap(rhs); }
-
-     private:
-      template <class T>
-      friend const T* any_cast(const any*) noexcept;
-
-      template <class T>
-      friend T* any_cast(any*) noexcept;
-
-      struct storage_base
-      {
-         virtual ~storage_base() = default;
-
-         virtual std::unique_ptr<storage_base> clone() const = 0;
-         virtual void* data() noexcept = 0;
-         glz::hash_t type_hash;
-      };
-
-      std::unique_ptr<storage_base> instance;
-
-      template <class T>
-      struct storage_impl final : storage_base
-      {
-         template <class... Args>
-         storage_impl(Args&&... args) : value(std::forward<Args>(args)...)
-         {
-            type_hash = hash<T>();
-         }
-
-         std::unique_ptr<storage_base> clone() const override { return std::make_unique<storage_impl<T>>(value); }
-
-         void* data() noexcept override
-         {
-            if constexpr (std::is_pointer_v<T>) {
-               return value;
-            }
-            else {
-               return &value;
-            }
-         }
-
-         T value;
-      };
-   };
-
-   // C++20
-   template <class T>
-   using remove_cvref_t = std::remove_cv_t<std::remove_reference_t<T>>;
-
-   template <class T>
-      requires(std::constructible_from<T, const remove_cvref_t<T>&>)
-   T any_cast(const any& a)
-   {
-      using V = remove_cvref_t<T>;
-      if (auto* value = any_cast<V>(&a)) {
-         return static_cast<T>(*value);
-      }
-      else {
-         std::abort();
-      }
-   }
-
-   template <class T>
-      requires(std::constructible_from<T, remove_cvref_t<T>&>)
-   T any_cast(any& a)
-   {
-      using V = remove_cvref_t<T>;
-      if (auto* value = any_cast<V>(&a)) {
-         return static_cast<T>(*value);
-      }
-      else {
-         std::abort();
-      }
-   }
-
-   template <class T>
-      requires(std::constructible_from<T, remove_cvref_t<T>>)
-   T any_cast(any&& a)
-   {
-      using V = remove_cvref_t<T>;
-      if (auto* value = any_cast<V>(&a)) {
-         return static_cast<T>(std::move(*value));
-      }
-      else {
-         std::abort();
-      }
-   }
-
-   template <class T>
-   const T* any_cast(const any* a) noexcept
-   {
-      if (!a) {
-         return nullptr;
-      }
-      static constexpr auto h = hash<T>();
-
-      if (h == a->instance->type_hash) [[likely]] {
-         return &(reinterpret_cast<any::storage_impl<T>*>(a->instance.get())->value);
-      }
-      return nullptr;
-   }
-
-   template <class T>
-   T* any_cast(any* a) noexcept
-   {
-      return const_cast<T*>(any_cast<T>(static_cast<const any*>(a)));
-   }
-
-   template <class T, class... Args>
-   any make_any(Args&&... args)
-   {
-      return any(std::in_place_type<T>, std::forward<Args>(args)...);
-   }
-
-   template <class T, class List, class... Args>
-   any make_any(std::initializer_list<List> list, Args&&... args)
-   {
-      return any(std::in_place_type<T>, list, std::forward<Args>(args)...);
-   }
-}
diff --git a/deps/saucer/include/glaze/util/atoi.hpp b/deps/saucer/include/glaze/util/atoi.hpp
new file mode 100644
index 0000000..6277884
--- /dev/null
+++ b/deps/saucer/include/glaze/util/atoi.hpp
@@ -0,0 +1,946 @@
+#pragma once
+
+#include <array>
+#include <bit>
+#include <cmath>
+#include <cstdint>
+#include <cstring>
+#include <iterator>
+
+#include "glaze/util/for_each.hpp"
+#include "glaze/util/inline.hpp"
+#include "glaze/util/type_traits.hpp"
+
+// Characters to integer parsing
+
+// - We don't allow decimals in integer parsing
+// - We don't allow negative exponents
+// Thse cases can produce fractions which slow performance and add confusion
+// as to how the integer ought to be parsed (truncation, rounding, etc.)
+// This integer parsing is designed to be straightfoward and fast
+// Values like 1e6 are allowed because it enables less typing from the user
+// and has a clear integer value
+
+// Valid JSON integer examples
+// 1234
+// 1234e1
+// 1e9
+
+// Invalid for this atoi algorithm
+// 1.234
+// 1234e-1
+// 0.0
+
+// The standard JSON specification for numbers and the associated rules apply
+
+// *** We ensure that a decimal value being parsed will result in an error
+// 1.2 should not produce 1, but rather an error, even when a single field is parsed
+// This ensures that we get proper errors when parsing and don't get confusing errors
+// It isn't technically required, because end validation would handle it, but it produces
+// much clearer errors, especially when we don't perform trailing validation.
+
+#ifdef _MSC_VER
+// Turn off MSVC warning for possible loss of data: we are intentionally allowing well defined unsigned integer
+// overflows
+#pragma warning(push)
+#pragma warning(disable : 4244)
+#endif
+
+namespace glz
+{
+   inline constexpr std::array<uint64_t, 20> powers_of_ten_int{1ull,
+                                                               10ull,
+                                                               100ull,
+                                                               1000ull,
+                                                               10000ull,
+                                                               100000ull,
+                                                               1000000ull,
+                                                               10000000ull,
+                                                               100000000ull,
+                                                               1000000000ull,
+                                                               10000000000ull,
+                                                               100000000000ull,
+                                                               1000000000000ull,
+                                                               10000000000000ull,
+                                                               100000000000000ull,
+                                                               1000000000000000ull,
+                                                               10000000000000000ull,
+                                                               100000000000000000ull,
+                                                               1000000000000000000ull,
+                                                               10000000000000000000ull};
+
+   inline constexpr std::array<bool, 256> exp_dec_table = [] {
+      std::array<bool, 256> t{};
+      t['.'] = true;
+      t['E'] = true;
+      t['e'] = true;
+      return t;
+   }();
+
+   inline constexpr std::array<bool, 256> non_exp_table = [] {
+      std::array<bool, 256> t{};
+      t.fill(true);
+      t['E'] = false;
+      t['e'] = false;
+      return t;
+   }();
+
+   inline constexpr std::array<bool, 256> digit_table = [] {
+      std::array<bool, 256> t{};
+      t['0'] = true;
+      t['1'] = true;
+      t['2'] = true;
+      t['3'] = true;
+      t['4'] = true;
+      t['5'] = true;
+      t['6'] = true;
+      t['7'] = true;
+      t['8'] = true;
+      t['9'] = true;
+      return t;
+   }();
+
+   template <class T>
+   inline constexpr std::array<uint64_t, 256> peak_positive = [] {
+      constexpr auto peak{(std::numeric_limits<std::decay_t<T>>::max)()};
+      std::array<uint64_t, 256> t{};
+      t['0'] = (peak - 0) / 10;
+      t['1'] = (peak - 1) / 10;
+      t['2'] = (peak - 2) / 10;
+      t['3'] = (peak - 3) / 10;
+      t['4'] = (peak - 4) / 10;
+      t['5'] = (peak - 5) / 10;
+      t['6'] = (peak - 6) / 10;
+      t['7'] = (peak - 7) / 10;
+      t['8'] = (peak - 8) / 10;
+      t['9'] = (peak - 9) / 10;
+      return t;
+   }();
+
+   template <class T>
+   inline constexpr std::array<uint64_t, 256> peak_negative = [] {
+      constexpr auto peak{uint64_t((std::numeric_limits<std::decay_t<T>>::max)()) + 1};
+      std::array<uint64_t, 256> t{};
+      t['0'] = (peak - 0) / 10;
+      t['1'] = (peak - 1) / 10;
+      t['2'] = (peak - 2) / 10;
+      t['3'] = (peak - 3) / 10;
+      t['4'] = (peak - 4) / 10;
+      t['5'] = (peak - 5) / 10;
+      t['6'] = (peak - 6) / 10;
+      t['7'] = (peak - 7) / 10;
+      t['8'] = (peak - 8) / 10;
+      t['9'] = (peak - 9) / 10;
+      return t;
+   }();
+
+   GLZ_ALWAYS_INLINE constexpr bool is_digit(const uint8_t c) noexcept { return c <= '9' && c >= '0'; }
+
+   struct value128 final
+   {
+      uint64_t low;
+      uint64_t high;
+   };
+
+   // slow emulation routine for 32-bit
+   GLZ_ALWAYS_INLINE constexpr uint64_t emulu(uint32_t x, uint32_t y) { return x * (uint64_t)y; }
+
+   GLZ_ALWAYS_INLINE constexpr uint64_t umul128_generic(uint64_t ab, uint64_t cd, uint64_t* hi)
+   {
+      uint64_t ad = emulu((uint32_t)(ab >> 32), (uint32_t)cd);
+      uint64_t bd = emulu((uint32_t)ab, (uint32_t)cd);
+      uint64_t adbc = ad + emulu((uint32_t)ab, (uint32_t)(cd >> 32));
+      uint64_t adbc_carry = (uint64_t)(adbc < ad);
+      uint64_t lo = bd + (adbc << 32);
+      *hi = emulu((uint32_t)(ab >> 32), (uint32_t)(cd >> 32)) + (adbc >> 32) + (adbc_carry << 32) + (uint64_t)(lo < bd);
+      return lo;
+   }
+
+   // compute 64-bit a*b
+   GLZ_ALWAYS_INLINE constexpr value128 full_multiplication(uint64_t a, uint64_t b)
+   {
+      if (std::is_constant_evaluated()) {
+         value128 answer;
+         answer.low = umul128_generic(a, b, &answer.high);
+         return answer;
+      }
+      value128 answer;
+#if defined(_M_ARM64) && !defined(__MINGW32__)
+      // ARM64 has native support for 64-bit multiplications, no need to emulate
+      // But MinGW on ARM64 doesn't have native support for 64-bit multiplications
+      answer.high = __umulh(a, b);
+      answer.low = a * b;
+#elif defined(GLZ_FASTFLOAT_32BIT) || (defined(_WIN64) && !defined(__clang__) && !defined(__MINGW32__))
+      answer.low = _umul128(a, b, &answer.high); // _umul128 not available on ARM64
+#elif defined(GLZ_FASTFLOAT_64BIT) && defined(__SIZEOF_INT128__)
+      __uint128_t r = ((__uint128_t)a) * b;
+      answer.low = uint64_t(r);
+      answer.high = uint64_t(r >> 64);
+#else
+      answer.low = umul128_generic(a, b, &answer.high);
+#endif
+      return answer;
+   }
+
+   template <std::integral T>
+      requires(std::is_unsigned_v<T> && (sizeof(T) <= 8))
+   GLZ_ALWAYS_INLINE constexpr const uint8_t* parse_int(T& v, const uint8_t* c) noexcept
+   {
+      if (is_digit(*c)) [[likely]] {
+         v = *c - '0';
+         ++c;
+      }
+      else [[unlikely]] {
+         return {};
+      }
+
+      if (is_digit(*c)) {
+         v = v * 10 + (*c - '0');
+         ++c;
+      }
+      else {
+         return c;
+      }
+
+      if (c[-2] == '0') [[unlikely]] {
+         return {};
+      }
+
+      if constexpr (sizeof(T) > 1) {
+         if (is_digit(*c)) {
+            v = v * 10 + (*c - '0');
+            ++c;
+         }
+         else {
+            return c;
+         }
+
+         if (is_digit(*c)) {
+            v = v * 10 + (*c - '0');
+            ++c;
+         }
+         else {
+            return c;
+         }
+
+         if constexpr (sizeof(T) > 2) {
+            if (is_digit(*c)) {
+               v = v * 10 + (*c - '0');
+               ++c;
+            }
+            else {
+               return c;
+            }
+
+            if (is_digit(*c)) {
+               v = v * 10 + (*c - '0');
+               ++c;
+            }
+            else {
+               return c;
+            }
+
+            if (is_digit(*c)) {
+               v = v * 10 + (*c - '0');
+               ++c;
+            }
+            else {
+               return c;
+            }
+
+            if (is_digit(*c)) {
+               v = v * 10 + (*c - '0');
+               ++c;
+            }
+            else {
+               return c;
+            }
+
+            if (is_digit(*c)) {
+               v = v * 10 + (*c - '0');
+               ++c;
+            }
+            else {
+               return c;
+            }
+
+            if constexpr (sizeof(T) > 4) {
+               if (is_digit(*c)) {
+                  v = v * 10 + (*c - '0');
+                  ++c;
+               }
+               else {
+                  return c;
+               }
+
+               if (is_digit(*c)) {
+                  v = v * 10 + (*c - '0');
+                  ++c;
+               }
+               else {
+                  return c;
+               }
+
+               if (is_digit(*c)) {
+                  v = v * 10 + (*c - '0');
+                  ++c;
+               }
+               else {
+                  return c;
+               }
+
+               if (is_digit(*c)) {
+                  v = v * 10 + (*c - '0');
+                  ++c;
+               }
+               else {
+                  return c;
+               }
+
+               if (is_digit(*c)) {
+                  v = v * 10 + (*c - '0');
+                  ++c;
+               }
+               else {
+                  return c;
+               }
+
+               if (is_digit(*c)) {
+                  v = v * 10 + (*c - '0');
+                  ++c;
+               }
+               else {
+                  return c;
+               }
+
+               if (is_digit(*c)) {
+                  v = v * 10 + (*c - '0');
+                  ++c;
+               }
+               else {
+                  return c;
+               }
+
+               if (is_digit(*c)) {
+                  v = v * 10 + (*c - '0');
+                  ++c;
+               }
+               else {
+                  return c;
+               }
+
+               if (is_digit(*c)) {
+                  v = v * 10 + (*c - '0');
+                  ++c;
+               }
+               else {
+                  return c;
+               }
+
+               if (is_digit(*c)) {
+                  v = v * 10 + (*c - '0');
+                  ++c;
+               }
+               else {
+                  return c;
+               }
+            }
+         }
+      }
+
+      if (is_digit(*c)) {
+         v = v * 10 + (*c - '0');
+         constexpr auto split = (std::numeric_limits<T>::max)() / 10 - 10;
+         if (v < split) [[unlikely]] {
+            // due to overflow
+            return {};
+         }
+         ++c;
+         if (is_digit(*c)) [[unlikely]] {
+            return {};
+         }
+      }
+
+      return c;
+   }
+
+   template <std::integral T, class Char>
+      requires(std::is_unsigned_v<T>)
+   GLZ_ALWAYS_INLINE constexpr bool atoi(T& v, Char*& c) noexcept
+   {
+      if (auto ptr = parse_int(v, reinterpret_cast<const uint8_t*>(c))) [[likely]] {
+         c = reinterpret_cast<const Char*>(ptr);
+         if (*c == 'e' || *c == 'E') {
+            ++c;
+         }
+         else {
+            if (*c == '.') [[unlikely]] {
+               return false;
+            }
+            return true;
+         }
+
+         c += (*c == '+');
+
+         if (not is_digit(*c)) [[unlikely]] {
+            return false;
+         }
+         ++c;
+         uint8_t exp = c[-1] - '0';
+         if (is_digit(*c)) {
+            exp = exp * 10 + (*c - '0');
+            ++c;
+         }
+         if (is_digit(*c)) {
+            exp = exp * 10 + (*c - '0');
+            ++c;
+         }
+         if constexpr (sizeof(T) == 1) {
+            if (exp > 2) [[unlikely]] {
+               return false;
+            }
+         }
+         else if constexpr (sizeof(T) == 2) {
+            if (exp > 4) [[unlikely]] {
+               return false;
+            }
+         }
+         else if constexpr (sizeof(T) == 4) {
+            if (exp > 9) [[unlikely]] {
+               return false;
+            }
+         }
+         else {
+            if (exp > 19) [[unlikely]] {
+               return false;
+            }
+         }
+
+         if constexpr (sizeof(T) == 1) {
+            static constexpr std::array<uint8_t, 3> powers_of_ten{1, 10, 100};
+            const uint64_t i = v * powers_of_ten[exp];
+            v = T(i);
+            return i <= (std::numeric_limits<T>::max)();
+         }
+         else if constexpr (sizeof(T) == 2) {
+            static constexpr std::array<uint16_t, 5> powers_of_ten{1, 10, 100, 1000, 10000};
+            const uint64_t i = v * powers_of_ten[exp];
+            v = T(i);
+            return i <= (std::numeric_limits<T>::max)();
+         }
+         else if constexpr (sizeof(T) < 8) {
+            const uint64_t i = v * powers_of_ten_int[exp];
+            v = T(i);
+            return i <= (std::numeric_limits<T>::max)();
+         }
+         else {
+#if defined(__SIZEOF_INT128__)
+            const __uint128_t res = __uint128_t(v) * powers_of_ten_int[exp];
+            v = T(res);
+            return res <= (std::numeric_limits<T>::max)();
+#else
+            const auto res = full_multiplication(v, powers_of_ten_int[exp]);
+            v = T(res.low);
+            return res.high == 0;
+#endif
+         }
+      }
+      return false;
+   }
+
+   template <std::integral T>
+      requires(std::is_signed_v<T> && (sizeof(T) <= 8))
+   GLZ_ALWAYS_INLINE constexpr const uint8_t* parse_int(T& v, const uint8_t* c) noexcept
+   {
+      const uint8_t sign = *c == '-';
+      c += sign;
+
+      if (is_digit(*c)) [[likely]] {
+         v = *c - '0';
+         ++c;
+      }
+      else [[unlikely]] {
+         return {};
+      }
+
+      if (is_digit(*c)) {
+         v = v * 10 + (*c - '0');
+         ++c;
+      }
+      else {
+         if (sign) {
+            v = -v;
+         }
+         return c;
+      }
+
+      if (c[-2] == '0') [[unlikely]] {
+         return {};
+      }
+
+      if constexpr (sizeof(T) > 1) {
+         if (is_digit(*c)) {
+            v = v * 10 + (*c - '0');
+            ++c;
+         }
+         else {
+            if (sign) {
+               v = -v;
+            }
+            return c;
+         }
+
+         if (is_digit(*c)) {
+            v = v * 10 + (*c - '0');
+            ++c;
+         }
+         else {
+            if (sign) {
+               v = -v;
+            }
+            return c;
+         }
+
+         if constexpr (sizeof(T) > 2) {
+            if (is_digit(*c)) {
+               v = v * 10 + (*c - '0');
+               ++c;
+            }
+            else {
+               if (sign) {
+                  v = -v;
+               }
+               return c;
+            }
+
+            if (is_digit(*c)) {
+               v = v * 10 + (*c - '0');
+               ++c;
+            }
+            else {
+               if (sign) {
+                  v = -v;
+               }
+               return c;
+            }
+
+            if (is_digit(*c)) {
+               v = v * 10 + (*c - '0');
+               ++c;
+            }
+            else {
+               if (sign) {
+                  v = -v;
+               }
+               return c;
+            }
+
+            if (is_digit(*c)) {
+               v = v * 10 + (*c - '0');
+               ++c;
+            }
+            else {
+               if (sign) {
+                  v = -v;
+               }
+               return c;
+            }
+
+            if (is_digit(*c)) {
+               v = v * 10 + (*c - '0');
+               ++c;
+            }
+            else {
+               if (sign) {
+                  v = -v;
+               }
+               return c;
+            }
+
+            if constexpr (sizeof(T) > 4) {
+               if (is_digit(*c)) {
+                  v = v * 10 + (*c - '0');
+                  ++c;
+               }
+               else {
+                  if (sign) {
+                     v = -v;
+                  }
+                  return c;
+               }
+
+               if (is_digit(*c)) {
+                  v = v * 10 + (*c - '0');
+                  ++c;
+               }
+               else {
+                  if (sign) {
+                     v = -v;
+                  }
+                  return c;
+               }
+
+               if (is_digit(*c)) {
+                  v = v * 10 + (*c - '0');
+                  ++c;
+               }
+               else {
+                  if (sign) {
+                     v = -v;
+                  }
+                  return c;
+               }
+
+               if (is_digit(*c)) {
+                  v = v * 10 + (*c - '0');
+                  ++c;
+               }
+               else {
+                  if (sign) {
+                     v = -v;
+                  }
+                  return c;
+               }
+
+               if (is_digit(*c)) {
+                  v = v * 10 + (*c - '0');
+                  ++c;
+               }
+               else {
+                  if (sign) {
+                     v = -v;
+                  }
+                  return c;
+               }
+
+               if (is_digit(*c)) {
+                  v = v * 10 + (*c - '0');
+                  ++c;
+               }
+               else {
+                  if (sign) {
+                     v = -v;
+                  }
+                  return c;
+               }
+
+               if (is_digit(*c)) {
+                  v = v * 10 + (*c - '0');
+                  ++c;
+               }
+               else {
+                  if (sign) {
+                     v = -v;
+                  }
+                  return c;
+               }
+
+               if (is_digit(*c)) {
+                  v = v * 10 + (*c - '0');
+                  ++c;
+               }
+               else {
+                  if (sign) {
+                     v = -v;
+                  }
+                  return c;
+               }
+
+               if (is_digit(*c)) {
+                  v = v * 10 + (*c - '0');
+                  ++c;
+               }
+               else {
+                  if (sign) {
+                     v = -v;
+                  }
+                  return c;
+               }
+            }
+         }
+      }
+
+      if (is_digit(*c)) {
+         if (sign) {
+            if (v > T(peak_negative<T>[*c])) [[unlikely]] {
+               return {};
+            }
+            v = -1 * v;
+            v = v * 10 - (*c - '0');
+         }
+         else {
+            if (v > T(peak_positive<T>[*c])) [[unlikely]] {
+               return {};
+            }
+            v = v * 10 + (*c - '0');
+         }
+         ++c;
+         if (is_digit(*c)) [[unlikely]] {
+            return {};
+         }
+         return c;
+      }
+
+      if (sign) {
+         v = -v;
+      }
+      return c;
+   }
+
+   template <std::integral T, class Char>
+      requires(std::is_signed_v<T>)
+   GLZ_ALWAYS_INLINE constexpr bool atoi(T& v, Char*& c) noexcept
+   {
+      using X = std::decay_t<T>;
+      using utype = std::make_unsigned_t<X>;
+
+      const uint8_t sign = *c == '-';
+      if (auto ptr = parse_int(v, reinterpret_cast<const uint8_t*>(c))) [[likely]] {
+         c = reinterpret_cast<const Char*>(ptr);
+         if (*c == 'e' || *c == 'E') {
+            ++c;
+         }
+         else {
+            if (*c == '.') [[unlikely]] {
+               return false;
+            }
+            return true;
+         }
+
+         c += (*c == '+');
+
+         if (not is_digit(*c)) [[unlikely]] {
+            return false;
+         }
+         ++c;
+         uint8_t exp = c[-1] - '0';
+         if (is_digit(*c)) {
+            exp = exp * 10 + (*c - '0');
+            ++c;
+         }
+         if constexpr (sizeof(T) == 1) {
+            if (exp > 2) [[unlikely]] {
+               return false;
+            }
+         }
+         else if constexpr (sizeof(T) == 2) {
+            if (exp > 4) [[unlikely]] {
+               return false;
+            }
+         }
+         else if constexpr (sizeof(T) == 4) {
+            if (exp > 9) [[unlikely]] {
+               return false;
+            }
+         }
+         else {
+            if (exp > 18) [[unlikely]] {
+               return false;
+            }
+         }
+
+         utype i = utype((utype(v) ^ -sign) + sign);
+         if constexpr (sizeof(T) == 1) {
+            static constexpr std::array<utype, 3> powers_of_ten{1, 10, 100};
+            i *= powers_of_ten[exp];
+            v = T((utype(i) ^ -sign) + sign);
+            return (i - sign) <= static_cast<utype>((std::numeric_limits<T>::max)());
+         }
+         else if constexpr (sizeof(T) == 2) {
+            static constexpr std::array<utype, 5> powers_of_ten{1, 10, 100, 1000, 10000};
+            i *= powers_of_ten[exp];
+            v = T((utype(i) ^ -sign) + sign);
+            return (i - sign) <= static_cast<utype>((std::numeric_limits<T>::max)());
+         }
+         else if constexpr (sizeof(T) == 4) {
+            i *= powers_of_ten_int[exp];
+            v = T((utype(i) ^ -sign) + sign);
+            return (i - sign) <= static_cast<utype>((std::numeric_limits<T>::max)());
+         }
+         else {
+#if defined(__SIZEOF_INT128__)
+            const __uint128_t res = __uint128_t(reinterpret_cast<utype&>(v)) * powers_of_ten_int[exp];
+            v = T((uint64_t(res) ^ -sign) + sign);
+            return uint64_t(res) <= (9223372036854775807ull + sign);
+#else
+            const auto res = full_multiplication(reinterpret_cast<utype&>(v), powers_of_ten_int[exp]);
+            v = T((uint64_t(res.low) ^ -sign) + sign);
+            return res.high == 0 && (uint64_t(res.low) <= (9223372036854775807ull + sign));
+#endif
+         }
+      }
+      return false;
+   }
+
+   // Increase by 8 to support exponentials
+   inline constexpr std::array<size_t, 4> int_buffer_lengths{16, 16, 24, 32};
+
+   template <std::integral T, class Char>
+   GLZ_ALWAYS_INLINE constexpr bool atoi(T& v, const Char*& it, const Char* end) noexcept
+   {
+      // The number of characters needed at most for each type, rounded to nearest 8 bytes
+      constexpr auto buffer_length = int_buffer_lengths[std::bit_width(sizeof(T)) - 1];
+      // We copy the rest of the buffer or 64 bytes into a null terminated buffer
+      std::array<char, buffer_length> data{};
+      const auto n = size_t(end - it);
+      if (n > 0) [[likely]] {
+         if (n < buffer_length) {
+            std::memcpy(data.data(), it, n);
+         }
+         else {
+            std::memcpy(data.data(), it, buffer_length);
+         }
+
+         const auto start = data.data();
+         const auto* c = start;
+         const auto valid = glz::atoi(v, c);
+         it += size_t(c - start);
+         return valid;
+      }
+      else [[unlikely]] {
+         return false;
+      }
+   }
+}
+
+namespace glz::detail
+{
+   GLZ_ALWAYS_INLINE constexpr bool is_safe_addition(uint64_t a, uint64_t b) noexcept
+   {
+      return a <= (std::numeric_limits<uint64_t>::max)() - b;
+   }
+
+   GLZ_ALWAYS_INLINE constexpr bool is_safe_multiplication10(uint64_t a) noexcept
+   {
+      constexpr auto b = (std::numeric_limits<uint64_t>::max)() / 10;
+      return a <= b;
+   }
+
+   template <class T = uint64_t>
+   GLZ_ALWAYS_INLINE constexpr bool stoui64(uint64_t& res, const char*& c) noexcept
+   {
+      if (!digit_table[uint8_t(*c)]) [[unlikely]] {
+         return false;
+      }
+
+      // maximum number of digits need is: 3, 5, 10, 20, for byte sizes of 1, 2, 4, 8
+      // we need to store one extra space for a digit for sizes of 1, 2, and 4 because we avoid checking for overflow
+      // since we store in a uint64_t
+      constexpr std::array<int64_t, 4> max_digits_from_size = {4, 6, 11, 20};
+      constexpr auto N = max_digits_from_size[std::bit_width(sizeof(T)) - 1];
+
+      std::array<uint8_t, N> digits{0};
+      auto next_digit = digits.begin();
+      auto consume_digit = [&c, &next_digit, &digits]() {
+         if (next_digit < digits.cend()) [[likely]] {
+            *next_digit = (*c - '0');
+            ++next_digit;
+         }
+         ++c;
+      };
+
+      if (*c == '0') {
+         // digits[i] = 0; already set to zero
+         ++c;
+         ++next_digit;
+
+         if (*c == '0') [[unlikely]] {
+            return false;
+         }
+      }
+
+      while (digit_table[uint8_t(*c)]) {
+         consume_digit();
+      }
+      auto n = int64_t(std::distance(digits.begin(), next_digit));
+
+      if (*c == '.') {
+         ++c;
+         while (digit_table[uint8_t(*c)]) {
+            consume_digit();
+         }
+      }
+
+      if (*c == 'e' || *c == 'E') {
+         ++c;
+
+         bool negative = false;
+         if (*c == '+' || *c == '-') {
+            negative = (*c == '-');
+            ++c;
+         }
+         uint8_t exp = 0;
+         while (digit_table[uint8_t(*c)] && exp < 128) {
+            exp = 10 * exp + (*c - '0');
+            ++c;
+         }
+         n += negative ? -exp : exp;
+      }
+
+      res = 0;
+      if (n < 0) [[unlikely]] {
+         return true;
+      }
+
+      if constexpr (std::same_as<T, uint64_t>) {
+         if (n > 20) [[unlikely]] {
+            return false;
+         }
+
+         if (n == 20) [[unlikely]] {
+            for (size_t k = 0; k < 19; ++k) {
+               res = 10 * res + digits[k];
+            }
+
+            if (is_safe_multiplication10(res)) [[likely]] {
+               res *= 10;
+            }
+            else [[unlikely]] {
+               return false;
+            }
+            if (is_safe_addition(res, digits.back())) [[likely]] {
+               res += digits.back();
+            }
+            else [[unlikely]] {
+               return false;
+            }
+         }
+         else [[likely]] {
+            for (int64_t k = 0; k < n; ++k) {
+               res = 10 * res + digits[k];
+            }
+         }
+      }
+      else {
+         // a value of n == N would result in reading digits[N], which is invalid
+         if (n >= N) [[unlikely]] {
+            return false;
+         }
+         else [[likely]] {
+            for (int64_t k = 0; k < n; ++k) {
+               res = 10 * res + digits[k];
+            }
+         }
+      }
+
+      return true;
+   }
+
+   template <class T = uint64_t>
+   GLZ_ALWAYS_INLINE constexpr bool stoui64(uint64_t& res, auto& it) noexcept
+   {
+      static_assert(sizeof(*it) == sizeof(char));
+      const char* cur = reinterpret_cast<const char*>(it);
+      const char* beg = cur;
+      if (stoui64(res, cur)) {
+         it += (cur - beg);
+         return true;
+      }
+      return false;
+   }
+}
+
+#ifdef _MSC_VER
+// restore disabled warnings
+#pragma warning(pop)
+#endif
diff --git a/deps/saucer/include/glaze/util/bit_array.hpp b/deps/saucer/include/glaze/util/bit_array.hpp
index 972d2fc..aa8214e 100644
--- a/deps/saucer/include/glaze/util/bit_array.hpp
+++ b/deps/saucer/include/glaze/util/bit_array.hpp
@@ -7,19 +7,19 @@
 #include <bit>
 #include <limits>
 
-namespace glz::detail
+namespace glz
 {
    // Basicly std::bitset but exposes things normally not availible like the bitscan functions
-   template <size_t N, std::unsigned_integral Chunk_t = uint64_t>
+   template <size_t N, std::unsigned_integral Chunk = uint64_t>
    struct bit_array
    {
-      static constexpr size_t n_chunk_bits = std::numeric_limits<Chunk_t>::digits;
+      static constexpr size_t n_chunk_bits = std::numeric_limits<Chunk>::digits;
       static constexpr size_t n_chunks = (N == 0) ? 0 : (N - 1) / n_chunk_bits + 1;
 
       struct reference
       {
-         Chunk_t* data{};
-         Chunk_t maskbit{};
+         Chunk* data{};
+         Chunk maskbit{};
 
          constexpr reference& operator=(bool other) noexcept
          {
@@ -35,13 +35,13 @@ namespace glz::detail
          constexpr bool operator~() const noexcept { return (*data & maskbit) == 0; }
       };
 
-      std::array<Chunk_t, n_chunks> data{};
+      std::array<Chunk, n_chunks> data{};
 
       constexpr reference operator[](size_t pos)
       {
          const auto chunk = pos / n_chunk_bits;
          const auto offset = pos % n_chunk_bits;
-         const auto maskbit = Chunk_t{1} << offset;
+         const auto maskbit = Chunk{1} << offset;
          return reference{&data[chunk], maskbit};
       }
 
@@ -49,7 +49,7 @@ namespace glz::detail
       {
          const auto chunk = pos / n_chunk_bits;
          const auto offset = pos % n_chunk_bits;
-         const auto maskbit = Chunk_t{1} << offset;
+         const auto maskbit = Chunk{1} << offset;
          return data[chunk] & maskbit;
       }
 
diff --git a/deps/saucer/include/glaze/util/comment.hpp b/deps/saucer/include/glaze/util/comment.hpp
deleted file mode 100644
index d71b00a..0000000
--- a/deps/saucer/include/glaze/util/comment.hpp
+++ /dev/null
@@ -1,19 +0,0 @@
-// Glaze Library
-// For the license information refer to glaze.hpp
-
-#pragma once
-
-#include <string_view>
-
-namespace glz
-{
-   struct comment final
-   {
-      std::string_view value{};
-
-      constexpr comment(const char* str) noexcept : value(str) {}
-      constexpr comment(const char* str, size_t n) noexcept : value(str, n) {}
-   };
-
-   constexpr comment operator""_c(const char* data, size_t n) noexcept { return {data, n}; }
-}
diff --git a/deps/saucer/include/glaze/util/compare.hpp b/deps/saucer/include/glaze/util/compare.hpp
index 6e04f58..4b869e7 100644
--- a/deps/saucer/include/glaze/util/compare.hpp
+++ b/deps/saucer/include/glaze/util/compare.hpp
@@ -97,47 +97,185 @@ namespace glz
    }
 
    template <uint64_t Count, class Char>
-   inline bool compare(const Char* lhs, const Char* rhs) noexcept
+   GLZ_ALWAYS_INLINE bool compare(const Char* lhs, const Char* rhs) noexcept
    {
       if constexpr (Count > 8) {
-         return internal_compare(lhs, rhs, Count);
+         return 0 == std::memcmp(lhs, rhs, Count);
+         // return internal_compare(lhs, rhs, Count);
       }
       else if constexpr (Count == 8) {
-         uint64_t v[2];
-         std::memcpy(v, lhs, Count);
-         std::memcpy(v + 1, rhs, Count);
-         return v[0] == v[1];
+         uint64_t l, r;
+         std::memcpy(&l, lhs, 8);
+         std::memcpy(&r, rhs, 8);
+         return l == r;
       }
-      else if constexpr (Count > 4) {
-         uint64_t v[2]{}; // must default initialize
-         std::memcpy(v, lhs, Count);
-         std::memcpy(v + 1, rhs, Count);
-         return v[0] == v[1];
+      else if constexpr (Count == 7) {
+         uint32_t l, r;
+         std::memcpy(&l, lhs, 4);
+         std::memcpy(&r, rhs, 4);
+         uint32_t l2, r2;
+         std::memcpy(&l2, lhs + 3, 4);
+         std::memcpy(&r2, rhs + 3, 4);
+         return (l == r) & (l2 == r2);
+      }
+      else if constexpr (Count == 6) {
+         uint32_t l, r;
+         std::memcpy(&l, lhs, 4);
+         std::memcpy(&r, rhs, 4);
+         uint16_t l2, r2;
+         std::memcpy(&l2, lhs + 4, 2);
+         std::memcpy(&r2, rhs + 4, 2);
+         return (l == r) & (l2 == r2);
+      }
+      else if constexpr (Count == 5) {
+         uint32_t l, r;
+         std::memcpy(&l, lhs, 4);
+         std::memcpy(&r, rhs, 4);
+         return (l == r) & (lhs[4] == rhs[4]);
       }
       else if constexpr (Count == 4) {
-         uint32_t v[2];
-         std::memcpy(v, lhs, Count);
-         std::memcpy(v + 1, rhs, Count);
-         return v[0] == v[1];
+         uint32_t l, r;
+         std::memcpy(&l, lhs, 4);
+         std::memcpy(&r, rhs, 4);
+         return l == r;
       }
       else if constexpr (Count == 3) {
-         uint32_t v[2]{}; // must default initialize
-         std::memcpy(v, lhs, Count);
-         std::memcpy(v + 1, rhs, Count);
-         return v[0] == v[1];
+         uint16_t l, r;
+         std::memcpy(&l, lhs, 2);
+         std::memcpy(&r, rhs, 2);
+         return (l == r) & (lhs[2] == rhs[2]);
       }
       else if constexpr (Count == 2) {
-         uint16_t v[2];
-         std::memcpy(v, lhs, Count);
-         std::memcpy(v + 1, rhs, Count);
-         return v[0] == v[1];
+         uint16_t l, r;
+         std::memcpy(&l, lhs, 2);
+         std::memcpy(&r, rhs, 2);
+         return l == r;
       }
       else if constexpr (Count == 1) {
          return *lhs == *rhs;
       }
+      else if constexpr (Count == 0) {
+         return true;
+      }
+   }
+
+   template <size_t N>
+   consteval auto bytes_to_unsigned_type() noexcept
+   {
+      if constexpr (N == 1) {
+         return uint8_t{};
+      }
+      else if constexpr (N == 2) {
+         return uint16_t{};
+      }
+      else if constexpr (N == 4) {
+         return uint32_t{};
+      }
+      else if constexpr (N == 8) {
+         return uint64_t{};
+      }
       else {
+         return;
+      }
+   }
+
+   template <size_t N>
+   using unsigned_bytes_t = std::decay_t<decltype(bytes_to_unsigned_type<N>())>;
+
+   template <const std::string_view& Str, size_t N>
+      requires(N <= 8)
+   consteval auto pack()
+   {
+      using T = unsigned_bytes_t<N>;
+      T v{};
+      for (size_t i = 0; i < N; ++i) {
+         v |= (static_cast<T>(uint8_t(Str[i])) << ((i % 8) * 8));
+      }
+      return v;
+   }
+
+   template <const std::string_view& Str, size_t N>
+      requires(N > 8)
+   consteval auto pack()
+   {
+      constexpr auto chunks = N / 8;
+      std::array<uint64_t, ((chunks > 0) ? chunks + 1 : 1)> v{};
+      for (size_t i = 0; i < N; ++i) {
+         const auto chunk = i / 8;
+         v[chunk] |= (static_cast<uint64_t>(uint8_t(Str[i])) << ((i % 8) * 8));
+      }
+      return v;
+   }
+
+   template <const std::string_view& Str, size_t N>
+      requires(N <= 8)
+   consteval auto pack_buffered()
+   {
+      using T = unsigned_bytes_t<N>;
+      T v{};
+      for (size_t i = 0; i < Str.size(); ++i) {
+         v |= (static_cast<T>(uint8_t(Str[i])) << ((i % 8) * 8));
+      }
+      return v;
+   }
+
+   template <const std::string_view& Str, size_t N = Str.size()>
+   GLZ_ALWAYS_INLINE bool comparitor(const auto* other) noexcept
+   {
+      if constexpr (N == 8) {
+         static constexpr auto packed = pack<Str, 8>();
+         uint64_t in;
+         std::memcpy(&in, other, 8);
+         return (in == packed);
+      }
+      else if constexpr (N == 7) {
+         static constexpr auto packed = pack_buffered<Str, 8>();
+         uint64_t in{};
+         std::memcpy(&in, other, 7);
+         return (in == packed);
+      }
+      else if constexpr (N == 6) {
+         static constexpr auto packed = pack_buffered<Str, 8>();
+         uint64_t in{};
+         std::memcpy(&in, other, 6);
+         return (in == packed);
+      }
+      else if constexpr (N == 5) {
+         static constexpr auto packed = pack<Str, 4>();
+         uint32_t in;
+         std::memcpy(&in, other, 4);
+         return (in == packed) & (Str[4] == other[4]);
+      }
+      else if constexpr (N == 4) {
+         static constexpr auto packed = pack<Str, 4>();
+         uint32_t in;
+         std::memcpy(&in, other, 4);
+         return (in == packed);
+      }
+      else if constexpr (N == 3) {
+         static constexpr auto packed = pack<Str, 2>();
+         uint16_t in;
+         std::memcpy(&in, other, 2);
+         return (in == packed) & (Str[2] == other[2]);
+      }
+      else if constexpr (N == 2) {
+         static constexpr auto packed = pack<Str, 2>();
+         uint16_t in;
+         std::memcpy(&in, other, 2);
+         return (in == packed);
+      }
+      else if constexpr (N == 1) {
+         return Str[0] == other[0];
+      }
+      else if constexpr (N == 0) {
          return true;
       }
+      else {
+         // Clang and GCC optimize this extremely well for constexpr std::string_view
+         // Packing data can create more binary on GCC
+         // The other cases probably aren't needed as compiler explorer shows them optimized equally well as memcmp
+         return 0 == std::memcmp(Str.data(), other, N);
+      }
    }
 
    // compare_sv checks sizes
diff --git a/deps/saucer/include/glaze/util/convert.hpp b/deps/saucer/include/glaze/util/convert.hpp
new file mode 100644
index 0000000..095e0f7
--- /dev/null
+++ b/deps/saucer/include/glaze/util/convert.hpp
@@ -0,0 +1,11 @@
+// Glaze Library
+// For the license information refer to glaze.hpp
+
+#pragma once
+
+#include <cstdint>
+
+namespace glz
+{
+   consteval uint16_t to_uint16_t(const char chars[2]) { return uint16_t(chars[0]) | (uint16_t(chars[1]) << 8); }
+}
diff --git a/deps/saucer/include/glaze/util/dragonbox.hpp b/deps/saucer/include/glaze/util/dragonbox.hpp
new file mode 100644
index 0000000..4b0a427
--- /dev/null
+++ b/deps/saucer/include/glaze/util/dragonbox.hpp
@@ -0,0 +1,4233 @@
+// Copyright 2020-2024 Junekey Jeon
+//
+// The contents of this file may be used under the terms of
+// the Apache License v2.0 with LLVM Exceptions.
+//
+//    (See accompanying file LICENSE-Apache or copy at
+//     https://llvm.org/foundation/relicensing/LICENSE.txt)
+//
+// Alternatively, the contents of this file may be used under the terms of
+// the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE-Boost or copy at
+//     https://www.boost.org/LICENSE_1_0.txt)
+//
+// Unless required by applicable law or agreed to in writing, this software
+// is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.
+
+#ifndef GLZ_JKJ_HEADER_DRAGONBOX
+#define GLZ_JKJ_HEADER_DRAGONBOX
+
+// Attribute for storing static data into a dedicated place, e.g. flash memory. Every ODR-used
+// static data declaration will be decorated with this macro. The users may define this macro,
+// before including the library headers, into whatever they want.
+#ifndef GLZ_JKJ_STATIC_DATA_SECTION
+#define GLZ_JKJ_STATIC_DATA_SECTION
+#else
+#define GLZ_JKJ_STATIC_DATA_SECTION_DEFINED 1
+#endif
+
+// To use the library with toolchains without standard C++ headers, the users may define this macro
+// into their custom namespace which contains the defintions of all the standard C++ library
+// features used in this header. (The list can be found below.)
+#ifndef GLZ_JKJ_STD_REPLACEMENT_NAMESPACE
+#define GLZ_JKJ_STD_REPLACEMENT_NAMESPACE std
+#include <cassert>
+#include <cstdint>
+#include <cstring>
+#include <limits>
+#include <type_traits>
+
+#ifdef __has_include
+#if __has_include(<version>)
+#include <version>
+#endif
+#endif
+#else
+#define GLZ_JKJ_STD_REPLACEMENT_NAMESPACE_DEFINED 1
+#endif
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Language feature detections.
+////////////////////////////////////////////////////////////////////////////////////////
+
+// C++14 constexpr
+#if defined(__cpp_constexpr) && __cpp_constexpr >= 201304L
+#define GLZ_JKJ_HAS_CONSTEXPR14 1
+#elif __cplusplus >= 201402L
+#define GLZ_JKJ_HAS_CONSTEXPR14 1
+#elif defined(_MSC_VER) && _MSC_VER >= 1910 && _MSVC_LANG >= 201402L
+#define GLZ_JKJ_HAS_CONSTEXPR14 1
+#else
+#define GLZ_JKJ_HAS_CONSTEXPR14 0
+#endif
+
+#if GLZ_JKJ_HAS_CONSTEXPR14
+#define GLZ_JKJ_CONSTEXPR14 constexpr
+#else
+#define GLZ_JKJ_CONSTEXPR14
+#endif
+
+// C++17 constexpr lambdas
+#if defined(__cpp_constexpr) && __cpp_constexpr >= 201603L
+#define GLZ_JKJ_HAS_CONSTEXPR17 1
+#elif __cplusplus >= 201703L
+#define GLZ_JKJ_HAS_CONSTEXPR17 1
+#elif defined(_MSC_VER) && _MSC_VER >= 1911 && _MSVC_LANG >= 201703L
+#define GLZ_JKJ_HAS_CONSTEXPR17 1
+#else
+#define GLZ_JKJ_HAS_CONSTEXPR17 0
+#endif
+
+// C++17 inline variables
+#if defined(__cpp_inline_variables) && __cpp_inline_variables >= 201606L
+#define GLZ_JKJ_HAS_INLINE_VARIABLE 1
+#elif __cplusplus >= 201703L
+#define GLZ_JKJ_HAS_INLINE_VARIABLE 1
+#elif defined(_MSC_VER) && _MSC_VER >= 1912 && _MSVC_LANG >= 201703L
+#define GLZ_JKJ_HAS_INLINE_VARIABLE 1
+#else
+#define GLZ_JKJ_HAS_INLINE_VARIABLE 0
+#endif
+
+#if GLZ_JKJ_HAS_INLINE_VARIABLE
+#define GLZ_JKJ_INLINE_VARIABLE inline constexpr
+#else
+#define GLZ_JKJ_INLINE_VARIABLE static constexpr
+#endif
+
+// C++17 if constexpr
+#if defined(__cpp_if_constexpr) && __cpp_if_constexpr >= 201606L
+#define GLZ_JKJ_HAS_IF_CONSTEXPR 1
+#elif __cplusplus >= 201703L
+#define GLZ_JKJ_HAS_IF_CONSTEXPR 1
+#elif defined(_MSC_VER) && _MSC_VER >= 1911 && _MSVC_LANG >= 201703L
+#define GLZ_JKJ_HAS_IF_CONSTEXPR 1
+#else
+#define GLZ_JKJ_HAS_IF_CONSTEXPR 0
+#endif
+
+#if GLZ_JKJ_HAS_IF_CONSTEXPR
+#define GLZ_JKJ_IF_CONSTEXPR if constexpr
+#else
+#define GLZ_JKJ_IF_CONSTEXPR if
+#endif
+
+// C++20 std::bit_cast
+#if GLZ_JKJ_STD_REPLACEMENT_NAMESPACE_DEFINED
+#if GLZ_JKJ_STD_REPLACEMENT_HAS_BIT_CAST
+#define GLZ_JKJ_HAS_BIT_CAST 1
+#else
+#define GLZ_JKJ_HAS_BIT_CAST 0
+#endif
+#elif defined(__cpp_lib_bit_cast) && __cpp_lib_bit_cast >= 201806L
+#include <bit>
+#define GLZ_JKJ_HAS_BIT_CAST 1
+#else
+#define GLZ_JKJ_HAS_BIT_CAST 0
+#endif
+
+// C++23 if consteval or C++20 std::is_constant_evaluated
+#if defined(__cpp_if_consteval) && __cpp_is_consteval >= 202106L
+#define GLZ_JKJ_IF_CONSTEVAL if consteval
+#define GLZ_JKJ_IF_NOT_CONSTEVAL if !consteval
+#define GLZ_JKJ_CAN_BRANCH_ON_CONSTEVAL 1
+#define GLZ_JKJ_USE_IS_CONSTANT_EVALUATED 0
+#elif GLZ_JKJ_STD_REPLACEMENT_NAMESPACE_DEFINED
+#if GLZ_JKJ_STD_REPLACEMENT_HAS_IS_CONSTANT_EVALUATED
+#define GLZ_JKJ_IF_CONSTEVAL if (stdr::is_constant_evaluated())
+#define GLZ_JKJ_IF_NOT_CONSTEVAL if (!stdr::is_constant_evaluated())
+#define GLZ_JKJ_CAN_BRANCH_ON_CONSTEVAL 1
+#define GLZ_JKJ_USE_IS_CONSTANT_EVALUATED 1
+#elif GLZ_JKJ_HAS_IF_CONSTEXPR
+#define GLZ_JKJ_IF_CONSTEVAL if constexpr (false)
+#define GLZ_JKJ_IF_NOT_CONSTEVAL if constexpr (true)
+#define GLZ_JKJ_CAN_BRANCH_ON_CONSTEVAL 0
+#define GLZ_JKJ_USE_IS_CONSTANT_EVALUATED 0
+#else
+#define GLZ_JKJ_IF_CONSTEVAL if (false)
+#define GLZ_JKJ_IF_NOT_CONSTEVAL if (true)
+#define GLZ_JKJ_CAN_BRANCH_ON_CONSTEVAL 0
+#define GLZ_JKJ_USE_IS_CONSTANT_EVALUATED 0
+#endif
+#else
+#if defined(__cpp_lib_is_constant_evaluated) && __cpp_lib_is_constant_evaluated >= 201811L
+#define GLZ_JKJ_IF_CONSTEVAL if (stdr::is_constant_evaluated())
+#define GLZ_JKJ_IF_NOT_CONSTEVAL if (!stdr::is_constant_evaluated())
+#define GLZ_JKJ_CAN_BRANCH_ON_CONSTEVAL 1
+#define GLZ_JKJ_USE_IS_CONSTANT_EVALUATED 1
+#elif GLZ_JKJ_HAS_IF_CONSTEXPR
+#define GLZ_JKJ_IF_CONSTEVAL if constexpr (false)
+#define GLZ_JKJ_IF_NOT_CONSTEVAL if constexpr (true)
+#define GLZ_JKJ_CAN_BRANCH_ON_CONSTEVAL 0
+#define GLZ_JKJ_USE_IS_CONSTANT_EVALUATED 0
+#else
+#define GLZ_JKJ_IF_CONSTEVAL if (false)
+#define GLZ_JKJ_IF_NOT_CONSTEVAL if (true)
+#define GLZ_JKJ_CAN_BRANCH_ON_CONSTEVAL 0
+#define GLZ_JKJ_USE_IS_CONSTANT_EVALUATED 0
+#endif
+#endif
+
+#if GLZ_JKJ_CAN_BRANCH_ON_CONSTEVAL && GLZ_JKJ_HAS_BIT_CAST
+#define GLZ_JKJ_CONSTEXPR20 constexpr
+#else
+#define GLZ_JKJ_CONSTEXPR20
+#endif
+
+// Suppress additional buffer overrun check.
+// I have no idea why MSVC thinks some functions here are vulnerable to the buffer overrun
+// attacks. No, they aren't.
+#if defined(__GNUC__) || defined(__clang__)
+#define GLZ_JKJ_SAFEBUFFERS
+#define GLZ_JKJ_FORCEINLINE inline __attribute__((always_inline))
+#elif defined(_MSC_VER)
+#define GLZ_JKJ_SAFEBUFFERS __declspec(safebuffers)
+#define GLZ_JKJ_FORCEINLINE __forceinline
+#else
+#define GLZ_JKJ_SAFEBUFFERS
+#define GLZ_JKJ_FORCEINLINE inline
+#endif
+
+#if defined(__has_builtin)
+#define GLZ_JKJ_HAS_BUILTIN(x) __has_builtin(x)
+#else
+#define GLZ_JKJ_HAS_BUILTIN(x) false
+#endif
+
+#if defined(_MSC_VER)
+#include <intrin.h>
+#elif defined(__INTEL_COMPILER)
+#include <immintrin.h>
+#endif
+
+namespace glz::jkj
+{
+   namespace dragonbox
+   {
+      ////////////////////////////////////////////////////////////////////////////////////////
+      // The Compatibility layer for toolchains without standard C++ headers.
+      ////////////////////////////////////////////////////////////////////////////////////////
+      namespace detail
+      {
+         namespace stdr
+         {
+            // <bit>
+#if GLZ_JKJ_HAS_BIT_CAST
+            using GLZ_JKJ_STD_REPLACEMENT_NAMESPACE::bit_cast;
+#endif
+
+            // <cassert>
+            // We need assert() macro, but it is not namespaced anyway, so nothing to do here.
+
+            // <cstdint>
+            using GLZ_JKJ_STD_REPLACEMENT_NAMESPACE::int_fast16_t;
+            using GLZ_JKJ_STD_REPLACEMENT_NAMESPACE::int_fast32_t;
+            using GLZ_JKJ_STD_REPLACEMENT_NAMESPACE::int_fast8_t;
+            using GLZ_JKJ_STD_REPLACEMENT_NAMESPACE::int_least16_t;
+            using GLZ_JKJ_STD_REPLACEMENT_NAMESPACE::int_least32_t;
+            using GLZ_JKJ_STD_REPLACEMENT_NAMESPACE::int_least8_t;
+            using GLZ_JKJ_STD_REPLACEMENT_NAMESPACE::uint_fast16_t;
+            using GLZ_JKJ_STD_REPLACEMENT_NAMESPACE::uint_fast32_t;
+            using GLZ_JKJ_STD_REPLACEMENT_NAMESPACE::uint_fast8_t;
+            using GLZ_JKJ_STD_REPLACEMENT_NAMESPACE::uint_least16_t;
+            using GLZ_JKJ_STD_REPLACEMENT_NAMESPACE::uint_least32_t;
+            using GLZ_JKJ_STD_REPLACEMENT_NAMESPACE::uint_least64_t;
+            using GLZ_JKJ_STD_REPLACEMENT_NAMESPACE::uint_least8_t;
+            // We need INT32_C, UINT32_C and UINT64_C macros too, but again there is nothing to do
+            // here.
+
+            // <cstring>
+            using GLZ_JKJ_STD_REPLACEMENT_NAMESPACE::memcpy;
+            using GLZ_JKJ_STD_REPLACEMENT_NAMESPACE::size_t;
+
+            // <limits>
+            template <class T>
+            using numeric_limits = GLZ_JKJ_STD_REPLACEMENT_NAMESPACE::numeric_limits<T>;
+
+            // <type_traits>
+            template <bool cond, class T = void>
+            using enable_if = GLZ_JKJ_STD_REPLACEMENT_NAMESPACE::enable_if<cond, T>;
+            template <class T>
+            using add_rvalue_reference = GLZ_JKJ_STD_REPLACEMENT_NAMESPACE::add_rvalue_reference<T>;
+            template <bool cond, class T_true, class T_false>
+            using conditional = GLZ_JKJ_STD_REPLACEMENT_NAMESPACE::conditional<cond, T_true, T_false>;
+#if GLZ_JKJ_USE_IS_CONSTANT_EVALUATED
+            using GLZ_JKJ_STD_REPLACEMENT_NAMESPACE::is_constant_evaluated;
+#endif
+            template <class T1, class T2>
+            using is_same = GLZ_JKJ_STD_REPLACEMENT_NAMESPACE::is_same<T1, T2>;
+#if !GLZ_JKJ_HAS_BIT_CAST
+            template <class T>
+            using is_trivially_copyable = GLZ_JKJ_STD_REPLACEMENT_NAMESPACE::is_trivially_copyable<T>;
+#endif
+            template <class T>
+            using is_integral = GLZ_JKJ_STD_REPLACEMENT_NAMESPACE::is_integral<T>;
+            template <class T>
+            using is_signed = GLZ_JKJ_STD_REPLACEMENT_NAMESPACE::is_signed<T>;
+            template <class T>
+            using is_unsigned = GLZ_JKJ_STD_REPLACEMENT_NAMESPACE::is_unsigned<T>;
+         }
+      }
+
+      ////////////////////////////////////////////////////////////////////////////////////////
+      // Some general utilities for C++11-compatibility.
+      ////////////////////////////////////////////////////////////////////////////////////////
+      namespace detail
+      {
+#if !GLZ_JKJ_HAS_CONSTEXPR17
+         template <stdr::size_t... indices>
+         struct index_sequence
+         {};
+
+         template <stdr::size_t current, stdr::size_t total, class Dummy, stdr::size_t... indices>
+         struct make_index_sequence_impl
+         {
+            using type = typename make_index_sequence_impl<current + 1, total, Dummy, indices..., current>::type;
+         };
+
+         template <stdr::size_t total, class Dummy, stdr::size_t... indices>
+         struct make_index_sequence_impl<total, total, Dummy, indices...>
+         {
+            using type = index_sequence<indices...>;
+         };
+
+         template <stdr::size_t N>
+         using make_index_sequence = typename make_index_sequence_impl<0, N, void>::type;
+#endif
+
+         // Available since C++11, but including <utility> just for this is an overkill.
+         template <class T>
+         typename stdr::add_rvalue_reference<T>::type declval() noexcept;
+
+         // Similarly, including <array> is an overkill.
+         template <class T, stdr::size_t N>
+         struct array
+         {
+            T data_[N];
+            constexpr T operator[](stdr::size_t idx) const noexcept { return data_[idx]; }
+            GLZ_JKJ_CONSTEXPR14 T& operator[](stdr::size_t idx) noexcept { return data_[idx]; }
+         };
+      }
+
+      ////////////////////////////////////////////////////////////////////////////////////////
+      // Some basic features for encoding/decoding IEEE-754 formats.
+      ////////////////////////////////////////////////////////////////////////////////////////
+      namespace detail
+      {
+         template <class T>
+         struct physical_bits
+         {
+            static constexpr stdr::size_t value = sizeof(T) * stdr::numeric_limits<unsigned char>::digits;
+         };
+         template <class T>
+         struct value_bits
+         {
+            static constexpr stdr::size_t value =
+               stdr::numeric_limits<typename stdr::enable_if<stdr::is_integral<T>::value, T>::type>::digits;
+         };
+
+         template <typename To, typename From>
+         GLZ_JKJ_CONSTEXPR20 To bit_cast(const From& from)
+         {
+#if GLZ_JKJ_HAS_BIT_CAST
+            return stdr::bit_cast<To>(from);
+#else
+            static_assert(sizeof(From) == sizeof(To), "");
+            static_assert(stdr::is_trivially_copyable<To>::value, "");
+            static_assert(stdr::is_trivially_copyable<From>::value, "");
+            To to;
+            stdr::memcpy(&to, &from, sizeof(To));
+            return to;
+#endif
+         }
+      }
+
+      // These classes expose encoding specs of IEEE-754-like floating-point formats.
+      // Currently available formats are IEEE-754 binary32 & IEEE-754 binary64.
+
+      struct ieee754_binary32
+      {
+         static constexpr int total_bits = 32;
+         static constexpr int significand_bits = 23;
+         static constexpr int exponent_bits = 8;
+         static constexpr int min_exponent = -126;
+         static constexpr int max_exponent = 127;
+         static constexpr int exponent_bias = -127;
+         static constexpr int decimal_significand_digits = 9;
+         static constexpr int decimal_exponent_digits = 2;
+      };
+      struct ieee754_binary64
+      {
+         static constexpr int total_bits = 64;
+         static constexpr int significand_bits = 52;
+         static constexpr int exponent_bits = 11;
+         static constexpr int min_exponent = -1022;
+         static constexpr int max_exponent = 1023;
+         static constexpr int exponent_bias = -1023;
+         static constexpr int decimal_significand_digits = 17;
+         static constexpr int decimal_exponent_digits = 3;
+      };
+
+      // A floating-point format traits class defines ways to interpret a bit pattern of given size as
+      // an encoding of floating-point number. This is an implementation of such a traits class,
+      // supporting ways to interpret IEEE-754 binary floating-point numbers.
+      template <class Format, class CarrierUInt, class ExponentInt = int>
+      struct ieee754_binary_traits
+      {
+         // CarrierUInt needs to have enough size to hold the entire contents of floating-point
+         // numbers. The actual bits are assumed to be aligned to the LSB, and every other bits are
+         // assumed to be zeroed.
+         static_assert(detail::value_bits<CarrierUInt>::value >= Format::total_bits,
+                       "jkj::dragonbox: insufficient number of bits");
+         static_assert(detail::stdr::is_unsigned<CarrierUInt>::value, "");
+
+         // ExponentUInt needs to be large enough to hold (unsigned) exponent bits as well as the
+         // (signed) actual exponent.
+         // TODO: static overflow guard against intermediate computations.
+         static_assert(detail::value_bits<ExponentInt>::value >= Format::exponent_bits + 1,
+                       "jkj::dragonbox: insufficient number of bits");
+         static_assert(detail::stdr::is_signed<ExponentInt>::value, "");
+
+         using format = Format;
+         using carrier_uint = CarrierUInt;
+         static constexpr int carrier_bits = int(detail::value_bits<carrier_uint>::value);
+         using exponent_int = ExponentInt;
+
+         // Extract exponent bits from a bit pattern.
+         // The result must be aligned to the LSB so that there is no additional zero paddings
+         // on the right. This function does not do bias adjustment.
+         static constexpr exponent_int extract_exponent_bits(carrier_uint u) noexcept
+         {
+            return exponent_int((u >> format::significand_bits) & ((exponent_int(1) << format::exponent_bits) - 1));
+         }
+
+         // Extract significand bits from a bit pattern.
+         // The result must be aligned to the LSB so that there is no additional zero paddings
+         // on the right. The result does not contain the implicit bit.
+         static constexpr carrier_uint extract_significand_bits(carrier_uint u) noexcept
+         {
+            return carrier_uint(u & ((carrier_uint(1) << format::significand_bits) - 1u));
+         }
+
+         // Remove the exponent bits and extract significand bits together with the sign bit.
+         static constexpr carrier_uint remove_exponent_bits(carrier_uint u) noexcept
+         {
+            return carrier_uint(u & ~(((carrier_uint(1) << format::exponent_bits) - 1u) << format::significand_bits));
+         }
+
+         // Shift the obtained signed significand bits to the left by 1 to remove the sign bit.
+         static constexpr carrier_uint remove_sign_bit_and_shift(carrier_uint u) noexcept
+         {
+            return carrier_uint((carrier_uint(u) << 1) &
+                                ((((carrier_uint(1) << (Format::total_bits - 1)) - 1u) << 1) | 1u));
+         }
+
+         // Obtain the actual value of the binary exponent from the extracted exponent bits.
+         static constexpr exponent_int binary_exponent(exponent_int exponent_bits) noexcept
+         {
+            return exponent_int(exponent_bits == 0 ? format::min_exponent : exponent_bits + format::exponent_bias);
+         }
+
+         // Obtain the actual value of the binary significand from the extracted significand bits
+         // and exponent bits.
+         static constexpr carrier_uint binary_significand(carrier_uint significand_bits,
+                                                          exponent_int exponent_bits) noexcept
+         {
+            return carrier_uint(exponent_bits == 0
+                                   ? significand_bits
+                                   : (significand_bits | (carrier_uint(1) << format::significand_bits)));
+         }
+
+         /* Various boolean observer functions */
+
+         static constexpr bool is_nonzero(carrier_uint u) noexcept
+         {
+            return (u & ((carrier_uint(1) << (format::significand_bits + format::exponent_bits)) - 1u)) != 0;
+         }
+         static constexpr bool is_positive(carrier_uint u) noexcept
+         {
+            return u < (carrier_uint(1) << (format::significand_bits + format::exponent_bits));
+         }
+         static constexpr bool is_negative(carrier_uint u) noexcept { return !is_positive(u); }
+         static constexpr bool is_finite(exponent_int exponent_bits) noexcept
+         {
+            return exponent_bits != ((exponent_int(1) << format::exponent_bits) - 1);
+         }
+         static constexpr bool has_all_zero_significand_bits(carrier_uint u) noexcept
+         {
+            return ((u << 1) & ((((carrier_uint(1) << (Format::total_bits - 1)) - 1u) << 1) | 1u)) == 0;
+         }
+         static constexpr bool has_even_significand_bits(carrier_uint u) noexcept { return u % 2 == 0; }
+      };
+
+      // Convert between bit patterns stored in carrier_uint and instances of an actual
+      // floating-point type. Depending on format and carrier_uint, this operation might not
+      // be possible for some specific bit patterns. However, the contract is that u always
+      // denotes a valid bit pattern, so the functions here are assumed to be noexcept.
+      // Users might specialize this class to change the behavior for certain types.
+      // The default provided by the library is to treat the given floating-point type Float as either
+      // IEEE-754 binary32 or IEEE-754 binary64, depending on the bitwise size of Float.
+      template <class Float>
+      struct default_float_bit_carrier_conversion_traits
+      {
+         // Guards against types that have different internal representations than IEEE-754
+         // binary32/64. I don't know if there is a truly reliable way of detecting IEEE-754 binary
+         // formats. I just did my best here. Note that in some cases
+         // numeric_limits<Float>::is_iec559 may report false even if the internal representation is
+         // IEEE-754 compatible. In such a case, the user can specialize this traits template and
+         // remove this static sanity check in order to make Dragonbox work for Float.
+         static_assert(detail::stdr::numeric_limits<Float>::is_iec559 &&
+                          detail::stdr::numeric_limits<Float>::radix == 2 &&
+                          (detail::physical_bits<Float>::value == 32 || detail::physical_bits<Float>::value == 64),
+                       "jkj::dragonbox: Float may not be of IEEE-754 binary32/binary64");
+
+         // Specifies the unsigned integer type to hold bitwise value of Float.
+         using carrier_uint =
+            typename detail::stdr::conditional<detail::physical_bits<Float>::value == 32, detail::stdr::uint_least32_t,
+                                               detail::stdr::uint_least64_t>::type;
+
+         // Specifies the floating-point format.
+         using format = typename detail::stdr::conditional<detail::physical_bits<Float>::value == 32, ieee754_binary32,
+                                                           ieee754_binary64>::type;
+
+         // Converts the floating-point type into the bit-carrier unsigned integer type.
+         static GLZ_JKJ_CONSTEXPR20 carrier_uint float_to_carrier(Float x) noexcept
+         {
+            return detail::bit_cast<carrier_uint>(x);
+         }
+
+         // Converts the bit-carrier unsigned integer type into the floating-point type.
+         static GLZ_JKJ_CONSTEXPR20 Float carrier_to_float(carrier_uint x) noexcept
+         {
+            return detail::bit_cast<Float>(x);
+         }
+      };
+
+      // Convenient wrappers for floating-point traits classes.
+      // In order to reduce the argument passing overhead, these classes should be as simple as
+      // possible (e.g., no inheritance, no private non-static data member, etc.; this is an
+      // unfortunate fact about common ABI convention).
+
+      template <class FormatTraits>
+      struct signed_significand_bits
+      {
+         using format_traits = FormatTraits;
+         using carrier_uint = typename format_traits::carrier_uint;
+
+         carrier_uint u;
+
+         signed_significand_bits() = default;
+         constexpr explicit signed_significand_bits(carrier_uint bit_pattern) noexcept : u{bit_pattern} {}
+
+         // Shift the obtained signed significand bits to the left by 1 to remove the sign bit.
+         constexpr carrier_uint remove_sign_bit_and_shift() const noexcept
+         {
+            return format_traits::remove_sign_bit_and_shift(u);
+         }
+
+         constexpr bool is_positive() const noexcept { return format_traits::is_positive(u); }
+         constexpr bool is_negative() const noexcept { return format_traits::is_negative(u); }
+         constexpr bool has_all_zero_significand_bits() const noexcept
+         {
+            return format_traits::has_all_zero_significand_bits(u);
+         }
+         constexpr bool has_even_significand_bits() const noexcept
+         {
+            return format_traits::has_even_significand_bits(u);
+         }
+      };
+
+      template <class FormatTraits>
+      struct float_bits
+      {
+         using format_traits = FormatTraits;
+         using carrier_uint = typename format_traits::carrier_uint;
+         using exponent_int = typename format_traits::exponent_int;
+
+         carrier_uint u;
+
+         float_bits() = default;
+         constexpr explicit float_bits(carrier_uint bit_pattern) noexcept : u{bit_pattern} {}
+
+         // Extract exponent bits from a bit pattern.
+         // The result must be aligned to the LSB so that there is no additional zero paddings
+         // on the right. This function does not do bias adjustment.
+         constexpr exponent_int extract_exponent_bits() const noexcept
+         {
+            return format_traits::extract_exponent_bits(u);
+         }
+
+         // Extract significand bits from a bit pattern.
+         // The result must be aligned to the LSB so that there is no additional zero paddings
+         // on the right. The result does not contain the implicit bit.
+         constexpr carrier_uint extract_significand_bits() const noexcept
+         {
+            return format_traits::extract_significand_bits(u);
+         }
+
+         // Remove the exponent bits and extract significand bits together with the sign bit.
+         constexpr signed_significand_bits<format_traits> remove_exponent_bits() const noexcept
+         {
+            return signed_significand_bits<format_traits>(format_traits::remove_exponent_bits(u));
+         }
+
+         // Obtain the actual value of the binary exponent from the extracted exponent bits.
+         static constexpr exponent_int binary_exponent(exponent_int exponent_bits) noexcept
+         {
+            return format_traits::binary_exponent(exponent_bits);
+         }
+         constexpr exponent_int binary_exponent() const noexcept { return binary_exponent(extract_exponent_bits()); }
+
+         // Obtain the actual value of the binary exponent from the extracted significand bits
+         // and exponent bits.
+         static constexpr carrier_uint binary_significand(carrier_uint significand_bits,
+                                                          exponent_int exponent_bits) noexcept
+         {
+            return format_traits::binary_significand(significand_bits, exponent_bits);
+         }
+         constexpr carrier_uint binary_significand() const noexcept
+         {
+            return binary_significand(extract_significand_bits(), extract_exponent_bits());
+         }
+
+         constexpr bool is_nonzero() const noexcept { return format_traits::is_nonzero(u); }
+         constexpr bool is_positive() const noexcept { return format_traits::is_positive(u); }
+         constexpr bool is_negative() const noexcept { return format_traits::is_negative(u); }
+         constexpr bool is_finite(exponent_int exponent_bits) const noexcept
+         {
+            return format_traits::is_finite(exponent_bits);
+         }
+         constexpr bool is_finite() const noexcept { return format_traits::is_finite(extract_exponent_bits()); }
+         constexpr bool has_even_significand_bits() const noexcept
+         {
+            return format_traits::has_even_significand_bits(u);
+         }
+      };
+
+      template <class Float, class ConversionTraits = default_float_bit_carrier_conversion_traits<Float>,
+                class FormatTraits =
+                   ieee754_binary_traits<typename ConversionTraits::format, typename ConversionTraits::carrier_uint>>
+      GLZ_JKJ_CONSTEXPR20 float_bits<FormatTraits> make_float_bits(Float x) noexcept
+      {
+         return float_bits<FormatTraits>(ConversionTraits::float_to_carrier(x));
+      }
+
+      namespace detail
+      {
+         ////////////////////////////////////////////////////////////////////////////////////////
+         // Bit operation intrinsics.
+         ////////////////////////////////////////////////////////////////////////////////////////
+
+         namespace bits
+         {
+            // Most compilers should be able to optimize this into the ROR instruction.
+            // n is assumed to be at most of bit_width bits.
+            template <stdr::size_t bit_width, class UInt>
+            GLZ_JKJ_CONSTEXPR14 UInt rotr(UInt n, unsigned int r) noexcept
+            {
+               static_assert(bit_width > 0, "jkj::dragonbox: rotation bit-width must be positive");
+               static_assert(bit_width <= value_bits<UInt>::value, "jkj::dragonbox: rotation bit-width is too large");
+               r &= (bit_width - 1);
+               return (n >> r) | (n << ((bit_width - r) & (bit_width - 1)));
+            }
+         }
+
+         ////////////////////////////////////////////////////////////////////////////////////////
+         // Utilities for wide unsigned integer arithmetic.
+         ////////////////////////////////////////////////////////////////////////////////////////
+
+         namespace wuint
+         {
+            // Compilers might support built-in 128-bit integer types. However, it seems that
+            // emulating them with a pair of 64-bit integers actually produces a better code,
+            // so we avoid using those built-ins. That said, they are still useful for
+            // implementing 64-bit x 64-bit -> 128-bit multiplication.
+
+            // clang-format off
+#if defined(__SIZEOF_INT128__)
+      // To silence "error: ISO C++ does not support '__int128' for 'type name'
+      // [-Wpedantic]"
+#if defined(__GNUC__)
+         __extension__
+#endif
+         using builtin_uint128_t = unsigned __int128;
+#endif
+            // clang-format on
+
+            struct uint128
+            {
+               uint128() = default;
+
+               stdr::uint_least64_t high_;
+               stdr::uint_least64_t low_;
+
+               constexpr uint128(stdr::uint_least64_t high, stdr::uint_least64_t low) noexcept : high_{high}, low_{low}
+               {}
+
+               constexpr stdr::uint_least64_t high() const noexcept { return high_; }
+               constexpr stdr::uint_least64_t low() const noexcept { return low_; }
+
+               GLZ_JKJ_CONSTEXPR20 uint128& operator+=(stdr::uint_least64_t n) & noexcept
+               {
+                  const auto generic_impl = [&] {
+                     const auto sum = (low_ + n) & UINT64_C(0xffffffffffffffff);
+                     high_ += (sum < low_ ? 1 : 0);
+                     low_ = sum;
+                  };
+                  // To suppress warning.
+                  static_cast<void>(generic_impl);
+
+                  GLZ_JKJ_IF_CONSTEXPR(value_bits<stdr::uint_least64_t>::value > 64)
+                  {
+                     generic_impl();
+                     return *this;
+                  }
+
+                  GLZ_JKJ_IF_CONSTEVAL
+                  {
+                     generic_impl();
+                     return *this;
+                  }
+
+                  // See https://github.com/fmtlib/fmt/pull/2985.
+#if GLZ_JKJ_HAS_BUILTIN(__builtin_addcll) && !defined(__ibmxl__)
+                  GLZ_JKJ_IF_CONSTEXPR(stdr::is_same<stdr::uint_least64_t, unsigned long long>::value)
+                  {
+                     unsigned long long carry{};
+                     low_ = stdr::uint_least64_t(__builtin_addcll(low_, n, 0, &carry));
+                     high_ = stdr::uint_least64_t(__builtin_addcll(high_, 0, carry, &carry));
+                     return *this;
+                  }
+#endif
+#if GLZ_JKJ_HAS_BUILTIN(__builtin_addcl) && !defined(__ibmxl__)
+                  GLZ_JKJ_IF_CONSTEXPR(stdr::is_same<stdr::uint_least64_t, unsigned long>::value)
+                  {
+                     unsigned long carry{};
+                     low_ = stdr::uint_least64_t(
+                        __builtin_addcl(static_cast<unsigned long>(low_), static_cast<unsigned long>(n), 0, &carry));
+                     high_ = stdr::uint_least64_t(__builtin_addcl(static_cast<unsigned long>(high_), 0, carry, &carry));
+                     return *this;
+                  }
+#endif
+#if GLZ_JKJ_HAS_BUILTIN(__builtin_addc) && !defined(__ibmxl__)
+                  GLZ_JKJ_IF_CONSTEXPR(stdr::is_same<stdr::uint_least64_t, unsigned int>::value)
+                  {
+                     unsigned int carry{};
+                     low_ = stdr::uint_least64_t(
+                        __builtin_addc(static_cast<unsigned int>(low_), static_cast<unsigned int>(n), 0, &carry));
+                     high_ = stdr::uint_least64_t(__builtin_addc(static_cast<unsigned int>(high_), 0, carry, &carry));
+                     return *this;
+                  }
+#endif
+
+#if GLZ_JKJ_HAS_BUILTIN(__builtin_ia32_addcarry_u64)
+                  // __builtin_ia32_addcarry_u64 is not documented, but it seems it takes unsigned
+                  // long long arguments.
+                  unsigned long long result{};
+                  const auto carry = __builtin_ia32_addcarry_u64(0, low_, n, &result);
+                  low_ = stdr::uint_least64_t(result);
+                  __builtin_ia32_addcarry_u64(carry, high_, 0, &result);
+                  high_ = stdr::uint_least64_t(result);
+#elif defined(_MSC_VER) && defined(_M_X64)
+                  // On MSVC, uint_least64_t and __int64 must be unsigned long long; see
+                  // https://learn.microsoft.com/en-us/cpp/c-runtime-library/standard-types
+                  // and https://learn.microsoft.com/en-us/cpp/cpp/int8-int16-int32-int64.
+                  static_assert(stdr::is_same<unsigned long long, stdr::uint_least64_t>::value, "");
+                  const auto carry = _addcarry_u64(0, low_, n, &low_);
+                  _addcarry_u64(carry, high_, 0, &high_);
+#elif defined(__INTEL_COMPILER) && (defined(_M_X64) || defined(__x86_64))
+                  // Cannot find any documentation on how things are defined, but hopefully this
+                  // is always true...
+                  static_assert(stdr::is_same<unsigned __int64, stdr::uint_least64_t>::value, "");
+                  const auto carry = _addcarry_u64(0, low_, n, &low_);
+                  _addcarry_u64(carry, high_, 0, &high_);
+#else
+                  generic_impl();
+#endif
+                  return *this;
+               }
+            };
+
+            inline GLZ_JKJ_CONSTEXPR20 stdr::uint_least64_t umul64(stdr::uint_least32_t x,
+                                                                   stdr::uint_least32_t y) noexcept
+            {
+#if defined(_MSC_VER) && defined(_M_IX86)
+               GLZ_JKJ_IF_NOT_CONSTEVAL { return __emulu(x, y); }
+#endif
+               return x * stdr::uint_least64_t(y);
+            }
+
+            // Get 128-bit result of multiplication of two 64-bit unsigned integers.
+            GLZ_JKJ_SAFEBUFFERS inline GLZ_JKJ_CONSTEXPR20 uint128 umul128(stdr::uint_least64_t x,
+                                                                           stdr::uint_least64_t y) noexcept
+            {
+               const auto generic_impl = [=]() -> uint128 {
+                  const auto a = stdr::uint_least32_t(x >> 32);
+                  const auto b = stdr::uint_least32_t(x);
+                  const auto c = stdr::uint_least32_t(y >> 32);
+                  const auto d = stdr::uint_least32_t(y);
+
+                  const auto ac = umul64(a, c);
+                  const auto bc = umul64(b, c);
+                  const auto ad = umul64(a, d);
+                  const auto bd = umul64(b, d);
+
+                  const auto intermediate = (bd >> 32) + stdr::uint_least32_t(ad) + stdr::uint_least32_t(bc);
+
+                  return {ac + (intermediate >> 32) + (ad >> 32) + (bc >> 32),
+                          (intermediate << 32) + stdr::uint_least32_t(bd)};
+               };
+               // To silence warning.
+               static_cast<void>(generic_impl);
+
+#if defined(__SIZEOF_INT128__)
+               const auto result = builtin_uint128_t(x) * builtin_uint128_t(y);
+               return {stdr::uint_least64_t(result >> 64), stdr::uint_least64_t(result)};
+#elif defined(_MSC_VER) && defined(_M_X64)
+               GLZ_JKJ_IF_CONSTEVAL
+               {
+                  // This redundant variable is to workaround MSVC's codegen bug caused by the
+                  // interaction of NRVO and intrinsics.
+                  const auto result = generic_impl();
+                  return result;
+               }
+               uint128 result;
+#if defined(__AVX2__)
+               result.low_ = _mulx_u64(x, y, &result.high_);
+#else
+               result.low_ = _umul128(x, y, &result.high_);
+#endif
+               return result;
+#else
+               return generic_impl();
+#endif
+            }
+
+            // Get high half of the 128-bit result of multiplication of two 64-bit unsigned
+            // integers.
+            GLZ_JKJ_SAFEBUFFERS inline GLZ_JKJ_CONSTEXPR20 stdr::uint_least64_t umul128_upper64(
+               stdr::uint_least64_t x, stdr::uint_least64_t y) noexcept
+            {
+               const auto generic_impl = [=]() -> stdr::uint_least64_t {
+                  const auto a = stdr::uint_least32_t(x >> 32);
+                  const auto b = stdr::uint_least32_t(x);
+                  const auto c = stdr::uint_least32_t(y >> 32);
+                  const auto d = stdr::uint_least32_t(y);
+
+                  const auto ac = umul64(a, c);
+                  const auto bc = umul64(b, c);
+                  const auto ad = umul64(a, d);
+                  const auto bd = umul64(b, d);
+
+                  const auto intermediate = (bd >> 32) + stdr::uint_least32_t(ad) + stdr::uint_least32_t(bc);
+
+                  return ac + (intermediate >> 32) + (ad >> 32) + (bc >> 32);
+               };
+               // To silence warning.
+               static_cast<void>(generic_impl);
+
+#if defined(__SIZEOF_INT128__)
+               const auto result = builtin_uint128_t(x) * builtin_uint128_t(y);
+               return stdr::uint_least64_t(result >> 64);
+#elif defined(_MSC_VER) && defined(_M_X64)
+               GLZ_JKJ_IF_CONSTEVAL
+               {
+                  // This redundant variable is to workaround MSVC's codegen bug caused by the
+                  // interaction of NRVO and intrinsics.
+                  const auto result = generic_impl();
+                  return result;
+               }
+               stdr::uint_least64_t result;
+#if defined(__AVX2__)
+               _mulx_u64(x, y, &result);
+#else
+               result = __umulh(x, y);
+#endif
+               return result;
+#else
+               return generic_impl();
+#endif
+            }
+
+            // Get upper 128-bits of multiplication of a 64-bit unsigned integer and a 128-bit
+            // unsigned integer.
+            GLZ_JKJ_SAFEBUFFERS inline GLZ_JKJ_CONSTEXPR20 uint128 umul192_upper128(stdr::uint_least64_t x,
+                                                                                    uint128 y) noexcept
+            {
+               auto r = umul128(x, y.high());
+               r += umul128_upper64(x, y.low());
+               return r;
+            }
+
+            // Get upper 64-bits of multiplication of a 32-bit unsigned integer and a 64-bit
+            // unsigned integer.
+            inline GLZ_JKJ_CONSTEXPR20 stdr::uint_least64_t umul96_upper64(stdr::uint_least32_t x,
+                                                                           stdr::uint_least64_t y) noexcept
+            {
+#if defined(__SIZEOF_INT128__) || (defined(_MSC_VER) && defined(_M_X64))
+               return umul128_upper64(stdr::uint_least64_t(x) << 32, y);
+#else
+               const auto yh = stdr::uint_least32_t(y >> 32);
+               const auto yl = stdr::uint_least32_t(y);
+
+               const auto xyh = umul64(x, yh);
+               const auto xyl = umul64(x, yl);
+
+               return xyh + (xyl >> 32);
+#endif
+            }
+
+            // Get lower 128-bits of multiplication of a 64-bit unsigned integer and a 128-bit
+            // unsigned integer.
+            GLZ_JKJ_SAFEBUFFERS inline GLZ_JKJ_CONSTEXPR20 uint128 umul192_lower128(stdr::uint_least64_t x,
+                                                                                    uint128 y) noexcept
+            {
+               const auto high = x * y.high();
+               const auto high_low = umul128(x, y.low());
+               return {(high + high_low.high()) & UINT64_C(0xffffffffffffffff), high_low.low()};
+            }
+
+            // Get lower 64-bits of multiplication of a 32-bit unsigned integer and a 64-bit
+            // unsigned integer.
+            constexpr stdr::uint_least64_t umul96_lower64(stdr::uint_least32_t x, stdr::uint_least64_t y) noexcept
+            {
+               return (x * y) & UINT64_C(0xffffffffffffffff);
+            }
+         }
+
+         ////////////////////////////////////////////////////////////////////////////////////////
+         // Some simple utilities for constexpr computation.
+         ////////////////////////////////////////////////////////////////////////////////////////
+
+         template <int k, class Int>
+         constexpr Int compute_power(Int a) noexcept
+         {
+            static_assert(k >= 0, "");
+#if GLZ_JKJ_HAS_CONSTEXPR14
+            Int p = 1;
+            for (int i = 0; i < k; ++i) {
+               p *= a;
+            }
+            return p;
+#else
+            return k == 0 ? 1 : k % 2 == 0 ? compute_power<k / 2, Int>(a * a) : a * compute_power<k / 2, Int>(a * a);
+#endif
+         }
+
+         template <int a, class UInt>
+         constexpr int count_factors(UInt n) noexcept
+         {
+            static_assert(a > 1, "");
+#if GLZ_JKJ_HAS_CONSTEXPR14
+            int c = 0;
+            while (n % a == 0) {
+               n /= a;
+               ++c;
+            }
+            return c;
+#else
+            return n % a == 0 ? count_factors<a, UInt>(n / a) + 1 : 0;
+#endif
+         }
+
+         ////////////////////////////////////////////////////////////////////////////////////////
+         // Utilities for fast/constexpr log computation.
+         ////////////////////////////////////////////////////////////////////////////////////////
+
+         namespace log
+         {
+            static_assert((stdr::int_fast32_t(-1) >> 1) == stdr::int_fast32_t(-1) &&
+                             (stdr::int_fast16_t(-1) >> 1) == stdr::int_fast16_t(-1),
+                          "jkj::dragonbox: right-shift for signed integers must be arithmetic");
+
+            // For constexpr computation.
+            // Returns -1 when n = 0.
+            template <class UInt>
+            constexpr int floor_log2(UInt n) noexcept
+            {
+#if GLZ_JKJ_HAS_CONSTEXPR14
+               int count = -1;
+               while (n != 0) {
+                  ++count;
+                  n >>= 1;
+               }
+               return count;
+#else
+               return n == 0 ? -1 : floor_log2<UInt>(n / 2) + 1;
+#endif
+            }
+
+            template <template <stdr::size_t> class Info, stdr::int_least32_t min_exponent,
+                      stdr::int_least32_t max_exponent, stdr::size_t current_tier,
+                      stdr::int_least32_t supported_min_exponent = Info<current_tier>::min_exponent,
+                      stdr::int_least32_t supported_max_exponent = Info<current_tier>::max_exponent>
+            constexpr bool is_in_range(int) noexcept
+            {
+               return min_exponent >= supported_min_exponent && max_exponent <= supported_max_exponent;
+            }
+            template <template <stdr::size_t> class Info, stdr::int_least32_t min_exponent,
+                      stdr::int_least32_t max_exponent, stdr::size_t current_tier>
+            constexpr bool is_in_range(...) noexcept
+            {
+               // Supposed to be always false, but formally dependent on the template parameters.
+               static_assert(min_exponent > max_exponent, "jkj::dragonbox: exponent range is too wide");
+               return false;
+            }
+
+            template <template <stdr::size_t> class Info, stdr::int_least32_t min_exponent,
+                      stdr::int_least32_t max_exponent, stdr::size_t current_tier = 0,
+                      bool = is_in_range<Info, min_exponent, max_exponent, current_tier>(0)>
+            struct compute_impl;
+
+            template <template <stdr::size_t> class Info, stdr::int_least32_t min_exponent,
+                      stdr::int_least32_t max_exponent, stdr::size_t current_tier>
+            struct compute_impl<Info, min_exponent, max_exponent, current_tier, true>
+            {
+               using info = Info<current_tier>;
+               using default_return_type = typename info::default_return_type;
+               template <class ReturnType, class Int>
+               static constexpr ReturnType compute(Int e) noexcept
+               {
+#if GLZ_JKJ_HAS_CONSTEXPR14
+                  assert(min_exponent <= e && e <= max_exponent);
+#endif
+                  // The sign is irrelevant for the mathematical validity of the formula, but
+                  // assuming positivity makes the overflow analysis simpler.
+                  static_assert(info::multiply >= 0 && info::subtract >= 0, "");
+                  return static_cast<ReturnType>((e * info::multiply - info::subtract) >> info::shift);
+               }
+            };
+
+            template <template <stdr::size_t> class Info, stdr::int_least32_t min_exponent,
+                      stdr::int_least32_t max_exponent, stdr::size_t current_tier>
+            struct compute_impl<Info, min_exponent, max_exponent, current_tier, false>
+            {
+               using next_tier = compute_impl<Info, min_exponent, max_exponent, current_tier + 1>;
+               using default_return_type = typename next_tier::default_return_type;
+               template <class ReturnType, class Int>
+               static constexpr ReturnType compute(Int e) noexcept
+               {
+                  return next_tier::template compute<ReturnType>(e);
+               }
+            };
+
+            template <stdr::size_t tier>
+            struct floor_log10_pow2_info;
+            template <>
+            struct floor_log10_pow2_info<0>
+            {
+               using default_return_type = stdr::int_fast8_t;
+               static constexpr stdr::int_fast16_t multiply = 77;
+               static constexpr stdr::int_fast16_t subtract = 0;
+               static constexpr stdr::size_t shift = 8;
+               static constexpr stdr::int_least32_t min_exponent = -102;
+               static constexpr stdr::int_least32_t max_exponent = 102;
+            };
+            template <>
+            struct floor_log10_pow2_info<1>
+            {
+               using default_return_type = stdr::int_fast8_t;
+               // 24-bits are enough in fact.
+               static constexpr stdr::int_fast32_t multiply = 1233;
+               static constexpr stdr::int_fast32_t subtract = 0;
+               static constexpr stdr::size_t shift = 12;
+               // Formula itself holds on [-680,680]; [-425,425] is to ensure that the output is
+               // within [-127,127].
+               static constexpr stdr::int_least32_t min_exponent = -425;
+               static constexpr stdr::int_least32_t max_exponent = 425;
+            };
+            template <>
+            struct floor_log10_pow2_info<2>
+            {
+               using default_return_type = stdr::int_fast16_t;
+               static constexpr stdr::int_fast32_t multiply = INT32_C(315653);
+               static constexpr stdr::int_fast32_t subtract = 0;
+               static constexpr stdr::size_t shift = 20;
+               static constexpr stdr::int_least32_t min_exponent = -2620;
+               static constexpr stdr::int_least32_t max_exponent = 2620;
+            };
+            template <stdr::int_least32_t min_exponent = -2620, stdr::int_least32_t max_exponent = 2620,
+                      class ReturnType =
+                         typename compute_impl<floor_log10_pow2_info, min_exponent, max_exponent>::default_return_type,
+                      class Int>
+            constexpr ReturnType floor_log10_pow2(Int e) noexcept
+            {
+               return compute_impl<floor_log10_pow2_info, min_exponent, max_exponent>::template compute<ReturnType>(e);
+            }
+
+            template <stdr::size_t tier>
+            struct floor_log2_pow10_info;
+            template <>
+            struct floor_log2_pow10_info<0>
+            {
+               using default_return_type = stdr::int_fast8_t;
+               static constexpr stdr::int_fast16_t multiply = 53;
+               static constexpr stdr::int_fast16_t subtract = 0;
+               static constexpr stdr::size_t shift = 4;
+               static constexpr stdr::int_least32_t min_exponent = -15;
+               static constexpr stdr::int_least32_t max_exponent = 18;
+            };
+            template <>
+            struct floor_log2_pow10_info<1>
+            {
+               using default_return_type = stdr::int_fast16_t;
+               // 24-bits are enough in fact.
+               static constexpr stdr::int_fast32_t multiply = 1701;
+               static constexpr stdr::int_fast32_t subtract = 0;
+               static constexpr stdr::size_t shift = 9;
+               static constexpr stdr::int_least32_t min_exponent = -58;
+               static constexpr stdr::int_least32_t max_exponent = 58;
+            };
+            template <>
+            struct floor_log2_pow10_info<2>
+            {
+               using default_return_type = stdr::int_fast16_t;
+               static constexpr stdr::int_fast32_t multiply = INT32_C(1741647);
+               static constexpr stdr::int_fast32_t subtract = 0;
+               static constexpr stdr::size_t shift = 19;
+               // Formula itself holds on [-4003,4003]; [-1233,1233] is to ensure no overflow.
+               static constexpr stdr::int_least32_t min_exponent = -1233;
+               static constexpr stdr::int_least32_t max_exponent = 1233;
+            };
+            template <stdr::int_least32_t min_exponent = -1233, stdr::int_least32_t max_exponent = 1233,
+                      class ReturnType =
+                         typename compute_impl<floor_log2_pow10_info, min_exponent, max_exponent>::default_return_type,
+                      class Int>
+            constexpr ReturnType floor_log2_pow10(Int e) noexcept
+            {
+               return compute_impl<floor_log2_pow10_info, min_exponent, max_exponent>::template compute<ReturnType>(e);
+            }
+
+            template <stdr::size_t tier>
+            struct floor_log10_pow2_minus_log10_4_over_3_info;
+            template <>
+            struct floor_log10_pow2_minus_log10_4_over_3_info<0>
+            {
+               using default_return_type = stdr::int_fast8_t;
+               static constexpr stdr::int_fast16_t multiply = 77;
+               static constexpr stdr::int_fast16_t subtract = 31;
+               static constexpr stdr::size_t shift = 8;
+               static constexpr stdr::int_least32_t min_exponent = -75;
+               static constexpr stdr::int_least32_t max_exponent = 129;
+            };
+            template <>
+            struct floor_log10_pow2_minus_log10_4_over_3_info<1>
+            {
+               using default_return_type = stdr::int_fast8_t;
+               // 24-bits are enough in fact.
+               static constexpr stdr::int_fast32_t multiply = 19728;
+               static constexpr stdr::int_fast32_t subtract = 8241;
+               static constexpr stdr::size_t shift = 16;
+               // Formula itself holds on [-849,315]; [-424,315] is to ensure that the output is
+               // within [-127,127].
+               static constexpr stdr::int_least32_t min_exponent = -424;
+               static constexpr stdr::int_least32_t max_exponent = 315;
+            };
+            template <>
+            struct floor_log10_pow2_minus_log10_4_over_3_info<2>
+            {
+               using default_return_type = stdr::int_fast16_t;
+               static constexpr stdr::int_fast32_t multiply = INT32_C(631305);
+               static constexpr stdr::int_fast32_t subtract = INT32_C(261663);
+               static constexpr stdr::size_t shift = 21;
+               static constexpr stdr::int_least32_t min_exponent = -2985;
+               static constexpr stdr::int_least32_t max_exponent = 2936;
+            };
+            template <stdr::int_least32_t min_exponent = -2985, stdr::int_least32_t max_exponent = 2936,
+                      class ReturnType = typename compute_impl<floor_log10_pow2_minus_log10_4_over_3_info, min_exponent,
+                                                               max_exponent>::default_return_type,
+                      class Int>
+            constexpr ReturnType floor_log10_pow2_minus_log10_4_over_3(Int e) noexcept
+            {
+               return compute_impl<floor_log10_pow2_minus_log10_4_over_3_info, min_exponent,
+                                   max_exponent>::template compute<ReturnType>(e);
+            }
+
+            template <stdr::size_t tier>
+            struct floor_log5_pow2_info;
+            template <>
+            struct floor_log5_pow2_info<0>
+            {
+               using default_return_type = stdr::int_fast32_t;
+               static constexpr stdr::int_fast32_t multiply = INT32_C(225799);
+               static constexpr stdr::int_fast32_t subtract = 0;
+               static constexpr stdr::size_t shift = 19;
+               static constexpr stdr::int_least32_t min_exponent = -1831;
+               static constexpr stdr::int_least32_t max_exponent = 1831;
+            };
+            template <stdr::int_least32_t min_exponent = -1831, stdr::int_least32_t max_exponent = 1831,
+                      class ReturnType =
+                         typename compute_impl<floor_log5_pow2_info, min_exponent, max_exponent>::default_return_type,
+                      class Int>
+            constexpr ReturnType floor_log5_pow2(Int e) noexcept
+            {
+               return compute_impl<floor_log5_pow2_info, min_exponent, max_exponent>::template compute<ReturnType>(e);
+            }
+
+            template <stdr::size_t tier>
+            struct floor_log5_pow2_minus_log5_3_info;
+            template <>
+            struct floor_log5_pow2_minus_log5_3_info<0>
+            {
+               using default_return_type = stdr::int_fast32_t;
+               static constexpr stdr::int_fast32_t multiply = INT32_C(451597);
+               static constexpr stdr::int_fast32_t subtract = INT32_C(715764);
+               static constexpr stdr::size_t shift = 20;
+               static constexpr stdr::int_least32_t min_exponent = -3543;
+               static constexpr stdr::int_least32_t max_exponent = 2427;
+            };
+            template <stdr::int_least32_t min_exponent = -3543, stdr::int_least32_t max_exponent = 2427,
+                      class ReturnType = typename compute_impl<floor_log5_pow2_minus_log5_3_info, min_exponent,
+                                                               max_exponent>::default_return_type,
+                      class Int>
+            constexpr ReturnType floor_log5_pow2_minus_log5_3(Int e) noexcept
+            {
+               return compute_impl<floor_log5_pow2_minus_log5_3_info, min_exponent,
+                                   max_exponent>::template compute<ReturnType>(e);
+            }
+         }
+
+         ////////////////////////////////////////////////////////////////////////////////////////
+         // Utilities for fast divisibility tests.
+         ////////////////////////////////////////////////////////////////////////////////////////
+
+         namespace div
+         {
+            // Replace n by floor(n / 10^N).
+            // Returns true if and only if n is divisible by 10^N.
+            // Precondition: n <= 10^(N+1)
+            // !!It takes an in-out parameter!!
+            template <int N, class UInt>
+            struct divide_by_pow10_info;
+
+            template <class UInt>
+            struct divide_by_pow10_info<1, UInt>
+            {
+               static constexpr stdr::uint_fast32_t magic_number = 6554;
+               static constexpr int shift_amount = 16;
+            };
+
+            template <>
+            struct divide_by_pow10_info<1, stdr::uint_least8_t>
+            {
+               static constexpr stdr::uint_fast16_t magic_number = 103;
+               static constexpr int shift_amount = 10;
+            };
+
+            template <>
+            struct divide_by_pow10_info<1, stdr::uint_least16_t>
+            {
+               static constexpr stdr::uint_fast16_t magic_number = 103;
+               static constexpr int shift_amount = 10;
+            };
+
+            template <class UInt>
+            struct divide_by_pow10_info<2, UInt>
+            {
+               static constexpr stdr::uint_fast32_t magic_number = 656;
+               static constexpr int shift_amount = 16;
+            };
+
+            template <>
+            struct divide_by_pow10_info<2, stdr::uint_least16_t>
+            {
+               static constexpr stdr::uint_fast32_t magic_number = 41;
+               static constexpr int shift_amount = 12;
+            };
+
+            template <int N, class UInt>
+            GLZ_JKJ_CONSTEXPR14 bool check_divisibility_and_divide_by_pow10(UInt& n) noexcept
+            {
+               // Make sure the computation for max_n does not overflow.
+               static_assert(N + 1 <= log::floor_log10_pow2(int(value_bits<UInt>::value)), "");
+               assert(n <= compute_power<N + 1>(UInt(10)));
+
+               using info = divide_by_pow10_info<N, UInt>;
+               using intermediate_type = decltype(info::magic_number);
+               const auto prod = intermediate_type(n * info::magic_number);
+
+               constexpr auto mask = intermediate_type((intermediate_type(1) << info::shift_amount) - 1);
+               const bool result = ((prod & mask) < info::magic_number);
+
+               n = UInt(prod >> info::shift_amount);
+               return result;
+            }
+
+            // Compute floor(n / 10^N) for small n and N.
+            // Precondition: n <= 10^(N+1)
+            template <int N, class UInt>
+            GLZ_JKJ_CONSTEXPR14 UInt small_division_by_pow10(UInt n) noexcept
+            {
+               // Make sure the computation for max_n does not overflow.
+               static_assert(N + 1 <= log::floor_log10_pow2(int(value_bits<UInt>::value)), "");
+               assert(n <= compute_power<N + 1>(UInt(10)));
+
+               return UInt((n * divide_by_pow10_info<N, UInt>::magic_number) >>
+                           divide_by_pow10_info<N, UInt>::shift_amount);
+            }
+
+            // Compute floor(n / 10^N) for small N.
+            // Precondition: n <= n_max
+            template <int N, class UInt, UInt n_max>
+            GLZ_JKJ_CONSTEXPR20 UInt divide_by_pow10(UInt n) noexcept
+            {
+               static_assert(N >= 0, "");
+
+               // Specialize for 32-bit division by 10.
+               // Without the bound on n_max (which compilers these days never leverage), the
+               // minimum needed amount of shift is larger than 32. Hence, this may generate better
+               // code for 32-bit or smaller architectures. Even for 64-bit architectures, it seems
+               // compilers tend to generate mov + mul instead of a single imul for an unknown
+               // reason if we just write n / 10.
+               GLZ_JKJ_IF_CONSTEXPR(stdr::is_same<UInt, stdr::uint_least32_t>::value && N == 1 &&
+                                    n_max <= UINT32_C(1073741828))
+               {
+                  return UInt(wuint::umul64(n, UINT32_C(429496730)) >> 32);
+               }
+               // Specialize for 64-bit division by 10.
+               // Without the bound on n_max (which compilers these days never leverage), the
+               // minimum needed amount of shift is larger than 64.
+               else GLZ_JKJ_IF_CONSTEXPR(stdr::is_same<UInt, stdr::uint_least64_t>::value && N == 1 &&
+                                         n_max <= UINT64_C(4611686018427387908))
+               {
+                  return UInt(wuint::umul128_upper64(n, UINT64_C(1844674407370955162)));
+               }
+               // Specialize for 32-bit division by 100.
+               // It seems compilers tend to generate mov + mul instead of a single imul for an
+               // unknown reason if we just write n / 100.
+               else GLZ_JKJ_IF_CONSTEXPR(stdr::is_same<UInt, stdr::uint_least32_t>::value && N == 2)
+               {
+                  return UInt(wuint::umul64(n, UINT32_C(1374389535)) >> 37);
+               }
+               // Specialize for 64-bit division by 1000.
+               // Without the bound on n_max (which compilers these days never leverage), the
+               // smallest magic number for this computation does not fit into 64-bits.
+               else GLZ_JKJ_IF_CONSTEXPR(stdr::is_same<UInt, stdr::uint_least64_t>::value && N == 3 &&
+                                         n_max <= UINT64_C(15534100272597517998))
+               {
+                  return UInt(wuint::umul128_upper64(n, UINT64_C(4722366482869645214)) >> 8);
+               }
+               else
+               {
+                  constexpr auto divisor = compute_power<N>(UInt(10));
+                  return n / divisor;
+               }
+            }
+         }
+      }
+
+      ////////////////////////////////////////////////////////////////////////////////////////
+      // Return types for the main interface function.
+      ////////////////////////////////////////////////////////////////////////////////////////
+
+      template <class SignificandType, class ExponentType, bool is_signed, bool trailing_zero_flag>
+      struct decimal_fp;
+
+      template <class SignificandType, class ExponentType>
+      struct decimal_fp<SignificandType, ExponentType, false, false>
+      {
+         SignificandType significand;
+         ExponentType exponent;
+      };
+
+      template <class SignificandType, class ExponentType>
+      struct decimal_fp<SignificandType, ExponentType, true, false>
+      {
+         SignificandType significand;
+         ExponentType exponent;
+         bool is_negative;
+      };
+
+      template <class SignificandType, class ExponentType>
+      struct decimal_fp<SignificandType, ExponentType, false, true>
+      {
+         SignificandType significand;
+         ExponentType exponent;
+         bool may_have_trailing_zeros;
+      };
+
+      template <class SignificandType, class ExponentType>
+      struct decimal_fp<SignificandType, ExponentType, true, true>
+      {
+         SignificandType significand;
+         ExponentType exponent;
+         bool may_have_trailing_zeros;
+         bool is_negative;
+      };
+
+      template <class SignificandType, class ExponentType, bool trailing_zero_flag = false>
+      using unsigned_decimal_fp = decimal_fp<SignificandType, ExponentType, false, trailing_zero_flag>;
+
+      template <class SignificandType, class ExponentType, bool trailing_zero_flag = false>
+      using signed_decimal_fp = decimal_fp<SignificandType, ExponentType, true, trailing_zero_flag>;
+
+      template <class SignificandType, class ExponentType>
+      constexpr signed_decimal_fp<SignificandType, ExponentType, false> add_sign_to_unsigned_decimal_fp(
+         bool is_negative, unsigned_decimal_fp<SignificandType, ExponentType, false> r) noexcept
+      {
+         return {r.significand, r.exponent, is_negative};
+      }
+
+      template <class SignificandType, class ExponentType>
+      constexpr signed_decimal_fp<SignificandType, ExponentType, true> add_sign_to_unsigned_decimal_fp(
+         bool is_negative, unsigned_decimal_fp<SignificandType, ExponentType, true> r) noexcept
+      {
+         return {r.significand, r.exponent, r.may_have_trailing_zeros, is_negative};
+      }
+
+      namespace detail
+      {
+         template <class UnsignedDecimalFp>
+         struct unsigned_decimal_fp_to_signed;
+
+         template <class SignificandType, class ExponentType, bool trailing_zero_flag>
+         struct unsigned_decimal_fp_to_signed<unsigned_decimal_fp<SignificandType, ExponentType, trailing_zero_flag>>
+         {
+            using type = signed_decimal_fp<SignificandType, ExponentType, trailing_zero_flag>;
+         };
+
+         template <class UnsignedDecimalFp>
+         using unsigned_decimal_fp_to_signed_t = typename unsigned_decimal_fp_to_signed<UnsignedDecimalFp>::type;
+      }
+
+      ////////////////////////////////////////////////////////////////////////////////////////
+      // Computed cache entries.
+      ////////////////////////////////////////////////////////////////////////////////////////
+
+      template <class FloatFormat, class Dummy = void>
+      struct cache_holder;
+
+      template <class Dummy>
+      struct cache_holder<ieee754_binary32, Dummy>
+      {
+         using cache_entry_type = detail::stdr::uint_least64_t;
+         static constexpr int cache_bits = 64;
+         static constexpr int min_k = -31;
+         static constexpr int max_k = 46;
+         static constexpr detail::array<cache_entry_type, detail::stdr::size_t(max_k - min_k + 1)> cache
+            GLZ_JKJ_STATIC_DATA_SECTION = {
+               {UINT64_C(0x81ceb32c4b43fcf5), UINT64_C(0xa2425ff75e14fc32), UINT64_C(0xcad2f7f5359a3b3f),
+                UINT64_C(0xfd87b5f28300ca0e), UINT64_C(0x9e74d1b791e07e49), UINT64_C(0xc612062576589ddb),
+                UINT64_C(0xf79687aed3eec552), UINT64_C(0x9abe14cd44753b53), UINT64_C(0xc16d9a0095928a28),
+                UINT64_C(0xf1c90080baf72cb2), UINT64_C(0x971da05074da7bef), UINT64_C(0xbce5086492111aeb),
+                UINT64_C(0xec1e4a7db69561a6), UINT64_C(0x9392ee8e921d5d08), UINT64_C(0xb877aa3236a4b44a),
+                UINT64_C(0xe69594bec44de15c), UINT64_C(0x901d7cf73ab0acda), UINT64_C(0xb424dc35095cd810),
+                UINT64_C(0xe12e13424bb40e14), UINT64_C(0x8cbccc096f5088cc), UINT64_C(0xafebff0bcb24aaff),
+                UINT64_C(0xdbe6fecebdedd5bf), UINT64_C(0x89705f4136b4a598), UINT64_C(0xabcc77118461cefd),
+                UINT64_C(0xd6bf94d5e57a42bd), UINT64_C(0x8637bd05af6c69b6), UINT64_C(0xa7c5ac471b478424),
+                UINT64_C(0xd1b71758e219652c), UINT64_C(0x83126e978d4fdf3c), UINT64_C(0xa3d70a3d70a3d70b),
+                UINT64_C(0xcccccccccccccccd), UINT64_C(0x8000000000000000), UINT64_C(0xa000000000000000),
+                UINT64_C(0xc800000000000000), UINT64_C(0xfa00000000000000), UINT64_C(0x9c40000000000000),
+                UINT64_C(0xc350000000000000), UINT64_C(0xf424000000000000), UINT64_C(0x9896800000000000),
+                UINT64_C(0xbebc200000000000), UINT64_C(0xee6b280000000000), UINT64_C(0x9502f90000000000),
+                UINT64_C(0xba43b74000000000), UINT64_C(0xe8d4a51000000000), UINT64_C(0x9184e72a00000000),
+                UINT64_C(0xb5e620f480000000), UINT64_C(0xe35fa931a0000000), UINT64_C(0x8e1bc9bf04000000),
+                UINT64_C(0xb1a2bc2ec5000000), UINT64_C(0xde0b6b3a76400000), UINT64_C(0x8ac7230489e80000),
+                UINT64_C(0xad78ebc5ac620000), UINT64_C(0xd8d726b7177a8000), UINT64_C(0x878678326eac9000),
+                UINT64_C(0xa968163f0a57b400), UINT64_C(0xd3c21bcecceda100), UINT64_C(0x84595161401484a0),
+                UINT64_C(0xa56fa5b99019a5c8), UINT64_C(0xcecb8f27f4200f3a), UINT64_C(0x813f3978f8940985),
+                UINT64_C(0xa18f07d736b90be6), UINT64_C(0xc9f2c9cd04674edf), UINT64_C(0xfc6f7c4045812297),
+                UINT64_C(0x9dc5ada82b70b59e), UINT64_C(0xc5371912364ce306), UINT64_C(0xf684df56c3e01bc7),
+                UINT64_C(0x9a130b963a6c115d), UINT64_C(0xc097ce7bc90715b4), UINT64_C(0xf0bdc21abb48db21),
+                UINT64_C(0x96769950b50d88f5), UINT64_C(0xbc143fa4e250eb32), UINT64_C(0xeb194f8e1ae525fe),
+                UINT64_C(0x92efd1b8d0cf37bf), UINT64_C(0xb7abc627050305ae), UINT64_C(0xe596b7b0c643c71a),
+                UINT64_C(0x8f7e32ce7bea5c70), UINT64_C(0xb35dbf821ae4f38c), UINT64_C(0xe0352f62a19e306f)}};
+      };
+#if !GLZ_JKJ_HAS_INLINE_VARIABLE
+      // decltype(...) should not depend on Dummy; see
+      // https://stackoverflow.com/questions/76438400/decltype-on-static-variable-in-template-class.
+      template <class Dummy>
+      constexpr decltype(cache_holder<ieee754_binary32>::cache) cache_holder<ieee754_binary32, Dummy>::cache;
+#endif
+
+      template <class Dummy>
+      struct cache_holder<ieee754_binary64, Dummy>
+      {
+         using cache_entry_type = detail::wuint::uint128;
+         static constexpr int cache_bits = 128;
+         static constexpr int min_k = -292;
+         static constexpr int max_k = 326;
+         static constexpr detail::array<cache_entry_type, detail::stdr::size_t(max_k - min_k + 1)> cache
+            GLZ_JKJ_STATIC_DATA_SECTION = {{{UINT64_C(0xff77b1fcbebcdc4f), UINT64_C(0x25e8e89c13bb0f7b)},
+                                            {UINT64_C(0x9faacf3df73609b1), UINT64_C(0x77b191618c54e9ad)},
+                                            {UINT64_C(0xc795830d75038c1d), UINT64_C(0xd59df5b9ef6a2418)},
+                                            {UINT64_C(0xf97ae3d0d2446f25), UINT64_C(0x4b0573286b44ad1e)},
+                                            {UINT64_C(0x9becce62836ac577), UINT64_C(0x4ee367f9430aec33)},
+                                            {UINT64_C(0xc2e801fb244576d5), UINT64_C(0x229c41f793cda740)},
+                                            {UINT64_C(0xf3a20279ed56d48a), UINT64_C(0x6b43527578c11110)},
+                                            {UINT64_C(0x9845418c345644d6), UINT64_C(0x830a13896b78aaaa)},
+                                            {UINT64_C(0xbe5691ef416bd60c), UINT64_C(0x23cc986bc656d554)},
+                                            {UINT64_C(0xedec366b11c6cb8f), UINT64_C(0x2cbfbe86b7ec8aa9)},
+                                            {UINT64_C(0x94b3a202eb1c3f39), UINT64_C(0x7bf7d71432f3d6aa)},
+                                            {UINT64_C(0xb9e08a83a5e34f07), UINT64_C(0xdaf5ccd93fb0cc54)},
+                                            {UINT64_C(0xe858ad248f5c22c9), UINT64_C(0xd1b3400f8f9cff69)},
+                                            {UINT64_C(0x91376c36d99995be), UINT64_C(0x23100809b9c21fa2)},
+                                            {UINT64_C(0xb58547448ffffb2d), UINT64_C(0xabd40a0c2832a78b)},
+                                            {UINT64_C(0xe2e69915b3fff9f9), UINT64_C(0x16c90c8f323f516d)},
+                                            {UINT64_C(0x8dd01fad907ffc3b), UINT64_C(0xae3da7d97f6792e4)},
+                                            {UINT64_C(0xb1442798f49ffb4a), UINT64_C(0x99cd11cfdf41779d)},
+                                            {UINT64_C(0xdd95317f31c7fa1d), UINT64_C(0x40405643d711d584)},
+                                            {UINT64_C(0x8a7d3eef7f1cfc52), UINT64_C(0x482835ea666b2573)},
+                                            {UINT64_C(0xad1c8eab5ee43b66), UINT64_C(0xda3243650005eed0)},
+                                            {UINT64_C(0xd863b256369d4a40), UINT64_C(0x90bed43e40076a83)},
+                                            {UINT64_C(0x873e4f75e2224e68), UINT64_C(0x5a7744a6e804a292)},
+                                            {UINT64_C(0xa90de3535aaae202), UINT64_C(0x711515d0a205cb37)},
+                                            {UINT64_C(0xd3515c2831559a83), UINT64_C(0x0d5a5b44ca873e04)},
+                                            {UINT64_C(0x8412d9991ed58091), UINT64_C(0xe858790afe9486c3)},
+                                            {UINT64_C(0xa5178fff668ae0b6), UINT64_C(0x626e974dbe39a873)},
+                                            {UINT64_C(0xce5d73ff402d98e3), UINT64_C(0xfb0a3d212dc81290)},
+                                            {UINT64_C(0x80fa687f881c7f8e), UINT64_C(0x7ce66634bc9d0b9a)},
+                                            {UINT64_C(0xa139029f6a239f72), UINT64_C(0x1c1fffc1ebc44e81)},
+                                            {UINT64_C(0xc987434744ac874e), UINT64_C(0xa327ffb266b56221)},
+                                            {UINT64_C(0xfbe9141915d7a922), UINT64_C(0x4bf1ff9f0062baa9)},
+                                            {UINT64_C(0x9d71ac8fada6c9b5), UINT64_C(0x6f773fc3603db4aa)},
+                                            {UINT64_C(0xc4ce17b399107c22), UINT64_C(0xcb550fb4384d21d4)},
+                                            {UINT64_C(0xf6019da07f549b2b), UINT64_C(0x7e2a53a146606a49)},
+                                            {UINT64_C(0x99c102844f94e0fb), UINT64_C(0x2eda7444cbfc426e)},
+                                            {UINT64_C(0xc0314325637a1939), UINT64_C(0xfa911155fefb5309)},
+                                            {UINT64_C(0xf03d93eebc589f88), UINT64_C(0x793555ab7eba27cb)},
+                                            {UINT64_C(0x96267c7535b763b5), UINT64_C(0x4bc1558b2f3458df)},
+                                            {UINT64_C(0xbbb01b9283253ca2), UINT64_C(0x9eb1aaedfb016f17)},
+                                            {UINT64_C(0xea9c227723ee8bcb), UINT64_C(0x465e15a979c1cadd)},
+                                            {UINT64_C(0x92a1958a7675175f), UINT64_C(0x0bfacd89ec191eca)},
+                                            {UINT64_C(0xb749faed14125d36), UINT64_C(0xcef980ec671f667c)},
+                                            {UINT64_C(0xe51c79a85916f484), UINT64_C(0x82b7e12780e7401b)},
+                                            {UINT64_C(0x8f31cc0937ae58d2), UINT64_C(0xd1b2ecb8b0908811)},
+                                            {UINT64_C(0xb2fe3f0b8599ef07), UINT64_C(0x861fa7e6dcb4aa16)},
+                                            {UINT64_C(0xdfbdcece67006ac9), UINT64_C(0x67a791e093e1d49b)},
+                                            {UINT64_C(0x8bd6a141006042bd), UINT64_C(0xe0c8bb2c5c6d24e1)},
+                                            {UINT64_C(0xaecc49914078536d), UINT64_C(0x58fae9f773886e19)},
+                                            {UINT64_C(0xda7f5bf590966848), UINT64_C(0xaf39a475506a899f)},
+                                            {UINT64_C(0x888f99797a5e012d), UINT64_C(0x6d8406c952429604)},
+                                            {UINT64_C(0xaab37fd7d8f58178), UINT64_C(0xc8e5087ba6d33b84)},
+                                            {UINT64_C(0xd5605fcdcf32e1d6), UINT64_C(0xfb1e4a9a90880a65)},
+                                            {UINT64_C(0x855c3be0a17fcd26), UINT64_C(0x5cf2eea09a550680)},
+                                            {UINT64_C(0xa6b34ad8c9dfc06f), UINT64_C(0xf42faa48c0ea481f)},
+                                            {UINT64_C(0xd0601d8efc57b08b), UINT64_C(0xf13b94daf124da27)},
+                                            {UINT64_C(0x823c12795db6ce57), UINT64_C(0x76c53d08d6b70859)},
+                                            {UINT64_C(0xa2cb1717b52481ed), UINT64_C(0x54768c4b0c64ca6f)},
+                                            {UINT64_C(0xcb7ddcdda26da268), UINT64_C(0xa9942f5dcf7dfd0a)},
+                                            {UINT64_C(0xfe5d54150b090b02), UINT64_C(0xd3f93b35435d7c4d)},
+                                            {UINT64_C(0x9efa548d26e5a6e1), UINT64_C(0xc47bc5014a1a6db0)},
+                                            {UINT64_C(0xc6b8e9b0709f109a), UINT64_C(0x359ab6419ca1091c)},
+                                            {UINT64_C(0xf867241c8cc6d4c0), UINT64_C(0xc30163d203c94b63)},
+                                            {UINT64_C(0x9b407691d7fc44f8), UINT64_C(0x79e0de63425dcf1e)},
+                                            {UINT64_C(0xc21094364dfb5636), UINT64_C(0x985915fc12f542e5)},
+                                            {UINT64_C(0xf294b943e17a2bc4), UINT64_C(0x3e6f5b7b17b2939e)},
+                                            {UINT64_C(0x979cf3ca6cec5b5a), UINT64_C(0xa705992ceecf9c43)},
+                                            {UINT64_C(0xbd8430bd08277231), UINT64_C(0x50c6ff782a838354)},
+                                            {UINT64_C(0xece53cec4a314ebd), UINT64_C(0xa4f8bf5635246429)},
+                                            {UINT64_C(0x940f4613ae5ed136), UINT64_C(0x871b7795e136be9a)},
+                                            {UINT64_C(0xb913179899f68584), UINT64_C(0x28e2557b59846e40)},
+                                            {UINT64_C(0xe757dd7ec07426e5), UINT64_C(0x331aeada2fe589d0)},
+                                            {UINT64_C(0x9096ea6f3848984f), UINT64_C(0x3ff0d2c85def7622)},
+                                            {UINT64_C(0xb4bca50b065abe63), UINT64_C(0x0fed077a756b53aa)},
+                                            {UINT64_C(0xe1ebce4dc7f16dfb), UINT64_C(0xd3e8495912c62895)},
+                                            {UINT64_C(0x8d3360f09cf6e4bd), UINT64_C(0x64712dd7abbbd95d)},
+                                            {UINT64_C(0xb080392cc4349dec), UINT64_C(0xbd8d794d96aacfb4)},
+                                            {UINT64_C(0xdca04777f541c567), UINT64_C(0xecf0d7a0fc5583a1)},
+                                            {UINT64_C(0x89e42caaf9491b60), UINT64_C(0xf41686c49db57245)},
+                                            {UINT64_C(0xac5d37d5b79b6239), UINT64_C(0x311c2875c522ced6)},
+                                            {UINT64_C(0xd77485cb25823ac7), UINT64_C(0x7d633293366b828c)},
+                                            {UINT64_C(0x86a8d39ef77164bc), UINT64_C(0xae5dff9c02033198)},
+                                            {UINT64_C(0xa8530886b54dbdeb), UINT64_C(0xd9f57f830283fdfd)},
+                                            {UINT64_C(0xd267caa862a12d66), UINT64_C(0xd072df63c324fd7c)},
+                                            {UINT64_C(0x8380dea93da4bc60), UINT64_C(0x4247cb9e59f71e6e)},
+                                            {UINT64_C(0xa46116538d0deb78), UINT64_C(0x52d9be85f074e609)},
+                                            {UINT64_C(0xcd795be870516656), UINT64_C(0x67902e276c921f8c)},
+                                            {UINT64_C(0x806bd9714632dff6), UINT64_C(0x00ba1cd8a3db53b7)},
+                                            {UINT64_C(0xa086cfcd97bf97f3), UINT64_C(0x80e8a40eccd228a5)},
+                                            {UINT64_C(0xc8a883c0fdaf7df0), UINT64_C(0x6122cd128006b2ce)},
+                                            {UINT64_C(0xfad2a4b13d1b5d6c), UINT64_C(0x796b805720085f82)},
+                                            {UINT64_C(0x9cc3a6eec6311a63), UINT64_C(0xcbe3303674053bb1)},
+                                            {UINT64_C(0xc3f490aa77bd60fc), UINT64_C(0xbedbfc4411068a9d)},
+                                            {UINT64_C(0xf4f1b4d515acb93b), UINT64_C(0xee92fb5515482d45)},
+                                            {UINT64_C(0x991711052d8bf3c5), UINT64_C(0x751bdd152d4d1c4b)},
+                                            {UINT64_C(0xbf5cd54678eef0b6), UINT64_C(0xd262d45a78a0635e)},
+                                            {UINT64_C(0xef340a98172aace4), UINT64_C(0x86fb897116c87c35)},
+                                            {UINT64_C(0x9580869f0e7aac0e), UINT64_C(0xd45d35e6ae3d4da1)},
+                                            {UINT64_C(0xbae0a846d2195712), UINT64_C(0x8974836059cca10a)},
+                                            {UINT64_C(0xe998d258869facd7), UINT64_C(0x2bd1a438703fc94c)},
+                                            {UINT64_C(0x91ff83775423cc06), UINT64_C(0x7b6306a34627ddd0)},
+                                            {UINT64_C(0xb67f6455292cbf08), UINT64_C(0x1a3bc84c17b1d543)},
+                                            {UINT64_C(0xe41f3d6a7377eeca), UINT64_C(0x20caba5f1d9e4a94)},
+                                            {UINT64_C(0x8e938662882af53e), UINT64_C(0x547eb47b7282ee9d)},
+                                            {UINT64_C(0xb23867fb2a35b28d), UINT64_C(0xe99e619a4f23aa44)},
+                                            {UINT64_C(0xdec681f9f4c31f31), UINT64_C(0x6405fa00e2ec94d5)},
+                                            {UINT64_C(0x8b3c113c38f9f37e), UINT64_C(0xde83bc408dd3dd05)},
+                                            {UINT64_C(0xae0b158b4738705e), UINT64_C(0x9624ab50b148d446)},
+                                            {UINT64_C(0xd98ddaee19068c76), UINT64_C(0x3badd624dd9b0958)},
+                                            {UINT64_C(0x87f8a8d4cfa417c9), UINT64_C(0xe54ca5d70a80e5d7)},
+                                            {UINT64_C(0xa9f6d30a038d1dbc), UINT64_C(0x5e9fcf4ccd211f4d)},
+                                            {UINT64_C(0xd47487cc8470652b), UINT64_C(0x7647c32000696720)},
+                                            {UINT64_C(0x84c8d4dfd2c63f3b), UINT64_C(0x29ecd9f40041e074)},
+                                            {UINT64_C(0xa5fb0a17c777cf09), UINT64_C(0xf468107100525891)},
+                                            {UINT64_C(0xcf79cc9db955c2cc), UINT64_C(0x7182148d4066eeb5)},
+                                            {UINT64_C(0x81ac1fe293d599bf), UINT64_C(0xc6f14cd848405531)},
+                                            {UINT64_C(0xa21727db38cb002f), UINT64_C(0xb8ada00e5a506a7d)},
+                                            {UINT64_C(0xca9cf1d206fdc03b), UINT64_C(0xa6d90811f0e4851d)},
+                                            {UINT64_C(0xfd442e4688bd304a), UINT64_C(0x908f4a166d1da664)},
+                                            {UINT64_C(0x9e4a9cec15763e2e), UINT64_C(0x9a598e4e043287ff)},
+                                            {UINT64_C(0xc5dd44271ad3cdba), UINT64_C(0x40eff1e1853f29fe)},
+                                            {UINT64_C(0xf7549530e188c128), UINT64_C(0xd12bee59e68ef47d)},
+                                            {UINT64_C(0x9a94dd3e8cf578b9), UINT64_C(0x82bb74f8301958cf)},
+                                            {UINT64_C(0xc13a148e3032d6e7), UINT64_C(0xe36a52363c1faf02)},
+                                            {UINT64_C(0xf18899b1bc3f8ca1), UINT64_C(0xdc44e6c3cb279ac2)},
+                                            {UINT64_C(0x96f5600f15a7b7e5), UINT64_C(0x29ab103a5ef8c0ba)},
+                                            {UINT64_C(0xbcb2b812db11a5de), UINT64_C(0x7415d448f6b6f0e8)},
+                                            {UINT64_C(0xebdf661791d60f56), UINT64_C(0x111b495b3464ad22)},
+                                            {UINT64_C(0x936b9fcebb25c995), UINT64_C(0xcab10dd900beec35)},
+                                            {UINT64_C(0xb84687c269ef3bfb), UINT64_C(0x3d5d514f40eea743)},
+                                            {UINT64_C(0xe65829b3046b0afa), UINT64_C(0x0cb4a5a3112a5113)},
+                                            {UINT64_C(0x8ff71a0fe2c2e6dc), UINT64_C(0x47f0e785eaba72ac)},
+                                            {UINT64_C(0xb3f4e093db73a093), UINT64_C(0x59ed216765690f57)},
+                                            {UINT64_C(0xe0f218b8d25088b8), UINT64_C(0x306869c13ec3532d)},
+                                            {UINT64_C(0x8c974f7383725573), UINT64_C(0x1e414218c73a13fc)},
+                                            {UINT64_C(0xafbd2350644eeacf), UINT64_C(0xe5d1929ef90898fb)},
+                                            {UINT64_C(0xdbac6c247d62a583), UINT64_C(0xdf45f746b74abf3a)},
+                                            {UINT64_C(0x894bc396ce5da772), UINT64_C(0x6b8bba8c328eb784)},
+                                            {UINT64_C(0xab9eb47c81f5114f), UINT64_C(0x066ea92f3f326565)},
+                                            {UINT64_C(0xd686619ba27255a2), UINT64_C(0xc80a537b0efefebe)},
+                                            {UINT64_C(0x8613fd0145877585), UINT64_C(0xbd06742ce95f5f37)},
+                                            {UINT64_C(0xa798fc4196e952e7), UINT64_C(0x2c48113823b73705)},
+                                            {UINT64_C(0xd17f3b51fca3a7a0), UINT64_C(0xf75a15862ca504c6)},
+                                            {UINT64_C(0x82ef85133de648c4), UINT64_C(0x9a984d73dbe722fc)},
+                                            {UINT64_C(0xa3ab66580d5fdaf5), UINT64_C(0xc13e60d0d2e0ebbb)},
+                                            {UINT64_C(0xcc963fee10b7d1b3), UINT64_C(0x318df905079926a9)},
+                                            {UINT64_C(0xffbbcfe994e5c61f), UINT64_C(0xfdf17746497f7053)},
+                                            {UINT64_C(0x9fd561f1fd0f9bd3), UINT64_C(0xfeb6ea8bedefa634)},
+                                            {UINT64_C(0xc7caba6e7c5382c8), UINT64_C(0xfe64a52ee96b8fc1)},
+                                            {UINT64_C(0xf9bd690a1b68637b), UINT64_C(0x3dfdce7aa3c673b1)},
+                                            {UINT64_C(0x9c1661a651213e2d), UINT64_C(0x06bea10ca65c084f)},
+                                            {UINT64_C(0xc31bfa0fe5698db8), UINT64_C(0x486e494fcff30a63)},
+                                            {UINT64_C(0xf3e2f893dec3f126), UINT64_C(0x5a89dba3c3efccfb)},
+                                            {UINT64_C(0x986ddb5c6b3a76b7), UINT64_C(0xf89629465a75e01d)},
+                                            {UINT64_C(0xbe89523386091465), UINT64_C(0xf6bbb397f1135824)},
+                                            {UINT64_C(0xee2ba6c0678b597f), UINT64_C(0x746aa07ded582e2d)},
+                                            {UINT64_C(0x94db483840b717ef), UINT64_C(0xa8c2a44eb4571cdd)},
+                                            {UINT64_C(0xba121a4650e4ddeb), UINT64_C(0x92f34d62616ce414)},
+                                            {UINT64_C(0xe896a0d7e51e1566), UINT64_C(0x77b020baf9c81d18)},
+                                            {UINT64_C(0x915e2486ef32cd60), UINT64_C(0x0ace1474dc1d122f)},
+                                            {UINT64_C(0xb5b5ada8aaff80b8), UINT64_C(0x0d819992132456bb)},
+                                            {UINT64_C(0xe3231912d5bf60e6), UINT64_C(0x10e1fff697ed6c6a)},
+                                            {UINT64_C(0x8df5efabc5979c8f), UINT64_C(0xca8d3ffa1ef463c2)},
+                                            {UINT64_C(0xb1736b96b6fd83b3), UINT64_C(0xbd308ff8a6b17cb3)},
+                                            {UINT64_C(0xddd0467c64bce4a0), UINT64_C(0xac7cb3f6d05ddbdf)},
+                                            {UINT64_C(0x8aa22c0dbef60ee4), UINT64_C(0x6bcdf07a423aa96c)},
+                                            {UINT64_C(0xad4ab7112eb3929d), UINT64_C(0x86c16c98d2c953c7)},
+                                            {UINT64_C(0xd89d64d57a607744), UINT64_C(0xe871c7bf077ba8b8)},
+                                            {UINT64_C(0x87625f056c7c4a8b), UINT64_C(0x11471cd764ad4973)},
+                                            {UINT64_C(0xa93af6c6c79b5d2d), UINT64_C(0xd598e40d3dd89bd0)},
+                                            {UINT64_C(0xd389b47879823479), UINT64_C(0x4aff1d108d4ec2c4)},
+                                            {UINT64_C(0x843610cb4bf160cb), UINT64_C(0xcedf722a585139bb)},
+                                            {UINT64_C(0xa54394fe1eedb8fe), UINT64_C(0xc2974eb4ee658829)},
+                                            {UINT64_C(0xce947a3da6a9273e), UINT64_C(0x733d226229feea33)},
+                                            {UINT64_C(0x811ccc668829b887), UINT64_C(0x0806357d5a3f5260)},
+                                            {UINT64_C(0xa163ff802a3426a8), UINT64_C(0xca07c2dcb0cf26f8)},
+                                            {UINT64_C(0xc9bcff6034c13052), UINT64_C(0xfc89b393dd02f0b6)},
+                                            {UINT64_C(0xfc2c3f3841f17c67), UINT64_C(0xbbac2078d443ace3)},
+                                            {UINT64_C(0x9d9ba7832936edc0), UINT64_C(0xd54b944b84aa4c0e)},
+                                            {UINT64_C(0xc5029163f384a931), UINT64_C(0x0a9e795e65d4df12)},
+                                            {UINT64_C(0xf64335bcf065d37d), UINT64_C(0x4d4617b5ff4a16d6)},
+                                            {UINT64_C(0x99ea0196163fa42e), UINT64_C(0x504bced1bf8e4e46)},
+                                            {UINT64_C(0xc06481fb9bcf8d39), UINT64_C(0xe45ec2862f71e1d7)},
+                                            {UINT64_C(0xf07da27a82c37088), UINT64_C(0x5d767327bb4e5a4d)},
+                                            {UINT64_C(0x964e858c91ba2655), UINT64_C(0x3a6a07f8d510f870)},
+                                            {UINT64_C(0xbbe226efb628afea), UINT64_C(0x890489f70a55368c)},
+                                            {UINT64_C(0xeadab0aba3b2dbe5), UINT64_C(0x2b45ac74ccea842f)},
+                                            {UINT64_C(0x92c8ae6b464fc96f), UINT64_C(0x3b0b8bc90012929e)},
+                                            {UINT64_C(0xb77ada0617e3bbcb), UINT64_C(0x09ce6ebb40173745)},
+                                            {UINT64_C(0xe55990879ddcaabd), UINT64_C(0xcc420a6a101d0516)},
+                                            {UINT64_C(0x8f57fa54c2a9eab6), UINT64_C(0x9fa946824a12232e)},
+                                            {UINT64_C(0xb32df8e9f3546564), UINT64_C(0x47939822dc96abfa)},
+                                            {UINT64_C(0xdff9772470297ebd), UINT64_C(0x59787e2b93bc56f8)},
+                                            {UINT64_C(0x8bfbea76c619ef36), UINT64_C(0x57eb4edb3c55b65b)},
+                                            {UINT64_C(0xaefae51477a06b03), UINT64_C(0xede622920b6b23f2)},
+                                            {UINT64_C(0xdab99e59958885c4), UINT64_C(0xe95fab368e45ecee)},
+                                            {UINT64_C(0x88b402f7fd75539b), UINT64_C(0x11dbcb0218ebb415)},
+                                            {UINT64_C(0xaae103b5fcd2a881), UINT64_C(0xd652bdc29f26a11a)},
+                                            {UINT64_C(0xd59944a37c0752a2), UINT64_C(0x4be76d3346f04960)},
+                                            {UINT64_C(0x857fcae62d8493a5), UINT64_C(0x6f70a4400c562ddc)},
+                                            {UINT64_C(0xa6dfbd9fb8e5b88e), UINT64_C(0xcb4ccd500f6bb953)},
+                                            {UINT64_C(0xd097ad07a71f26b2), UINT64_C(0x7e2000a41346a7a8)},
+                                            {UINT64_C(0x825ecc24c873782f), UINT64_C(0x8ed400668c0c28c9)},
+                                            {UINT64_C(0xa2f67f2dfa90563b), UINT64_C(0x728900802f0f32fb)},
+                                            {UINT64_C(0xcbb41ef979346bca), UINT64_C(0x4f2b40a03ad2ffba)},
+                                            {UINT64_C(0xfea126b7d78186bc), UINT64_C(0xe2f610c84987bfa9)},
+                                            {UINT64_C(0x9f24b832e6b0f436), UINT64_C(0x0dd9ca7d2df4d7ca)},
+                                            {UINT64_C(0xc6ede63fa05d3143), UINT64_C(0x91503d1c79720dbc)},
+                                            {UINT64_C(0xf8a95fcf88747d94), UINT64_C(0x75a44c6397ce912b)},
+                                            {UINT64_C(0x9b69dbe1b548ce7c), UINT64_C(0xc986afbe3ee11abb)},
+                                            {UINT64_C(0xc24452da229b021b), UINT64_C(0xfbe85badce996169)},
+                                            {UINT64_C(0xf2d56790ab41c2a2), UINT64_C(0xfae27299423fb9c4)},
+                                            {UINT64_C(0x97c560ba6b0919a5), UINT64_C(0xdccd879fc967d41b)},
+                                            {UINT64_C(0xbdb6b8e905cb600f), UINT64_C(0x5400e987bbc1c921)},
+                                            {UINT64_C(0xed246723473e3813), UINT64_C(0x290123e9aab23b69)},
+                                            {UINT64_C(0x9436c0760c86e30b), UINT64_C(0xf9a0b6720aaf6522)},
+                                            {UINT64_C(0xb94470938fa89bce), UINT64_C(0xf808e40e8d5b3e6a)},
+                                            {UINT64_C(0xe7958cb87392c2c2), UINT64_C(0xb60b1d1230b20e05)},
+                                            {UINT64_C(0x90bd77f3483bb9b9), UINT64_C(0xb1c6f22b5e6f48c3)},
+                                            {UINT64_C(0xb4ecd5f01a4aa828), UINT64_C(0x1e38aeb6360b1af4)},
+                                            {UINT64_C(0xe2280b6c20dd5232), UINT64_C(0x25c6da63c38de1b1)},
+                                            {UINT64_C(0x8d590723948a535f), UINT64_C(0x579c487e5a38ad0f)},
+                                            {UINT64_C(0xb0af48ec79ace837), UINT64_C(0x2d835a9df0c6d852)},
+                                            {UINT64_C(0xdcdb1b2798182244), UINT64_C(0xf8e431456cf88e66)},
+                                            {UINT64_C(0x8a08f0f8bf0f156b), UINT64_C(0x1b8e9ecb641b5900)},
+                                            {UINT64_C(0xac8b2d36eed2dac5), UINT64_C(0xe272467e3d222f40)},
+                                            {UINT64_C(0xd7adf884aa879177), UINT64_C(0x5b0ed81dcc6abb10)},
+                                            {UINT64_C(0x86ccbb52ea94baea), UINT64_C(0x98e947129fc2b4ea)},
+                                            {UINT64_C(0xa87fea27a539e9a5), UINT64_C(0x3f2398d747b36225)},
+                                            {UINT64_C(0xd29fe4b18e88640e), UINT64_C(0x8eec7f0d19a03aae)},
+                                            {UINT64_C(0x83a3eeeef9153e89), UINT64_C(0x1953cf68300424ad)},
+                                            {UINT64_C(0xa48ceaaab75a8e2b), UINT64_C(0x5fa8c3423c052dd8)},
+                                            {UINT64_C(0xcdb02555653131b6), UINT64_C(0x3792f412cb06794e)},
+                                            {UINT64_C(0x808e17555f3ebf11), UINT64_C(0xe2bbd88bbee40bd1)},
+                                            {UINT64_C(0xa0b19d2ab70e6ed6), UINT64_C(0x5b6aceaeae9d0ec5)},
+                                            {UINT64_C(0xc8de047564d20a8b), UINT64_C(0xf245825a5a445276)},
+                                            {UINT64_C(0xfb158592be068d2e), UINT64_C(0xeed6e2f0f0d56713)},
+                                            {UINT64_C(0x9ced737bb6c4183d), UINT64_C(0x55464dd69685606c)},
+                                            {UINT64_C(0xc428d05aa4751e4c), UINT64_C(0xaa97e14c3c26b887)},
+                                            {UINT64_C(0xf53304714d9265df), UINT64_C(0xd53dd99f4b3066a9)},
+                                            {UINT64_C(0x993fe2c6d07b7fab), UINT64_C(0xe546a8038efe402a)},
+                                            {UINT64_C(0xbf8fdb78849a5f96), UINT64_C(0xde98520472bdd034)},
+                                            {UINT64_C(0xef73d256a5c0f77c), UINT64_C(0x963e66858f6d4441)},
+                                            {UINT64_C(0x95a8637627989aad), UINT64_C(0xdde7001379a44aa9)},
+                                            {UINT64_C(0xbb127c53b17ec159), UINT64_C(0x5560c018580d5d53)},
+                                            {UINT64_C(0xe9d71b689dde71af), UINT64_C(0xaab8f01e6e10b4a7)},
+                                            {UINT64_C(0x9226712162ab070d), UINT64_C(0xcab3961304ca70e9)},
+                                            {UINT64_C(0xb6b00d69bb55c8d1), UINT64_C(0x3d607b97c5fd0d23)},
+                                            {UINT64_C(0xe45c10c42a2b3b05), UINT64_C(0x8cb89a7db77c506b)},
+                                            {UINT64_C(0x8eb98a7a9a5b04e3), UINT64_C(0x77f3608e92adb243)},
+                                            {UINT64_C(0xb267ed1940f1c61c), UINT64_C(0x55f038b237591ed4)},
+                                            {UINT64_C(0xdf01e85f912e37a3), UINT64_C(0x6b6c46dec52f6689)},
+                                            {UINT64_C(0x8b61313bbabce2c6), UINT64_C(0x2323ac4b3b3da016)},
+                                            {UINT64_C(0xae397d8aa96c1b77), UINT64_C(0xabec975e0a0d081b)},
+                                            {UINT64_C(0xd9c7dced53c72255), UINT64_C(0x96e7bd358c904a22)},
+                                            {UINT64_C(0x881cea14545c7575), UINT64_C(0x7e50d64177da2e55)},
+                                            {UINT64_C(0xaa242499697392d2), UINT64_C(0xdde50bd1d5d0b9ea)},
+                                            {UINT64_C(0xd4ad2dbfc3d07787), UINT64_C(0x955e4ec64b44e865)},
+                                            {UINT64_C(0x84ec3c97da624ab4), UINT64_C(0xbd5af13bef0b113f)},
+                                            {UINT64_C(0xa6274bbdd0fadd61), UINT64_C(0xecb1ad8aeacdd58f)},
+                                            {UINT64_C(0xcfb11ead453994ba), UINT64_C(0x67de18eda5814af3)},
+                                            {UINT64_C(0x81ceb32c4b43fcf4), UINT64_C(0x80eacf948770ced8)},
+                                            {UINT64_C(0xa2425ff75e14fc31), UINT64_C(0xa1258379a94d028e)},
+                                            {UINT64_C(0xcad2f7f5359a3b3e), UINT64_C(0x096ee45813a04331)},
+                                            {UINT64_C(0xfd87b5f28300ca0d), UINT64_C(0x8bca9d6e188853fd)},
+                                            {UINT64_C(0x9e74d1b791e07e48), UINT64_C(0x775ea264cf55347e)},
+                                            {UINT64_C(0xc612062576589dda), UINT64_C(0x95364afe032a819e)},
+                                            {UINT64_C(0xf79687aed3eec551), UINT64_C(0x3a83ddbd83f52205)},
+                                            {UINT64_C(0x9abe14cd44753b52), UINT64_C(0xc4926a9672793543)},
+                                            {UINT64_C(0xc16d9a0095928a27), UINT64_C(0x75b7053c0f178294)},
+                                            {UINT64_C(0xf1c90080baf72cb1), UINT64_C(0x5324c68b12dd6339)},
+                                            {UINT64_C(0x971da05074da7bee), UINT64_C(0xd3f6fc16ebca5e04)},
+                                            {UINT64_C(0xbce5086492111aea), UINT64_C(0x88f4bb1ca6bcf585)},
+                                            {UINT64_C(0xec1e4a7db69561a5), UINT64_C(0x2b31e9e3d06c32e6)},
+                                            {UINT64_C(0x9392ee8e921d5d07), UINT64_C(0x3aff322e62439fd0)},
+                                            {UINT64_C(0xb877aa3236a4b449), UINT64_C(0x09befeb9fad487c3)},
+                                            {UINT64_C(0xe69594bec44de15b), UINT64_C(0x4c2ebe687989a9b4)},
+                                            {UINT64_C(0x901d7cf73ab0acd9), UINT64_C(0x0f9d37014bf60a11)},
+                                            {UINT64_C(0xb424dc35095cd80f), UINT64_C(0x538484c19ef38c95)},
+                                            {UINT64_C(0xe12e13424bb40e13), UINT64_C(0x2865a5f206b06fba)},
+                                            {UINT64_C(0x8cbccc096f5088cb), UINT64_C(0xf93f87b7442e45d4)},
+                                            {UINT64_C(0xafebff0bcb24aafe), UINT64_C(0xf78f69a51539d749)},
+                                            {UINT64_C(0xdbe6fecebdedd5be), UINT64_C(0xb573440e5a884d1c)},
+                                            {UINT64_C(0x89705f4136b4a597), UINT64_C(0x31680a88f8953031)},
+                                            {UINT64_C(0xabcc77118461cefc), UINT64_C(0xfdc20d2b36ba7c3e)},
+                                            {UINT64_C(0xd6bf94d5e57a42bc), UINT64_C(0x3d32907604691b4d)},
+                                            {UINT64_C(0x8637bd05af6c69b5), UINT64_C(0xa63f9a49c2c1b110)},
+                                            {UINT64_C(0xa7c5ac471b478423), UINT64_C(0x0fcf80dc33721d54)},
+                                            {UINT64_C(0xd1b71758e219652b), UINT64_C(0xd3c36113404ea4a9)},
+                                            {UINT64_C(0x83126e978d4fdf3b), UINT64_C(0x645a1cac083126ea)},
+                                            {UINT64_C(0xa3d70a3d70a3d70a), UINT64_C(0x3d70a3d70a3d70a4)},
+                                            {UINT64_C(0xcccccccccccccccc), UINT64_C(0xcccccccccccccccd)},
+                                            {UINT64_C(0x8000000000000000), UINT64_C(0x0000000000000000)},
+                                            {UINT64_C(0xa000000000000000), UINT64_C(0x0000000000000000)},
+                                            {UINT64_C(0xc800000000000000), UINT64_C(0x0000000000000000)},
+                                            {UINT64_C(0xfa00000000000000), UINT64_C(0x0000000000000000)},
+                                            {UINT64_C(0x9c40000000000000), UINT64_C(0x0000000000000000)},
+                                            {UINT64_C(0xc350000000000000), UINT64_C(0x0000000000000000)},
+                                            {UINT64_C(0xf424000000000000), UINT64_C(0x0000000000000000)},
+                                            {UINT64_C(0x9896800000000000), UINT64_C(0x0000000000000000)},
+                                            {UINT64_C(0xbebc200000000000), UINT64_C(0x0000000000000000)},
+                                            {UINT64_C(0xee6b280000000000), UINT64_C(0x0000000000000000)},
+                                            {UINT64_C(0x9502f90000000000), UINT64_C(0x0000000000000000)},
+                                            {UINT64_C(0xba43b74000000000), UINT64_C(0x0000000000000000)},
+                                            {UINT64_C(0xe8d4a51000000000), UINT64_C(0x0000000000000000)},
+                                            {UINT64_C(0x9184e72a00000000), UINT64_C(0x0000000000000000)},
+                                            {UINT64_C(0xb5e620f480000000), UINT64_C(0x0000000000000000)},
+                                            {UINT64_C(0xe35fa931a0000000), UINT64_C(0x0000000000000000)},
+                                            {UINT64_C(0x8e1bc9bf04000000), UINT64_C(0x0000000000000000)},
+                                            {UINT64_C(0xb1a2bc2ec5000000), UINT64_C(0x0000000000000000)},
+                                            {UINT64_C(0xde0b6b3a76400000), UINT64_C(0x0000000000000000)},
+                                            {UINT64_C(0x8ac7230489e80000), UINT64_C(0x0000000000000000)},
+                                            {UINT64_C(0xad78ebc5ac620000), UINT64_C(0x0000000000000000)},
+                                            {UINT64_C(0xd8d726b7177a8000), UINT64_C(0x0000000000000000)},
+                                            {UINT64_C(0x878678326eac9000), UINT64_C(0x0000000000000000)},
+                                            {UINT64_C(0xa968163f0a57b400), UINT64_C(0x0000000000000000)},
+                                            {UINT64_C(0xd3c21bcecceda100), UINT64_C(0x0000000000000000)},
+                                            {UINT64_C(0x84595161401484a0), UINT64_C(0x0000000000000000)},
+                                            {UINT64_C(0xa56fa5b99019a5c8), UINT64_C(0x0000000000000000)},
+                                            {UINT64_C(0xcecb8f27f4200f3a), UINT64_C(0x0000000000000000)},
+                                            {UINT64_C(0x813f3978f8940984), UINT64_C(0x4000000000000000)},
+                                            {UINT64_C(0xa18f07d736b90be5), UINT64_C(0x5000000000000000)},
+                                            {UINT64_C(0xc9f2c9cd04674ede), UINT64_C(0xa400000000000000)},
+                                            {UINT64_C(0xfc6f7c4045812296), UINT64_C(0x4d00000000000000)},
+                                            {UINT64_C(0x9dc5ada82b70b59d), UINT64_C(0xf020000000000000)},
+                                            {UINT64_C(0xc5371912364ce305), UINT64_C(0x6c28000000000000)},
+                                            {UINT64_C(0xf684df56c3e01bc6), UINT64_C(0xc732000000000000)},
+                                            {UINT64_C(0x9a130b963a6c115c), UINT64_C(0x3c7f400000000000)},
+                                            {UINT64_C(0xc097ce7bc90715b3), UINT64_C(0x4b9f100000000000)},
+                                            {UINT64_C(0xf0bdc21abb48db20), UINT64_C(0x1e86d40000000000)},
+                                            {UINT64_C(0x96769950b50d88f4), UINT64_C(0x1314448000000000)},
+                                            {UINT64_C(0xbc143fa4e250eb31), UINT64_C(0x17d955a000000000)},
+                                            {UINT64_C(0xeb194f8e1ae525fd), UINT64_C(0x5dcfab0800000000)},
+                                            {UINT64_C(0x92efd1b8d0cf37be), UINT64_C(0x5aa1cae500000000)},
+                                            {UINT64_C(0xb7abc627050305ad), UINT64_C(0xf14a3d9e40000000)},
+                                            {UINT64_C(0xe596b7b0c643c719), UINT64_C(0x6d9ccd05d0000000)},
+                                            {UINT64_C(0x8f7e32ce7bea5c6f), UINT64_C(0xe4820023a2000000)},
+                                            {UINT64_C(0xb35dbf821ae4f38b), UINT64_C(0xdda2802c8a800000)},
+                                            {UINT64_C(0xe0352f62a19e306e), UINT64_C(0xd50b2037ad200000)},
+                                            {UINT64_C(0x8c213d9da502de45), UINT64_C(0x4526f422cc340000)},
+                                            {UINT64_C(0xaf298d050e4395d6), UINT64_C(0x9670b12b7f410000)},
+                                            {UINT64_C(0xdaf3f04651d47b4c), UINT64_C(0x3c0cdd765f114000)},
+                                            {UINT64_C(0x88d8762bf324cd0f), UINT64_C(0xa5880a69fb6ac800)},
+                                            {UINT64_C(0xab0e93b6efee0053), UINT64_C(0x8eea0d047a457a00)},
+                                            {UINT64_C(0xd5d238a4abe98068), UINT64_C(0x72a4904598d6d880)},
+                                            {UINT64_C(0x85a36366eb71f041), UINT64_C(0x47a6da2b7f864750)},
+                                            {UINT64_C(0xa70c3c40a64e6c51), UINT64_C(0x999090b65f67d924)},
+                                            {UINT64_C(0xd0cf4b50cfe20765), UINT64_C(0xfff4b4e3f741cf6d)},
+                                            {UINT64_C(0x82818f1281ed449f), UINT64_C(0xbff8f10e7a8921a5)},
+                                            {UINT64_C(0xa321f2d7226895c7), UINT64_C(0xaff72d52192b6a0e)},
+                                            {UINT64_C(0xcbea6f8ceb02bb39), UINT64_C(0x9bf4f8a69f764491)},
+                                            {UINT64_C(0xfee50b7025c36a08), UINT64_C(0x02f236d04753d5b5)},
+                                            {UINT64_C(0x9f4f2726179a2245), UINT64_C(0x01d762422c946591)},
+                                            {UINT64_C(0xc722f0ef9d80aad6), UINT64_C(0x424d3ad2b7b97ef6)},
+                                            {UINT64_C(0xf8ebad2b84e0d58b), UINT64_C(0xd2e0898765a7deb3)},
+                                            {UINT64_C(0x9b934c3b330c8577), UINT64_C(0x63cc55f49f88eb30)},
+                                            {UINT64_C(0xc2781f49ffcfa6d5), UINT64_C(0x3cbf6b71c76b25fc)},
+                                            {UINT64_C(0xf316271c7fc3908a), UINT64_C(0x8bef464e3945ef7b)},
+                                            {UINT64_C(0x97edd871cfda3a56), UINT64_C(0x97758bf0e3cbb5ad)},
+                                            {UINT64_C(0xbde94e8e43d0c8ec), UINT64_C(0x3d52eeed1cbea318)},
+                                            {UINT64_C(0xed63a231d4c4fb27), UINT64_C(0x4ca7aaa863ee4bde)},
+                                            {UINT64_C(0x945e455f24fb1cf8), UINT64_C(0x8fe8caa93e74ef6b)},
+                                            {UINT64_C(0xb975d6b6ee39e436), UINT64_C(0xb3e2fd538e122b45)},
+                                            {UINT64_C(0xe7d34c64a9c85d44), UINT64_C(0x60dbbca87196b617)},
+                                            {UINT64_C(0x90e40fbeea1d3a4a), UINT64_C(0xbc8955e946fe31ce)},
+                                            {UINT64_C(0xb51d13aea4a488dd), UINT64_C(0x6babab6398bdbe42)},
+                                            {UINT64_C(0xe264589a4dcdab14), UINT64_C(0xc696963c7eed2dd2)},
+                                            {UINT64_C(0x8d7eb76070a08aec), UINT64_C(0xfc1e1de5cf543ca3)},
+                                            {UINT64_C(0xb0de65388cc8ada8), UINT64_C(0x3b25a55f43294bcc)},
+                                            {UINT64_C(0xdd15fe86affad912), UINT64_C(0x49ef0eb713f39ebf)},
+                                            {UINT64_C(0x8a2dbf142dfcc7ab), UINT64_C(0x6e3569326c784338)},
+                                            {UINT64_C(0xacb92ed9397bf996), UINT64_C(0x49c2c37f07965405)},
+                                            {UINT64_C(0xd7e77a8f87daf7fb), UINT64_C(0xdc33745ec97be907)},
+                                            {UINT64_C(0x86f0ac99b4e8dafd), UINT64_C(0x69a028bb3ded71a4)},
+                                            {UINT64_C(0xa8acd7c0222311bc), UINT64_C(0xc40832ea0d68ce0d)},
+                                            {UINT64_C(0xd2d80db02aabd62b), UINT64_C(0xf50a3fa490c30191)},
+                                            {UINT64_C(0x83c7088e1aab65db), UINT64_C(0x792667c6da79e0fb)},
+                                            {UINT64_C(0xa4b8cab1a1563f52), UINT64_C(0x577001b891185939)},
+                                            {UINT64_C(0xcde6fd5e09abcf26), UINT64_C(0xed4c0226b55e6f87)},
+                                            {UINT64_C(0x80b05e5ac60b6178), UINT64_C(0x544f8158315b05b5)},
+                                            {UINT64_C(0xa0dc75f1778e39d6), UINT64_C(0x696361ae3db1c722)},
+                                            {UINT64_C(0xc913936dd571c84c), UINT64_C(0x03bc3a19cd1e38ea)},
+                                            {UINT64_C(0xfb5878494ace3a5f), UINT64_C(0x04ab48a04065c724)},
+                                            {UINT64_C(0x9d174b2dcec0e47b), UINT64_C(0x62eb0d64283f9c77)},
+                                            {UINT64_C(0xc45d1df942711d9a), UINT64_C(0x3ba5d0bd324f8395)},
+                                            {UINT64_C(0xf5746577930d6500), UINT64_C(0xca8f44ec7ee3647a)},
+                                            {UINT64_C(0x9968bf6abbe85f20), UINT64_C(0x7e998b13cf4e1ecc)},
+                                            {UINT64_C(0xbfc2ef456ae276e8), UINT64_C(0x9e3fedd8c321a67f)},
+                                            {UINT64_C(0xefb3ab16c59b14a2), UINT64_C(0xc5cfe94ef3ea101f)},
+                                            {UINT64_C(0x95d04aee3b80ece5), UINT64_C(0xbba1f1d158724a13)},
+                                            {UINT64_C(0xbb445da9ca61281f), UINT64_C(0x2a8a6e45ae8edc98)},
+                                            {UINT64_C(0xea1575143cf97226), UINT64_C(0xf52d09d71a3293be)},
+                                            {UINT64_C(0x924d692ca61be758), UINT64_C(0x593c2626705f9c57)},
+                                            {UINT64_C(0xb6e0c377cfa2e12e), UINT64_C(0x6f8b2fb00c77836d)},
+                                            {UINT64_C(0xe498f455c38b997a), UINT64_C(0x0b6dfb9c0f956448)},
+                                            {UINT64_C(0x8edf98b59a373fec), UINT64_C(0x4724bd4189bd5ead)},
+                                            {UINT64_C(0xb2977ee300c50fe7), UINT64_C(0x58edec91ec2cb658)},
+                                            {UINT64_C(0xdf3d5e9bc0f653e1), UINT64_C(0x2f2967b66737e3ee)},
+                                            {UINT64_C(0x8b865b215899f46c), UINT64_C(0xbd79e0d20082ee75)},
+                                            {UINT64_C(0xae67f1e9aec07187), UINT64_C(0xecd8590680a3aa12)},
+                                            {UINT64_C(0xda01ee641a708de9), UINT64_C(0xe80e6f4820cc9496)},
+                                            {UINT64_C(0x884134fe908658b2), UINT64_C(0x3109058d147fdcde)},
+                                            {UINT64_C(0xaa51823e34a7eede), UINT64_C(0xbd4b46f0599fd416)},
+                                            {UINT64_C(0xd4e5e2cdc1d1ea96), UINT64_C(0x6c9e18ac7007c91b)},
+                                            {UINT64_C(0x850fadc09923329e), UINT64_C(0x03e2cf6bc604ddb1)},
+                                            {UINT64_C(0xa6539930bf6bff45), UINT64_C(0x84db8346b786151d)},
+                                            {UINT64_C(0xcfe87f7cef46ff16), UINT64_C(0xe612641865679a64)},
+                                            {UINT64_C(0x81f14fae158c5f6e), UINT64_C(0x4fcb7e8f3f60c07f)},
+                                            {UINT64_C(0xa26da3999aef7749), UINT64_C(0xe3be5e330f38f09e)},
+                                            {UINT64_C(0xcb090c8001ab551c), UINT64_C(0x5cadf5bfd3072cc6)},
+                                            {UINT64_C(0xfdcb4fa002162a63), UINT64_C(0x73d9732fc7c8f7f7)},
+                                            {UINT64_C(0x9e9f11c4014dda7e), UINT64_C(0x2867e7fddcdd9afb)},
+                                            {UINT64_C(0xc646d63501a1511d), UINT64_C(0xb281e1fd541501b9)},
+                                            {UINT64_C(0xf7d88bc24209a565), UINT64_C(0x1f225a7ca91a4227)},
+                                            {UINT64_C(0x9ae757596946075f), UINT64_C(0x3375788de9b06959)},
+                                            {UINT64_C(0xc1a12d2fc3978937), UINT64_C(0x0052d6b1641c83af)},
+                                            {UINT64_C(0xf209787bb47d6b84), UINT64_C(0xc0678c5dbd23a49b)},
+                                            {UINT64_C(0x9745eb4d50ce6332), UINT64_C(0xf840b7ba963646e1)},
+                                            {UINT64_C(0xbd176620a501fbff), UINT64_C(0xb650e5a93bc3d899)},
+                                            {UINT64_C(0xec5d3fa8ce427aff), UINT64_C(0xa3e51f138ab4cebf)},
+                                            {UINT64_C(0x93ba47c980e98cdf), UINT64_C(0xc66f336c36b10138)},
+                                            {UINT64_C(0xb8a8d9bbe123f017), UINT64_C(0xb80b0047445d4185)},
+                                            {UINT64_C(0xe6d3102ad96cec1d), UINT64_C(0xa60dc059157491e6)},
+                                            {UINT64_C(0x9043ea1ac7e41392), UINT64_C(0x87c89837ad68db30)},
+                                            {UINT64_C(0xb454e4a179dd1877), UINT64_C(0x29babe4598c311fc)},
+                                            {UINT64_C(0xe16a1dc9d8545e94), UINT64_C(0xf4296dd6fef3d67b)},
+                                            {UINT64_C(0x8ce2529e2734bb1d), UINT64_C(0x1899e4a65f58660d)},
+                                            {UINT64_C(0xb01ae745b101e9e4), UINT64_C(0x5ec05dcff72e7f90)},
+                                            {UINT64_C(0xdc21a1171d42645d), UINT64_C(0x76707543f4fa1f74)},
+                                            {UINT64_C(0x899504ae72497eba), UINT64_C(0x6a06494a791c53a9)},
+                                            {UINT64_C(0xabfa45da0edbde69), UINT64_C(0x0487db9d17636893)},
+                                            {UINT64_C(0xd6f8d7509292d603), UINT64_C(0x45a9d2845d3c42b7)},
+                                            {UINT64_C(0x865b86925b9bc5c2), UINT64_C(0x0b8a2392ba45a9b3)},
+                                            {UINT64_C(0xa7f26836f282b732), UINT64_C(0x8e6cac7768d7141f)},
+                                            {UINT64_C(0xd1ef0244af2364ff), UINT64_C(0x3207d795430cd927)},
+                                            {UINT64_C(0x8335616aed761f1f), UINT64_C(0x7f44e6bd49e807b9)},
+                                            {UINT64_C(0xa402b9c5a8d3a6e7), UINT64_C(0x5f16206c9c6209a7)},
+                                            {UINT64_C(0xcd036837130890a1), UINT64_C(0x36dba887c37a8c10)},
+                                            {UINT64_C(0x802221226be55a64), UINT64_C(0xc2494954da2c978a)},
+                                            {UINT64_C(0xa02aa96b06deb0fd), UINT64_C(0xf2db9baa10b7bd6d)},
+                                            {UINT64_C(0xc83553c5c8965d3d), UINT64_C(0x6f92829494e5acc8)},
+                                            {UINT64_C(0xfa42a8b73abbf48c), UINT64_C(0xcb772339ba1f17fa)},
+                                            {UINT64_C(0x9c69a97284b578d7), UINT64_C(0xff2a760414536efc)},
+                                            {UINT64_C(0xc38413cf25e2d70d), UINT64_C(0xfef5138519684abb)},
+                                            {UINT64_C(0xf46518c2ef5b8cd1), UINT64_C(0x7eb258665fc25d6a)},
+                                            {UINT64_C(0x98bf2f79d5993802), UINT64_C(0xef2f773ffbd97a62)},
+                                            {UINT64_C(0xbeeefb584aff8603), UINT64_C(0xaafb550ffacfd8fb)},
+                                            {UINT64_C(0xeeaaba2e5dbf6784), UINT64_C(0x95ba2a53f983cf39)},
+                                            {UINT64_C(0x952ab45cfa97a0b2), UINT64_C(0xdd945a747bf26184)},
+                                            {UINT64_C(0xba756174393d88df), UINT64_C(0x94f971119aeef9e5)},
+                                            {UINT64_C(0xe912b9d1478ceb17), UINT64_C(0x7a37cd5601aab85e)},
+                                            {UINT64_C(0x91abb422ccb812ee), UINT64_C(0xac62e055c10ab33b)},
+                                            {UINT64_C(0xb616a12b7fe617aa), UINT64_C(0x577b986b314d600a)},
+                                            {UINT64_C(0xe39c49765fdf9d94), UINT64_C(0xed5a7e85fda0b80c)},
+                                            {UINT64_C(0x8e41ade9fbebc27d), UINT64_C(0x14588f13be847308)},
+                                            {UINT64_C(0xb1d219647ae6b31c), UINT64_C(0x596eb2d8ae258fc9)},
+                                            {UINT64_C(0xde469fbd99a05fe3), UINT64_C(0x6fca5f8ed9aef3bc)},
+                                            {UINT64_C(0x8aec23d680043bee), UINT64_C(0x25de7bb9480d5855)},
+                                            {UINT64_C(0xada72ccc20054ae9), UINT64_C(0xaf561aa79a10ae6b)},
+                                            {UINT64_C(0xd910f7ff28069da4), UINT64_C(0x1b2ba1518094da05)},
+                                            {UINT64_C(0x87aa9aff79042286), UINT64_C(0x90fb44d2f05d0843)},
+                                            {UINT64_C(0xa99541bf57452b28), UINT64_C(0x353a1607ac744a54)},
+                                            {UINT64_C(0xd3fa922f2d1675f2), UINT64_C(0x42889b8997915ce9)},
+                                            {UINT64_C(0x847c9b5d7c2e09b7), UINT64_C(0x69956135febada12)},
+                                            {UINT64_C(0xa59bc234db398c25), UINT64_C(0x43fab9837e699096)},
+                                            {UINT64_C(0xcf02b2c21207ef2e), UINT64_C(0x94f967e45e03f4bc)},
+                                            {UINT64_C(0x8161afb94b44f57d), UINT64_C(0x1d1be0eebac278f6)},
+                                            {UINT64_C(0xa1ba1ba79e1632dc), UINT64_C(0x6462d92a69731733)},
+                                            {UINT64_C(0xca28a291859bbf93), UINT64_C(0x7d7b8f7503cfdcff)},
+                                            {UINT64_C(0xfcb2cb35e702af78), UINT64_C(0x5cda735244c3d43f)},
+                                            {UINT64_C(0x9defbf01b061adab), UINT64_C(0x3a0888136afa64a8)},
+                                            {UINT64_C(0xc56baec21c7a1916), UINT64_C(0x088aaa1845b8fdd1)},
+                                            {UINT64_C(0xf6c69a72a3989f5b), UINT64_C(0x8aad549e57273d46)},
+                                            {UINT64_C(0x9a3c2087a63f6399), UINT64_C(0x36ac54e2f678864c)},
+                                            {UINT64_C(0xc0cb28a98fcf3c7f), UINT64_C(0x84576a1bb416a7de)},
+                                            {UINT64_C(0xf0fdf2d3f3c30b9f), UINT64_C(0x656d44a2a11c51d6)},
+                                            {UINT64_C(0x969eb7c47859e743), UINT64_C(0x9f644ae5a4b1b326)},
+                                            {UINT64_C(0xbc4665b596706114), UINT64_C(0x873d5d9f0dde1fef)},
+                                            {UINT64_C(0xeb57ff22fc0c7959), UINT64_C(0xa90cb506d155a7eb)},
+                                            {UINT64_C(0x9316ff75dd87cbd8), UINT64_C(0x09a7f12442d588f3)},
+                                            {UINT64_C(0xb7dcbf5354e9bece), UINT64_C(0x0c11ed6d538aeb30)},
+                                            {UINT64_C(0xe5d3ef282a242e81), UINT64_C(0x8f1668c8a86da5fb)},
+                                            {UINT64_C(0x8fa475791a569d10), UINT64_C(0xf96e017d694487bd)},
+                                            {UINT64_C(0xb38d92d760ec4455), UINT64_C(0x37c981dcc395a9ad)},
+                                            {UINT64_C(0xe070f78d3927556a), UINT64_C(0x85bbe253f47b1418)},
+                                            {UINT64_C(0x8c469ab843b89562), UINT64_C(0x93956d7478ccec8f)},
+                                            {UINT64_C(0xaf58416654a6babb), UINT64_C(0x387ac8d1970027b3)},
+                                            {UINT64_C(0xdb2e51bfe9d0696a), UINT64_C(0x06997b05fcc0319f)},
+                                            {UINT64_C(0x88fcf317f22241e2), UINT64_C(0x441fece3bdf81f04)},
+                                            {UINT64_C(0xab3c2fddeeaad25a), UINT64_C(0xd527e81cad7626c4)},
+                                            {UINT64_C(0xd60b3bd56a5586f1), UINT64_C(0x8a71e223d8d3b075)},
+                                            {UINT64_C(0x85c7056562757456), UINT64_C(0xf6872d5667844e4a)},
+                                            {UINT64_C(0xa738c6bebb12d16c), UINT64_C(0xb428f8ac016561dc)},
+                                            {UINT64_C(0xd106f86e69d785c7), UINT64_C(0xe13336d701beba53)},
+                                            {UINT64_C(0x82a45b450226b39c), UINT64_C(0xecc0024661173474)},
+                                            {UINT64_C(0xa34d721642b06084), UINT64_C(0x27f002d7f95d0191)},
+                                            {UINT64_C(0xcc20ce9bd35c78a5), UINT64_C(0x31ec038df7b441f5)},
+                                            {UINT64_C(0xff290242c83396ce), UINT64_C(0x7e67047175a15272)},
+                                            {UINT64_C(0x9f79a169bd203e41), UINT64_C(0x0f0062c6e984d387)},
+                                            {UINT64_C(0xc75809c42c684dd1), UINT64_C(0x52c07b78a3e60869)},
+                                            {UINT64_C(0xf92e0c3537826145), UINT64_C(0xa7709a56ccdf8a83)},
+                                            {UINT64_C(0x9bbcc7a142b17ccb), UINT64_C(0x88a66076400bb692)},
+                                            {UINT64_C(0xc2abf989935ddbfe), UINT64_C(0x6acff893d00ea436)},
+                                            {UINT64_C(0xf356f7ebf83552fe), UINT64_C(0x0583f6b8c4124d44)},
+                                            {UINT64_C(0x98165af37b2153de), UINT64_C(0xc3727a337a8b704b)},
+                                            {UINT64_C(0xbe1bf1b059e9a8d6), UINT64_C(0x744f18c0592e4c5d)},
+                                            {UINT64_C(0xeda2ee1c7064130c), UINT64_C(0x1162def06f79df74)},
+                                            {UINT64_C(0x9485d4d1c63e8be7), UINT64_C(0x8addcb5645ac2ba9)},
+                                            {UINT64_C(0xb9a74a0637ce2ee1), UINT64_C(0x6d953e2bd7173693)},
+                                            {UINT64_C(0xe8111c87c5c1ba99), UINT64_C(0xc8fa8db6ccdd0438)},
+                                            {UINT64_C(0x910ab1d4db9914a0), UINT64_C(0x1d9c9892400a22a3)},
+                                            {UINT64_C(0xb54d5e4a127f59c8), UINT64_C(0x2503beb6d00cab4c)},
+                                            {UINT64_C(0xe2a0b5dc971f303a), UINT64_C(0x2e44ae64840fd61e)},
+                                            {UINT64_C(0x8da471a9de737e24), UINT64_C(0x5ceaecfed289e5d3)},
+                                            {UINT64_C(0xb10d8e1456105dad), UINT64_C(0x7425a83e872c5f48)},
+                                            {UINT64_C(0xdd50f1996b947518), UINT64_C(0xd12f124e28f7771a)},
+                                            {UINT64_C(0x8a5296ffe33cc92f), UINT64_C(0x82bd6b70d99aaa70)},
+                                            {UINT64_C(0xace73cbfdc0bfb7b), UINT64_C(0x636cc64d1001550c)},
+                                            {UINT64_C(0xd8210befd30efa5a), UINT64_C(0x3c47f7e05401aa4f)},
+                                            {UINT64_C(0x8714a775e3e95c78), UINT64_C(0x65acfaec34810a72)},
+                                            {UINT64_C(0xa8d9d1535ce3b396), UINT64_C(0x7f1839a741a14d0e)},
+                                            {UINT64_C(0xd31045a8341ca07c), UINT64_C(0x1ede48111209a051)},
+                                            {UINT64_C(0x83ea2b892091e44d), UINT64_C(0x934aed0aab460433)},
+                                            {UINT64_C(0xa4e4b66b68b65d60), UINT64_C(0xf81da84d56178540)},
+                                            {UINT64_C(0xce1de40642e3f4b9), UINT64_C(0x36251260ab9d668f)},
+                                            {UINT64_C(0x80d2ae83e9ce78f3), UINT64_C(0xc1d72b7c6b42601a)},
+                                            {UINT64_C(0xa1075a24e4421730), UINT64_C(0xb24cf65b8612f820)},
+                                            {UINT64_C(0xc94930ae1d529cfc), UINT64_C(0xdee033f26797b628)},
+                                            {UINT64_C(0xfb9b7cd9a4a7443c), UINT64_C(0x169840ef017da3b2)},
+                                            {UINT64_C(0x9d412e0806e88aa5), UINT64_C(0x8e1f289560ee864f)},
+                                            {UINT64_C(0xc491798a08a2ad4e), UINT64_C(0xf1a6f2bab92a27e3)},
+                                            {UINT64_C(0xf5b5d7ec8acb58a2), UINT64_C(0xae10af696774b1dc)},
+                                            {UINT64_C(0x9991a6f3d6bf1765), UINT64_C(0xacca6da1e0a8ef2a)},
+                                            {UINT64_C(0xbff610b0cc6edd3f), UINT64_C(0x17fd090a58d32af4)},
+                                            {UINT64_C(0xeff394dcff8a948e), UINT64_C(0xddfc4b4cef07f5b1)},
+                                            {UINT64_C(0x95f83d0a1fb69cd9), UINT64_C(0x4abdaf101564f98f)},
+                                            {UINT64_C(0xbb764c4ca7a4440f), UINT64_C(0x9d6d1ad41abe37f2)},
+                                            {UINT64_C(0xea53df5fd18d5513), UINT64_C(0x84c86189216dc5ee)},
+                                            {UINT64_C(0x92746b9be2f8552c), UINT64_C(0x32fd3cf5b4e49bb5)},
+                                            {UINT64_C(0xb7118682dbb66a77), UINT64_C(0x3fbc8c33221dc2a2)},
+                                            {UINT64_C(0xe4d5e82392a40515), UINT64_C(0x0fabaf3feaa5334b)},
+                                            {UINT64_C(0x8f05b1163ba6832d), UINT64_C(0x29cb4d87f2a7400f)},
+                                            {UINT64_C(0xb2c71d5bca9023f8), UINT64_C(0x743e20e9ef511013)},
+                                            {UINT64_C(0xdf78e4b2bd342cf6), UINT64_C(0x914da9246b255417)},
+                                            {UINT64_C(0x8bab8eefb6409c1a), UINT64_C(0x1ad089b6c2f7548f)},
+                                            {UINT64_C(0xae9672aba3d0c320), UINT64_C(0xa184ac2473b529b2)},
+                                            {UINT64_C(0xda3c0f568cc4f3e8), UINT64_C(0xc9e5d72d90a2741f)},
+                                            {UINT64_C(0x8865899617fb1871), UINT64_C(0x7e2fa67c7a658893)},
+                                            {UINT64_C(0xaa7eebfb9df9de8d), UINT64_C(0xddbb901b98feeab8)},
+                                            {UINT64_C(0xd51ea6fa85785631), UINT64_C(0x552a74227f3ea566)},
+                                            {UINT64_C(0x8533285c936b35de), UINT64_C(0xd53a88958f872760)},
+                                            {UINT64_C(0xa67ff273b8460356), UINT64_C(0x8a892abaf368f138)},
+                                            {UINT64_C(0xd01fef10a657842c), UINT64_C(0x2d2b7569b0432d86)},
+                                            {UINT64_C(0x8213f56a67f6b29b), UINT64_C(0x9c3b29620e29fc74)},
+                                            {UINT64_C(0xa298f2c501f45f42), UINT64_C(0x8349f3ba91b47b90)},
+                                            {UINT64_C(0xcb3f2f7642717713), UINT64_C(0x241c70a936219a74)},
+                                            {UINT64_C(0xfe0efb53d30dd4d7), UINT64_C(0xed238cd383aa0111)},
+                                            {UINT64_C(0x9ec95d1463e8a506), UINT64_C(0xf4363804324a40ab)},
+                                            {UINT64_C(0xc67bb4597ce2ce48), UINT64_C(0xb143c6053edcd0d6)},
+                                            {UINT64_C(0xf81aa16fdc1b81da), UINT64_C(0xdd94b7868e94050b)},
+                                            {UINT64_C(0x9b10a4e5e9913128), UINT64_C(0xca7cf2b4191c8327)},
+                                            {UINT64_C(0xc1d4ce1f63f57d72), UINT64_C(0xfd1c2f611f63a3f1)},
+                                            {UINT64_C(0xf24a01a73cf2dccf), UINT64_C(0xbc633b39673c8ced)},
+                                            {UINT64_C(0x976e41088617ca01), UINT64_C(0xd5be0503e085d814)},
+                                            {UINT64_C(0xbd49d14aa79dbc82), UINT64_C(0x4b2d8644d8a74e19)},
+                                            {UINT64_C(0xec9c459d51852ba2), UINT64_C(0xddf8e7d60ed1219f)},
+                                            {UINT64_C(0x93e1ab8252f33b45), UINT64_C(0xcabb90e5c942b504)},
+                                            {UINT64_C(0xb8da1662e7b00a17), UINT64_C(0x3d6a751f3b936244)},
+                                            {UINT64_C(0xe7109bfba19c0c9d), UINT64_C(0x0cc512670a783ad5)},
+                                            {UINT64_C(0x906a617d450187e2), UINT64_C(0x27fb2b80668b24c6)},
+                                            {UINT64_C(0xb484f9dc9641e9da), UINT64_C(0xb1f9f660802dedf7)},
+                                            {UINT64_C(0xe1a63853bbd26451), UINT64_C(0x5e7873f8a0396974)},
+                                            {UINT64_C(0x8d07e33455637eb2), UINT64_C(0xdb0b487b6423e1e9)},
+                                            {UINT64_C(0xb049dc016abc5e5f), UINT64_C(0x91ce1a9a3d2cda63)},
+                                            {UINT64_C(0xdc5c5301c56b75f7), UINT64_C(0x7641a140cc7810fc)},
+                                            {UINT64_C(0x89b9b3e11b6329ba), UINT64_C(0xa9e904c87fcb0a9e)},
+                                            {UINT64_C(0xac2820d9623bf429), UINT64_C(0x546345fa9fbdcd45)},
+                                            {UINT64_C(0xd732290fbacaf133), UINT64_C(0xa97c177947ad4096)},
+                                            {UINT64_C(0x867f59a9d4bed6c0), UINT64_C(0x49ed8eabcccc485e)},
+                                            {UINT64_C(0xa81f301449ee8c70), UINT64_C(0x5c68f256bfff5a75)},
+                                            {UINT64_C(0xd226fc195c6a2f8c), UINT64_C(0x73832eec6fff3112)},
+                                            {UINT64_C(0x83585d8fd9c25db7), UINT64_C(0xc831fd53c5ff7eac)},
+                                            {UINT64_C(0xa42e74f3d032f525), UINT64_C(0xba3e7ca8b77f5e56)},
+                                            {UINT64_C(0xcd3a1230c43fb26f), UINT64_C(0x28ce1bd2e55f35ec)},
+                                            {UINT64_C(0x80444b5e7aa7cf85), UINT64_C(0x7980d163cf5b81b4)},
+                                            {UINT64_C(0xa0555e361951c366), UINT64_C(0xd7e105bcc3326220)},
+                                            {UINT64_C(0xc86ab5c39fa63440), UINT64_C(0x8dd9472bf3fefaa8)},
+                                            {UINT64_C(0xfa856334878fc150), UINT64_C(0xb14f98f6f0feb952)},
+                                            {UINT64_C(0x9c935e00d4b9d8d2), UINT64_C(0x6ed1bf9a569f33d4)},
+                                            {UINT64_C(0xc3b8358109e84f07), UINT64_C(0x0a862f80ec4700c9)},
+                                            {UINT64_C(0xf4a642e14c6262c8), UINT64_C(0xcd27bb612758c0fb)},
+                                            {UINT64_C(0x98e7e9cccfbd7dbd), UINT64_C(0x8038d51cb897789d)},
+                                            {UINT64_C(0xbf21e44003acdd2c), UINT64_C(0xe0470a63e6bd56c4)},
+                                            {UINT64_C(0xeeea5d5004981478), UINT64_C(0x1858ccfce06cac75)},
+                                            {UINT64_C(0x95527a5202df0ccb), UINT64_C(0x0f37801e0c43ebc9)},
+                                            {UINT64_C(0xbaa718e68396cffd), UINT64_C(0xd30560258f54e6bb)},
+                                            {UINT64_C(0xe950df20247c83fd), UINT64_C(0x47c6b82ef32a206a)},
+                                            {UINT64_C(0x91d28b7416cdd27e), UINT64_C(0x4cdc331d57fa5442)},
+                                            {UINT64_C(0xb6472e511c81471d), UINT64_C(0xe0133fe4adf8e953)},
+                                            {UINT64_C(0xe3d8f9e563a198e5), UINT64_C(0x58180fddd97723a7)},
+                                            {UINT64_C(0x8e679c2f5e44ff8f), UINT64_C(0x570f09eaa7ea7649)},
+                                            {UINT64_C(0xb201833b35d63f73), UINT64_C(0x2cd2cc6551e513db)},
+                                            {UINT64_C(0xde81e40a034bcf4f), UINT64_C(0xf8077f7ea65e58d2)},
+                                            {UINT64_C(0x8b112e86420f6191), UINT64_C(0xfb04afaf27faf783)},
+                                            {UINT64_C(0xadd57a27d29339f6), UINT64_C(0x79c5db9af1f9b564)},
+                                            {UINT64_C(0xd94ad8b1c7380874), UINT64_C(0x18375281ae7822bd)},
+                                            {UINT64_C(0x87cec76f1c830548), UINT64_C(0x8f2293910d0b15b6)},
+                                            {UINT64_C(0xa9c2794ae3a3c69a), UINT64_C(0xb2eb3875504ddb23)},
+                                            {UINT64_C(0xd433179d9c8cb841), UINT64_C(0x5fa60692a46151ec)},
+                                            {UINT64_C(0x849feec281d7f328), UINT64_C(0xdbc7c41ba6bcd334)},
+                                            {UINT64_C(0xa5c7ea73224deff3), UINT64_C(0x12b9b522906c0801)},
+                                            {UINT64_C(0xcf39e50feae16bef), UINT64_C(0xd768226b34870a01)},
+                                            {UINT64_C(0x81842f29f2cce375), UINT64_C(0xe6a1158300d46641)},
+                                            {UINT64_C(0xa1e53af46f801c53), UINT64_C(0x60495ae3c1097fd1)},
+                                            {UINT64_C(0xca5e89b18b602368), UINT64_C(0x385bb19cb14bdfc5)},
+                                            {UINT64_C(0xfcf62c1dee382c42), UINT64_C(0x46729e03dd9ed7b6)},
+                                            {UINT64_C(0x9e19db92b4e31ba9), UINT64_C(0x6c07a2c26a8346d2)},
+                                            {UINT64_C(0xc5a05277621be293), UINT64_C(0xc7098b7305241886)},
+                                            {UINT64_C(0xf70867153aa2db38), UINT64_C(0xb8cbee4fc66d1ea8)}}};
+      };
+#if !GLZ_JKJ_HAS_INLINE_VARIABLE
+      // decltype(...) should not depend on Dummy; see
+      // https://stackoverflow.com/questions/76438400/decltype-on-static-variable-in-template-class.
+      template <class Dummy>
+      constexpr decltype(cache_holder<ieee754_binary64>::cache) cache_holder<ieee754_binary64, Dummy>::cache;
+#endif
+
+      // Compressed cache.
+      template <class FloatFormat, class Dummy = void>
+      struct compressed_cache_holder
+      {
+         using cache_entry_type = typename cache_holder<FloatFormat>::cache_entry_type;
+         static constexpr int cache_bits = cache_holder<FloatFormat>::cache_bits;
+         static constexpr int min_k = cache_holder<FloatFormat>::min_k;
+         static constexpr int max_k = cache_holder<FloatFormat>::max_k;
+
+         template <class ShiftAmountType, class DecimalExponentType>
+         static constexpr cache_entry_type get_cache(DecimalExponentType k) noexcept
+         {
+            return cache_holder<FloatFormat>::cache[k - min_k];
+         }
+      };
+
+      template <class Dummy>
+      struct compressed_cache_holder<ieee754_binary32, Dummy>
+      {
+         using cache_entry_type = cache_holder<ieee754_binary32>::cache_entry_type;
+         static constexpr int cache_bits = cache_holder<ieee754_binary32>::cache_bits;
+         static constexpr int min_k = cache_holder<ieee754_binary32>::min_k;
+         static constexpr int max_k = cache_holder<ieee754_binary32>::max_k;
+         static constexpr int compression_ratio = 13;
+         static constexpr detail::stdr::size_t compressed_table_size =
+            detail::stdr::size_t((max_k - min_k + compression_ratio) / compression_ratio);
+         static constexpr detail::stdr::size_t pow5_table_size = detail::stdr::size_t((compression_ratio + 1) / 2);
+
+         using cache_holder_t = detail::array<cache_entry_type, compressed_table_size>;
+         using pow5_holder_t = detail::array<detail::stdr::uint_least16_t, pow5_table_size>;
+
+#if GLZ_JKJ_HAS_CONSTEXPR17
+         static constexpr cache_holder_t cache GLZ_JKJ_STATIC_DATA_SECTION = [] {
+            cache_holder_t res{};
+            for (detail::stdr::size_t i = 0; i < compressed_table_size; ++i) {
+               res[i] = cache_holder<ieee754_binary32>::cache[i * compression_ratio];
+            }
+            return res;
+         }();
+         static constexpr pow5_holder_t pow5_table GLZ_JKJ_STATIC_DATA_SECTION = [] {
+            pow5_holder_t res{};
+            detail::stdr::uint_least16_t p = 1;
+            for (detail::stdr::size_t i = 0; i < pow5_table_size; ++i) {
+               res[i] = p;
+               p *= 5;
+            }
+            return res;
+         }();
+#else
+         template <detail::stdr::size_t... indices>
+         static constexpr cache_holder_t make_cache(detail::index_sequence<indices...>)
+         {
+            return {cache_holder<ieee754_binary32>::cache[indices * compression_ratio]...};
+         }
+         static constexpr cache_holder_t cache GLZ_JKJ_STATIC_DATA_SECTION =
+            make_cache(detail::make_index_sequence<compressed_table_size>{});
+
+         template <detail::stdr::size_t... indices>
+         static constexpr pow5_holder_t make_pow5_table(detail::index_sequence<indices...>)
+         {
+            return {detail::compute_power<indices>(detail::stdr::uint_least16_t(5))...};
+         }
+         static constexpr pow5_holder_t pow5_table GLZ_JKJ_STATIC_DATA_SECTION =
+            make_pow5_table(detail::make_index_sequence<pow5_table_size>{});
+#endif
+
+         template <class ShiftAmountType, class DecimalExponentType>
+         static GLZ_JKJ_CONSTEXPR20 cache_entry_type get_cache(DecimalExponentType k) noexcept
+         {
+            // Compute the base index.
+            // Supposed to compute (k - min_k) / compression_ratio.
+            static_assert(max_k - min_k <= 89 && compression_ratio == 13, "");
+            static_assert(max_k - min_k <= (detail::stdr::numeric_limits<DecimalExponentType>::max)(), "");
+            const auto cache_index = DecimalExponentType(
+               detail::stdr::uint_fast16_t(DecimalExponentType(k - min_k) * detail::stdr::int_fast16_t(79)) >> 10);
+            const auto kb = DecimalExponentType(cache_index * compression_ratio + min_k);
+            const auto offset = DecimalExponentType(k - kb);
+
+            // Get the base cache.
+            const auto base_cache = cache[cache_index];
+
+            if (offset == 0) {
+               return base_cache;
+            }
+            else {
+               // Compute the required amount of bit-shift.
+               const auto alpha = ShiftAmountType(detail::log::floor_log2_pow10<min_k, max_k>(k) -
+                                                  detail::log::floor_log2_pow10<min_k, max_k>(kb) - offset);
+               assert(alpha > 0 && alpha < 64);
+
+               // Try to recover the real cache.
+               const auto pow5 =
+                  offset >= 7
+                     ? detail::stdr::uint_fast32_t(detail::stdr::uint_fast32_t(pow5_table[6]) * pow5_table[offset - 6])
+                     : detail::stdr::uint_fast32_t(pow5_table[offset]);
+               auto mul_result = detail::wuint::umul128(base_cache, pow5);
+               const auto recovered_cache = cache_entry_type(
+                  (((mul_result.high() << ShiftAmountType(64 - alpha)) | (mul_result.low() >> alpha)) + 1) &
+                  UINT64_C(0xffffffffffffffff));
+               assert(recovered_cache != 0);
+
+               return recovered_cache;
+            }
+         }
+      };
+#if !GLZ_JKJ_HAS_INLINE_VARIABLE
+      template <class Dummy>
+      constexpr typename compressed_cache_holder<ieee754_binary32, Dummy>::cache_holder_t
+         compressed_cache_holder<ieee754_binary32, Dummy>::cache;
+      template <class Dummy>
+      constexpr typename compressed_cache_holder<ieee754_binary32, Dummy>::pow5_holder_t
+         compressed_cache_holder<ieee754_binary32, Dummy>::pow5_table;
+#endif
+
+      template <class Dummy>
+      struct compressed_cache_holder<ieee754_binary64, Dummy>
+      {
+         using cache_entry_type = cache_holder<ieee754_binary64>::cache_entry_type;
+         static constexpr int cache_bits = cache_holder<ieee754_binary64>::cache_bits;
+         static constexpr int min_k = cache_holder<ieee754_binary64>::min_k;
+         static constexpr int max_k = cache_holder<ieee754_binary64>::max_k;
+         static constexpr int compression_ratio = 27;
+         static constexpr detail::stdr::size_t compressed_table_size =
+            detail::stdr::size_t((max_k - min_k + compression_ratio) / compression_ratio);
+         static constexpr detail::stdr::size_t pow5_table_size = detail::stdr::size_t(compression_ratio);
+
+         using cache_holder_t = detail::array<cache_entry_type, compressed_table_size>;
+         using pow5_holder_t = detail::array<detail::stdr::uint_least64_t, pow5_table_size>;
+
+#if GLZ_JKJ_HAS_CONSTEXPR17
+         static constexpr cache_holder_t cache GLZ_JKJ_STATIC_DATA_SECTION = [] {
+            cache_holder_t res{};
+            for (detail::stdr::size_t i = 0; i < compressed_table_size; ++i) {
+               res[i] = cache_holder<ieee754_binary64>::cache[i * compression_ratio];
+            }
+            return res;
+         }();
+         static constexpr pow5_holder_t pow5_table GLZ_JKJ_STATIC_DATA_SECTION = [] {
+            pow5_holder_t res{};
+            detail::stdr::uint_least64_t p = 1;
+            for (detail::stdr::size_t i = 0; i < pow5_table_size; ++i) {
+               res[i] = p;
+               p *= 5;
+            }
+            return res;
+         }();
+#else
+         template <detail::stdr::size_t... indices>
+         static constexpr cache_holder_t make_cache(detail::index_sequence<indices...>)
+         {
+            return {cache_holder<ieee754_binary64>::cache[indices * compression_ratio]...};
+         }
+         static constexpr cache_holder_t cache GLZ_JKJ_STATIC_DATA_SECTION =
+            make_cache(detail::make_index_sequence<compressed_table_size>{});
+
+         template <detail::stdr::size_t... indices>
+         static constexpr pow5_holder_t make_pow5_table(detail::index_sequence<indices...>)
+         {
+            return {detail::compute_power<indices>(detail::stdr::uint_least64_t(5))...};
+         }
+         static constexpr pow5_holder_t pow5_table GLZ_JKJ_STATIC_DATA_SECTION =
+            make_pow5_table(detail::make_index_sequence<pow5_table_size>{});
+#endif
+
+         template <class ShiftAmountType, class DecimalExponentType>
+         static GLZ_JKJ_CONSTEXPR20 cache_entry_type get_cache(DecimalExponentType k) noexcept
+         {
+            // Compute the base index.
+            // Supposed to compute (k - min_k) / compression_ratio.
+            static_assert(max_k - min_k <= 619 && compression_ratio == 27, "");
+            static_assert(max_k - min_k <= (detail::stdr::numeric_limits<DecimalExponentType>::max)(), "");
+            const auto cache_index = DecimalExponentType(
+               detail::stdr::uint_fast32_t(DecimalExponentType(k - min_k) * detail::stdr::int_fast32_t(607)) >> 14);
+            const auto kb = DecimalExponentType(cache_index * compression_ratio + min_k);
+            const auto offset = DecimalExponentType(k - kb);
+
+            // Get the base cache.
+            const auto base_cache = cache[cache_index];
+
+            if (offset == 0) {
+               return base_cache;
+            }
+            else {
+               // Compute the required amount of bit-shift.
+               const auto alpha = ShiftAmountType(detail::log::floor_log2_pow10<min_k, max_k>(k) -
+                                                  detail::log::floor_log2_pow10<min_k, max_k>(kb) - offset);
+               assert(alpha > 0 && alpha < 64);
+
+               // Try to recover the real cache.
+               const auto pow5 = pow5_table[offset];
+               auto recovered_cache = detail::wuint::umul128(base_cache.high(), pow5);
+               const auto middle_low = detail::wuint::umul128(base_cache.low(), pow5);
+
+               recovered_cache += middle_low.high();
+
+               const auto high_to_middle = detail::stdr::uint_least64_t(
+                  (recovered_cache.high() << ShiftAmountType(64 - alpha)) & UINT64_C(0xffffffffffffffff));
+               const auto middle_to_low = detail::stdr::uint_least64_t(
+                  (recovered_cache.low() << ShiftAmountType(64 - alpha)) & UINT64_C(0xffffffffffffffff));
+
+               recovered_cache = {(recovered_cache.low() >> alpha) | high_to_middle,
+                                  ((middle_low.low() >> alpha) | middle_to_low)};
+
+               assert(recovered_cache.low() != UINT64_C(0xffffffffffffffff));
+               recovered_cache = {recovered_cache.high(), detail::stdr::uint_least64_t(recovered_cache.low() + 1)};
+
+               return recovered_cache;
+            }
+         }
+      };
+#if !GLZ_JKJ_HAS_INLINE_VARIABLE
+      template <class Dummy>
+      constexpr typename compressed_cache_holder<ieee754_binary64, Dummy>::cache_holder_t
+         compressed_cache_holder<ieee754_binary64, Dummy>::cache;
+      template <class Dummy>
+      constexpr typename compressed_cache_holder<ieee754_binary64, Dummy>::pow5_holder_t
+         compressed_cache_holder<ieee754_binary64, Dummy>::pow5_table;
+#endif
+
+      ////////////////////////////////////////////////////////////////////////////////////////
+      // Forward declarations of user-specializable templates used in the main algorithm.
+      ////////////////////////////////////////////////////////////////////////////////////////
+
+      // Remove trailing zeros from significand and add the number of removed zeros into
+      // exponent.
+      template <class TrailingZeroPolicy, class Format, class DecimalSignificand, class DecimalExponentType>
+      struct remove_trailing_zeros_traits;
+
+      // Users can specialize this traits class to make Dragonbox work with their own formats.
+      // However, this requires detailed knowledge on how the algorithm works, so it is recommended to
+      // read through the paper.
+      template <class FormatTraits, class CacheEntryType, detail::stdr::size_t cache_bits_>
+      struct multiplication_traits;
+
+      // A collection of some common definitions to reduce boilerplate.
+      template <class FormatTraits, class CacheEntryType, detail::stdr::size_t cache_bits_>
+      struct multiplication_traits_base
+      {
+         using format = typename FormatTraits::format;
+         static constexpr int significand_bits = format::significand_bits;
+         static constexpr int total_bits = format::total_bits;
+         using carrier_uint = typename FormatTraits::carrier_uint;
+         using cache_entry_type = CacheEntryType;
+         static constexpr int cache_bits = int(cache_bits_);
+
+         struct compute_mul_result
+         {
+            carrier_uint integer_part;
+            bool is_integer;
+         };
+         struct compute_mul_parity_result
+         {
+            bool parity;
+            bool is_integer;
+         };
+      };
+
+      ////////////////////////////////////////////////////////////////////////////////////////
+      // Policies.
+      ////////////////////////////////////////////////////////////////////////////////////////
+
+      namespace detail
+      {
+         template <class T>
+         struct dummy
+         {};
+      }
+
+      namespace policy
+      {
+         namespace sign
+         {
+            GLZ_JKJ_INLINE_VARIABLE struct ignore_t
+            {
+               using sign_policy = ignore_t;
+               static constexpr bool return_has_sign = false;
+
+#if defined(_MSC_VER) && !defined(__clang__)
+               // See
+               // https://developercommunity.visualstudio.com/t/Failure-to-optimize-intrinsics/10628226
+               template <class SignedSignificandBits, class DecimalSignificand, class DecimalExponentType>
+               static constexpr decimal_fp<DecimalSignificand, DecimalExponentType, false, false> handle_sign(
+                  SignedSignificandBits, decimal_fp<DecimalSignificand, DecimalExponentType, false, false> r) noexcept
+               {
+                  return {r.significand, r.exponent};
+               }
+               template <class SignedSignificandBits, class DecimalSignificand, class DecimalExponentType>
+               static constexpr decimal_fp<DecimalSignificand, DecimalExponentType, false, true> handle_sign(
+                  SignedSignificandBits, decimal_fp<DecimalSignificand, DecimalExponentType, false, true> r) noexcept
+               {
+                  return {r.significand, r.exponent, r.may_have_trailing_zeros};
+               }
+#else
+               template <class SignedSignificandBits, class UnsignedDecimalFp>
+               static constexpr UnsignedDecimalFp handle_sign(SignedSignificandBits, UnsignedDecimalFp r) noexcept
+               {
+                  return r;
+               }
+#endif
+            } ignore = {};
+
+            GLZ_JKJ_INLINE_VARIABLE struct return_sign_t
+            {
+               using sign_policy = return_sign_t;
+               static constexpr bool return_has_sign = true;
+
+               template <class SignedSignificandBits, class UnsignedDecimalFp>
+               static constexpr detail::unsigned_decimal_fp_to_signed_t<UnsignedDecimalFp> handle_sign(
+                  SignedSignificandBits s, UnsignedDecimalFp r) noexcept
+               {
+                  return add_sign_to_unsigned_decimal_fp(s.is_negative(), r);
+               }
+            } return_sign = {};
+         }
+
+         namespace trailing_zero
+         {
+            GLZ_JKJ_INLINE_VARIABLE struct ignore_t
+            {
+               using trailing_zero_policy = ignore_t;
+               static constexpr bool report_trailing_zeros = false;
+
+               template <class Format, class DecimalSignificand, class DecimalExponentType>
+               static constexpr unsigned_decimal_fp<DecimalSignificand, DecimalExponentType, false> on_trailing_zeros(
+                  DecimalSignificand significand, DecimalExponentType exponent) noexcept
+               {
+                  return {significand, exponent};
+               }
+
+               template <class Format, class DecimalSignificand, class DecimalExponentType>
+               static constexpr unsigned_decimal_fp<DecimalSignificand, DecimalExponentType, false> no_trailing_zeros(
+                  DecimalSignificand significand, DecimalExponentType exponent) noexcept
+               {
+                  return {significand, exponent};
+               }
+            } ignore = {};
+
+            GLZ_JKJ_INLINE_VARIABLE struct remove_t
+            {
+               using trailing_zero_policy = remove_t;
+               static constexpr bool report_trailing_zeros = false;
+
+               template <class Format, class DecimalSignificand, class DecimalExponentType>
+               GLZ_JKJ_FORCEINLINE static GLZ_JKJ_CONSTEXPR14
+                  unsigned_decimal_fp<DecimalSignificand, DecimalExponentType, false>
+                  on_trailing_zeros(DecimalSignificand significand, DecimalExponentType exponent) noexcept
+               {
+                  remove_trailing_zeros_traits<remove_t, Format, DecimalSignificand,
+                                               DecimalExponentType>::remove_trailing_zeros(significand, exponent);
+                  return {significand, exponent};
+               }
+
+               template <class Format, class DecimalSignificand, class DecimalExponentType>
+               static constexpr unsigned_decimal_fp<DecimalSignificand, DecimalExponentType, false> no_trailing_zeros(
+                  DecimalSignificand significand, DecimalExponentType exponent) noexcept
+               {
+                  return {significand, exponent};
+               }
+            } remove = {};
+
+            GLZ_JKJ_INLINE_VARIABLE struct remove_compact_t
+            {
+               using trailing_zero_policy = remove_compact_t;
+               static constexpr bool report_trailing_zeros = false;
+
+               template <class Format, class DecimalSignificand, class DecimalExponentType>
+               GLZ_JKJ_FORCEINLINE static GLZ_JKJ_CONSTEXPR14
+                  unsigned_decimal_fp<DecimalSignificand, DecimalExponentType, false>
+                  on_trailing_zeros(DecimalSignificand significand, DecimalExponentType exponent) noexcept
+               {
+                  remove_trailing_zeros_traits<remove_compact_t, Format, DecimalSignificand,
+                                               DecimalExponentType>::remove_trailing_zeros(significand, exponent);
+                  return {significand, exponent};
+               }
+
+               template <class Format, class DecimalSignificand, class DecimalExponentType>
+               static constexpr unsigned_decimal_fp<DecimalSignificand, DecimalExponentType, false> no_trailing_zeros(
+                  DecimalSignificand significand, DecimalExponentType exponent) noexcept
+               {
+                  return {significand, exponent};
+               }
+            } remove_compact = {};
+
+            GLZ_JKJ_INLINE_VARIABLE struct report_t
+            {
+               using trailing_zero_policy = report_t;
+               static constexpr bool report_trailing_zeros = true;
+
+               template <class Format, class DecimalSignificand, class DecimalExponentType>
+               static constexpr unsigned_decimal_fp<DecimalSignificand, DecimalExponentType, true> on_trailing_zeros(
+                  DecimalSignificand significand, DecimalExponentType exponent) noexcept
+               {
+                  return {significand, exponent, true};
+               }
+
+               template <class Format, class DecimalSignificand, class DecimalExponentType>
+               static constexpr unsigned_decimal_fp<DecimalSignificand, DecimalExponentType, true> no_trailing_zeros(
+                  DecimalSignificand significand, DecimalExponentType exponent) noexcept
+               {
+                  return {significand, exponent, false};
+               }
+            } report = {};
+         }
+
+         namespace decimal_to_binary_rounding
+         {
+            enum class tag_t { to_nearest, left_closed_directed, right_closed_directed };
+
+            namespace interval_type
+            {
+               struct symmetric_boundary
+               {
+                  static constexpr bool is_symmetric = true;
+                  bool is_closed;
+                  constexpr bool include_left_endpoint() const noexcept { return is_closed; }
+                  constexpr bool include_right_endpoint() const noexcept { return is_closed; }
+               };
+               struct asymmetric_boundary
+               {
+                  static constexpr bool is_symmetric = false;
+                  bool is_left_closed;
+                  constexpr bool include_left_endpoint() const noexcept { return is_left_closed; }
+                  constexpr bool include_right_endpoint() const noexcept { return !is_left_closed; }
+               };
+               struct closed
+               {
+                  static constexpr bool is_symmetric = true;
+                  static constexpr bool include_left_endpoint() noexcept { return true; }
+                  static constexpr bool include_right_endpoint() noexcept { return true; }
+               };
+               struct open
+               {
+                  static constexpr bool is_symmetric = true;
+                  static constexpr bool include_left_endpoint() noexcept { return false; }
+                  static constexpr bool include_right_endpoint() noexcept { return false; }
+               };
+               struct left_closed_right_open
+               {
+                  static constexpr bool is_symmetric = false;
+                  static constexpr bool include_left_endpoint() noexcept { return true; }
+                  static constexpr bool include_right_endpoint() noexcept { return false; }
+               };
+               struct right_closed_left_open
+               {
+                  static constexpr bool is_symmetric = false;
+                  static constexpr bool include_left_endpoint() noexcept { return false; }
+                  static constexpr bool include_right_endpoint() noexcept { return true; }
+               };
+            }
+
+            GLZ_JKJ_INLINE_VARIABLE struct nearest_to_even_t
+            {
+               using decimal_to_binary_rounding_policy = nearest_to_even_t;
+               using interval_type_provider = nearest_to_even_t;
+               static constexpr auto tag = tag_t::to_nearest;
+
+               template <class SignedSignificandBits, class Func, class... Args>
+               GLZ_JKJ_FORCEINLINE GLZ_JKJ_SAFEBUFFERS static constexpr decltype(Func{}(
+                  dragonbox::detail::declval<nearest_to_even_t>(), Args{}...))
+               delegate(SignedSignificandBits, Func f, Args... args) noexcept
+               {
+                  return f(nearest_to_even_t{}, args...);
+               }
+
+               template <class SignedSignificandBits>
+               static constexpr interval_type::symmetric_boundary normal_interval(SignedSignificandBits s) noexcept
+               {
+                  return {s.has_even_significand_bits()};
+               }
+
+               template <class SignedSignificandBits>
+               static constexpr interval_type::closed shorter_interval(SignedSignificandBits) noexcept
+               {
+                  return {};
+               }
+            } nearest_to_even = {};
+
+            GLZ_JKJ_INLINE_VARIABLE struct nearest_to_odd_t
+            {
+               using decimal_to_binary_rounding_policy = nearest_to_odd_t;
+               using interval_type_provider = nearest_to_odd_t;
+               static constexpr auto tag = tag_t::to_nearest;
+
+               template <class SignedSignificandBits, class Func, class... Args>
+               GLZ_JKJ_FORCEINLINE GLZ_JKJ_SAFEBUFFERS static constexpr decltype(Func{}(
+                  dragonbox::detail::declval<nearest_to_odd_t>(), Args{}...))
+               delegate(SignedSignificandBits, Func f, Args... args) noexcept
+               {
+                  return f(nearest_to_odd_t{}, args...);
+               }
+
+               template <class SignedSignificandBits>
+               static constexpr interval_type::symmetric_boundary normal_interval(SignedSignificandBits s) noexcept
+               {
+                  return {!s.has_even_significand_bits()};
+               }
+               template <class SignedSignificandBits>
+               static constexpr interval_type::open shorter_interval(SignedSignificandBits) noexcept
+               {
+                  return {};
+               }
+            } nearest_to_odd = {};
+
+            GLZ_JKJ_INLINE_VARIABLE struct nearest_toward_plus_infinity_t
+            {
+               using decimal_to_binary_rounding_policy = nearest_toward_plus_infinity_t;
+               using interval_type_provider = nearest_toward_plus_infinity_t;
+               static constexpr auto tag = tag_t::to_nearest;
+
+               template <class SignedSignificandBits, class Func, class... Args>
+               GLZ_JKJ_FORCEINLINE GLZ_JKJ_SAFEBUFFERS static constexpr decltype(Func{}(
+                  dragonbox::detail::declval<nearest_toward_plus_infinity_t>(), Args{}...))
+               delegate(SignedSignificandBits, Func f, Args... args) noexcept
+               {
+                  return f(nearest_toward_plus_infinity_t{}, args...);
+               }
+
+               template <class SignedSignificandBits>
+               static constexpr interval_type::asymmetric_boundary normal_interval(SignedSignificandBits s) noexcept
+               {
+                  return {!s.is_negative()};
+               }
+               template <class SignedSignificandBits>
+               static constexpr interval_type::asymmetric_boundary shorter_interval(SignedSignificandBits s) noexcept
+               {
+                  return {!s.is_negative()};
+               }
+            } nearest_toward_plus_infinity = {};
+
+            GLZ_JKJ_INLINE_VARIABLE struct nearest_toward_minus_infinity_t
+            {
+               using decimal_to_binary_rounding_policy = nearest_toward_minus_infinity_t;
+               using interval_type_provider = nearest_toward_minus_infinity_t;
+               static constexpr auto tag = tag_t::to_nearest;
+
+               template <class SignedSignificandBits, class Func, class... Args>
+               GLZ_JKJ_FORCEINLINE GLZ_JKJ_SAFEBUFFERS static constexpr decltype(Func{}(
+                  dragonbox::detail::declval<nearest_toward_minus_infinity_t>(), Args{}...))
+               delegate(SignedSignificandBits, Func f, Args... args) noexcept
+               {
+                  return f(nearest_toward_minus_infinity_t{}, args...);
+               }
+
+               template <class SignedSignificandBits>
+               static constexpr interval_type::asymmetric_boundary normal_interval(SignedSignificandBits s) noexcept
+               {
+                  return {s.is_negative()};
+               }
+               template <class SignedSignificandBits>
+               static constexpr interval_type::asymmetric_boundary shorter_interval(SignedSignificandBits s) noexcept
+               {
+                  return {s.is_negative()};
+               }
+            } nearest_toward_minus_infinity = {};
+
+            GLZ_JKJ_INLINE_VARIABLE struct nearest_toward_zero_t
+            {
+               using decimal_to_binary_rounding_policy = nearest_toward_zero_t;
+               using interval_type_provider = nearest_toward_zero_t;
+               static constexpr auto tag = tag_t::to_nearest;
+
+               template <class SignedSignificandBits, class Func, class... Args>
+               GLZ_JKJ_FORCEINLINE GLZ_JKJ_SAFEBUFFERS static constexpr decltype(Func{}(
+                  dragonbox::detail::declval<nearest_toward_zero_t>(), Args{}...))
+               delegate(SignedSignificandBits, Func f, Args... args) noexcept
+               {
+                  return f(nearest_toward_zero_t{}, args...);
+               }
+
+               template <class SignedSignificandBits>
+               static constexpr interval_type::right_closed_left_open normal_interval(SignedSignificandBits) noexcept
+               {
+                  return {};
+               }
+               template <class SignedSignificandBits>
+               static constexpr interval_type::right_closed_left_open shorter_interval(SignedSignificandBits) noexcept
+               {
+                  return {};
+               }
+            } nearest_toward_zero = {};
+
+            GLZ_JKJ_INLINE_VARIABLE struct nearest_away_from_zero_t
+            {
+               using decimal_to_binary_rounding_policy = nearest_away_from_zero_t;
+               using interval_type_provider = nearest_away_from_zero_t;
+               static constexpr auto tag = tag_t::to_nearest;
+
+               template <class SignedSignificandBits, class Func, class... Args>
+               GLZ_JKJ_FORCEINLINE GLZ_JKJ_SAFEBUFFERS static constexpr decltype(Func{}(
+                  dragonbox::detail::declval<nearest_away_from_zero_t>(), Args{}...))
+               delegate(SignedSignificandBits, Func f, Args... args) noexcept
+               {
+                  return f(nearest_away_from_zero_t{}, args...);
+               }
+
+               template <class SignedSignificandBits>
+               static constexpr interval_type::left_closed_right_open normal_interval(SignedSignificandBits) noexcept
+               {
+                  return {};
+               }
+               template <class SignedSignificandBits>
+               static constexpr interval_type::left_closed_right_open shorter_interval(SignedSignificandBits) noexcept
+               {
+                  return {};
+               }
+            } nearest_away_from_zero = {};
+
+            namespace detail
+            {
+               struct nearest_always_closed_t
+               {
+                  using interval_type_provider = nearest_always_closed_t;
+                  static constexpr auto tag = tag_t::to_nearest;
+
+                  template <class SignedSignificandBits>
+                  static constexpr interval_type::closed normal_interval(SignedSignificandBits) noexcept
+                  {
+                     return {};
+                  }
+                  template <class SignedSignificandBits>
+                  static constexpr interval_type::closed shorter_interval(SignedSignificandBits) noexcept
+                  {
+                     return {};
+                  }
+               };
+               struct nearest_always_open_t
+               {
+                  using interval_type_provider = nearest_always_open_t;
+                  static constexpr auto tag = tag_t::to_nearest;
+
+                  template <class SignedSignificandBits>
+                  static constexpr interval_type::open normal_interval(SignedSignificandBits) noexcept
+                  {
+                     return {};
+                  }
+                  template <class SignedSignificandBits>
+                  static constexpr interval_type::open shorter_interval(SignedSignificandBits) noexcept
+                  {
+                     return {};
+                  }
+               };
+            }
+
+            GLZ_JKJ_INLINE_VARIABLE struct nearest_to_even_static_boundary_t
+            {
+               using decimal_to_binary_rounding_policy = nearest_to_even_static_boundary_t;
+
+               template <class SignedSignificandBits, class Func, class... Args>
+               GLZ_JKJ_FORCEINLINE GLZ_JKJ_SAFEBUFFERS static constexpr decltype(Func{}(
+                  detail::nearest_always_closed_t{}, Args{}...))
+               delegate(SignedSignificandBits s, Func f, Args... args) noexcept
+               {
+                  return s.has_even_significand_bits() ? f(detail::nearest_always_closed_t{}, args...)
+                                                       : f(detail::nearest_always_open_t{}, args...);
+               }
+            } nearest_to_even_static_boundary = {};
+
+            GLZ_JKJ_INLINE_VARIABLE struct nearest_to_odd_static_boundary_t
+            {
+               using decimal_to_binary_rounding_policy = nearest_to_odd_static_boundary_t;
+
+               template <class SignedSignificandBits, class Func, class... Args>
+               GLZ_JKJ_FORCEINLINE GLZ_JKJ_SAFEBUFFERS static constexpr decltype(Func{}(
+                  detail::nearest_always_closed_t{}, Args{}...))
+               delegate(SignedSignificandBits s, Func f, Args... args) noexcept
+               {
+                  return s.has_even_significand_bits() ? f(detail::nearest_always_open_t{}, args...)
+                                                       : f(detail::nearest_always_closed_t{}, args...);
+               }
+            } nearest_to_odd_static_boundary = {};
+
+            GLZ_JKJ_INLINE_VARIABLE struct nearest_toward_plus_infinity_static_boundary_t
+            {
+               using decimal_to_binary_rounding_policy = nearest_toward_plus_infinity_static_boundary_t;
+
+               template <class SignedSignificandBits, class Func, class... Args>
+               GLZ_JKJ_FORCEINLINE GLZ_JKJ_SAFEBUFFERS static constexpr decltype(Func{}(nearest_toward_zero, Args{}...))
+               delegate(SignedSignificandBits s, Func f, Args... args) noexcept
+               {
+                  return s.is_negative() ? f(nearest_toward_zero, args...) : f(nearest_away_from_zero, args...);
+               }
+            } nearest_toward_plus_infinity_static_boundary = {};
+
+            GLZ_JKJ_INLINE_VARIABLE struct nearest_toward_minus_infinity_static_boundary_t
+            {
+               using decimal_to_binary_rounding_policy = nearest_toward_minus_infinity_static_boundary_t;
+
+               template <class SignedSignificandBits, class Func, class... Args>
+               GLZ_JKJ_FORCEINLINE GLZ_JKJ_SAFEBUFFERS static constexpr decltype(Func{}(nearest_toward_zero, Args{}...))
+               delegate(SignedSignificandBits s, Func f, Args... args) noexcept
+               {
+                  return s.is_negative() ? f(nearest_away_from_zero, args...) : f(nearest_toward_zero, args...);
+               }
+            } nearest_toward_minus_infinity_static_boundary = {};
+
+            namespace detail
+            {
+               struct left_closed_directed_t
+               {
+                  static constexpr auto tag = tag_t::left_closed_directed;
+               };
+               struct right_closed_directed_t
+               {
+                  static constexpr auto tag = tag_t::right_closed_directed;
+               };
+            }
+
+            GLZ_JKJ_INLINE_VARIABLE struct toward_plus_infinity_t
+            {
+               using decimal_to_binary_rounding_policy = toward_plus_infinity_t;
+
+               template <class SignedSignificandBits, class Func, class... Args>
+               GLZ_JKJ_FORCEINLINE GLZ_JKJ_SAFEBUFFERS static constexpr decltype(Func{}(
+                  detail::left_closed_directed_t{}, Args{}...))
+               delegate(SignedSignificandBits s, Func f, Args... args) noexcept
+               {
+                  return s.is_negative() ? f(detail::left_closed_directed_t{}, args...)
+                                         : f(detail::right_closed_directed_t{}, args...);
+               }
+            } toward_plus_infinity = {};
+
+            GLZ_JKJ_INLINE_VARIABLE struct toward_minus_infinity_t
+            {
+               using decimal_to_binary_rounding_policy = toward_minus_infinity_t;
+
+               template <class SignedSignificandBits, class Func, class... Args>
+               GLZ_JKJ_FORCEINLINE GLZ_JKJ_SAFEBUFFERS static constexpr decltype(Func{}(
+                  detail::left_closed_directed_t{}, Args{}...))
+               delegate(SignedSignificandBits s, Func f, Args... args) noexcept
+               {
+                  return s.is_negative() ? f(detail::right_closed_directed_t{}, args...)
+                                         : f(detail::left_closed_directed_t{}, args...);
+               }
+            } toward_minus_infinity = {};
+
+            GLZ_JKJ_INLINE_VARIABLE struct toward_zero_t
+            {
+               using decimal_to_binary_rounding_policy = toward_zero_t;
+
+               template <class SignedSignificandBits, class Func, class... Args>
+               GLZ_JKJ_FORCEINLINE GLZ_JKJ_SAFEBUFFERS static constexpr decltype(Func{}(
+                  detail::left_closed_directed_t{}, Args{}...))
+               delegate(SignedSignificandBits, Func f, Args... args) noexcept
+               {
+                  return f(detail::left_closed_directed_t{}, args...);
+               }
+            } toward_zero = {};
+
+            GLZ_JKJ_INLINE_VARIABLE struct away_from_zero_t
+            {
+               using decimal_to_binary_rounding_policy = away_from_zero_t;
+
+               template <class SignedSignificandBits, class Func, class... Args>
+               GLZ_JKJ_FORCEINLINE GLZ_JKJ_SAFEBUFFERS static constexpr decltype(Func{}(
+                  detail::right_closed_directed_t{}, Args{}...))
+               delegate(SignedSignificandBits, Func f, Args... args) noexcept
+               {
+                  return f(detail::right_closed_directed_t{}, args...);
+               }
+            } away_from_zero = {};
+         }
+
+         namespace binary_to_decimal_rounding
+         {
+            // (Always assumes nearest rounding modes, as there can be no tie for other rounding
+            // modes.)
+            enum class tag_t { do_not_care, to_even, to_odd, away_from_zero, toward_zero };
+
+            // The parameter significand corresponds to 10\tilde{s}+t in the paper.
+
+            GLZ_JKJ_INLINE_VARIABLE struct do_not_care_t
+            {
+               using binary_to_decimal_rounding_policy = do_not_care_t;
+               static constexpr auto tag = tag_t::do_not_care;
+
+               template <class CarrierUInt>
+               static constexpr bool prefer_round_down(CarrierUInt) noexcept
+               {
+                  return false;
+               }
+            } do_not_care = {};
+
+            GLZ_JKJ_INLINE_VARIABLE struct to_even_t
+            {
+               using binary_to_decimal_rounding_policy = to_even_t;
+               static constexpr auto tag = tag_t::to_even;
+
+               template <class CarrierUInt>
+               static constexpr bool prefer_round_down(CarrierUInt significand) noexcept
+               {
+                  return significand % 2 != 0;
+               }
+            } to_even = {};
+
+            GLZ_JKJ_INLINE_VARIABLE struct to_odd_t
+            {
+               using binary_to_decimal_rounding_policy = to_odd_t;
+               static constexpr auto tag = tag_t::to_odd;
+
+               template <class CarrierUInt>
+               static constexpr bool prefer_round_down(CarrierUInt significand) noexcept
+               {
+                  return significand % 2 == 0;
+               }
+            } to_odd = {};
+
+            GLZ_JKJ_INLINE_VARIABLE struct away_from_zero_t
+            {
+               using binary_to_decimal_rounding_policy = away_from_zero_t;
+               static constexpr auto tag = tag_t::away_from_zero;
+
+               template <class CarrierUInt>
+               static constexpr bool prefer_round_down(CarrierUInt) noexcept
+               {
+                  return false;
+               }
+            } away_from_zero = {};
+
+            GLZ_JKJ_INLINE_VARIABLE struct toward_zero_t
+            {
+               using binary_to_decimal_rounding_policy = toward_zero_t;
+               static constexpr auto tag = tag_t::toward_zero;
+
+               template <class CarrierUInt>
+               static constexpr bool prefer_round_down(CarrierUInt) noexcept
+               {
+                  return true;
+               }
+            } toward_zero = {};
+         }
+
+         namespace cache
+         {
+            GLZ_JKJ_INLINE_VARIABLE struct full_t
+            {
+               using cache_policy = full_t;
+               template <class FloatFormat>
+               using cache_holder_type = cache_holder<FloatFormat>;
+
+               template <class FloatFormat, class ShiftAmountType, class DecimalExponentType>
+               static constexpr typename cache_holder_type<FloatFormat>::cache_entry_type get_cache(
+                  DecimalExponentType k) noexcept
+               {
+#if GLZ_JKJ_HAS_CONSTEXPR14
+                  assert(k >= cache_holder_type<FloatFormat>::min_k && k <= cache_holder_type<FloatFormat>::max_k);
+#endif
+                  return cache_holder_type<FloatFormat>::cache[detail::stdr::size_t(
+                     k - cache_holder_type<FloatFormat>::min_k)];
+               }
+            } full = {};
+
+            GLZ_JKJ_INLINE_VARIABLE struct compact_t
+            {
+               using cache_policy = compact_t;
+               template <class FloatFormat>
+               using cache_holder_type = compressed_cache_holder<FloatFormat>;
+
+               template <class FloatFormat, class ShiftAmountType, class DecimalExponentType>
+               static GLZ_JKJ_CONSTEXPR20 typename cache_holder<FloatFormat>::cache_entry_type get_cache(
+                  DecimalExponentType k) noexcept
+               {
+                  assert(k >= cache_holder<FloatFormat>::min_k && k <= cache_holder<FloatFormat>::max_k);
+
+                  return cache_holder_type<FloatFormat>::template get_cache<ShiftAmountType>(k);
+               }
+            } compact = {};
+         }
+
+         namespace preferred_integer_types
+         {
+            GLZ_JKJ_INLINE_VARIABLE struct match_t
+            {
+               using preferred_integer_types_policy = match_t;
+
+               template <class FormatTraits, detail::stdr::uint_least64_t upper_bound>
+               using remainder_type = typename FormatTraits::carrier_uint;
+
+               template <class FormatTraits, detail::stdr::int_least32_t lower_bound,
+                         detail::stdr::uint_least32_t upper_bound>
+               using decimal_exponent_type = typename FormatTraits::exponent_int;
+
+               template <class FormatTraits>
+               using shift_amount_type = typename FormatTraits::exponent_int;
+            } match;
+
+            GLZ_JKJ_INLINE_VARIABLE struct prefer_32_t
+            {
+               using preferred_integer_types_policy = prefer_32_t;
+
+               template <class FormatTraits, detail::stdr::uint_least64_t upper_bound>
+               using remainder_type = typename detail::stdr::conditional<
+                  upper_bound <= (detail::stdr::numeric_limits<detail::stdr::uint_least32_t>::max)(),
+                  detail::stdr::uint_least32_t, typename FormatTraits::carrier_uint>::type;
+
+               template <class FormatTraits, detail::stdr::int_least32_t lower_bound,
+                         detail::stdr::uint_least32_t upper_bound>
+               using decimal_exponent_type = typename detail::stdr::conditional<
+                  FormatTraits::format::exponent_bits <= detail::value_bits<detail::stdr::int_least32_t>::value,
+                  detail::stdr::int_least32_t, typename FormatTraits::exponent_int>::type;
+
+               template <class FormatTraits>
+               using shift_amount_type = detail::stdr::int_least32_t;
+            } prefer_32;
+
+            GLZ_JKJ_INLINE_VARIABLE struct minimal_t
+            {
+               using preferred_integer_types_policy = minimal_t;
+
+               template <class FormatTraits, detail::stdr::uint_least64_t upper_bound>
+               using remainder_type = typename detail::stdr::conditional<
+                  upper_bound <= (detail::stdr::numeric_limits<detail::stdr::uint_least8_t>::max)(),
+                  detail::stdr::uint_least8_t,
+                  typename detail::stdr::conditional<
+                     upper_bound <= (detail::stdr::numeric_limits<detail::stdr::uint_least16_t>::max)(),
+                     detail::stdr::uint_least16_t,
+                     typename detail::stdr::conditional<
+                        upper_bound <= (detail::stdr::numeric_limits<detail::stdr::uint_least32_t>::max)(),
+                        detail::stdr::uint_least32_t,
+                        typename detail::stdr::conditional<
+                           upper_bound <= (detail::stdr::numeric_limits<detail::stdr::uint_least64_t>::max)(),
+                           detail::stdr::uint_least64_t, typename FormatTraits::carrier_uint>::type>::type>::type>::
+                  type;
+
+               template <class FormatTraits, detail::stdr::int_least32_t lower_bound,
+                         detail::stdr::uint_least32_t upper_bound>
+               using decimal_exponent_type = typename detail::stdr::conditional<
+                  lower_bound >= (detail::stdr::numeric_limits<detail::stdr::int_least8_t>::min)() &&
+                     upper_bound <= (detail::stdr::numeric_limits<detail::stdr::int_least8_t>::max)(),
+                  detail::stdr::int_least8_t,
+                  typename detail::stdr::conditional<
+                     lower_bound >= (detail::stdr::numeric_limits<detail::stdr::int_least16_t>::min)() &&
+                        upper_bound <= (detail::stdr::numeric_limits<detail::stdr::int_least16_t>::max)(),
+                     detail::stdr::int_least16_t,
+                     typename detail::stdr::conditional<
+                        lower_bound >= (detail::stdr::numeric_limits<detail::stdr::int_least32_t>::min)() &&
+                           upper_bound <= (detail::stdr::numeric_limits<detail::stdr::int_least32_t>::max)(),
+                        detail::stdr::int_least32_t, typename FormatTraits::exponent_int>::type>::type>::type;
+
+               template <class FormatTraits>
+               using shift_amount_type = detail::stdr::int_least8_t;
+            } minimal;
+         }
+      }
+
+      ////////////////////////////////////////////////////////////////////////////////////////
+      // Specializations of user-specializable templates used in the main algorithm.
+      ////////////////////////////////////////////////////////////////////////////////////////
+
+      template <class DecimalExponentType>
+      struct remove_trailing_zeros_traits<policy::trailing_zero::remove_t, ieee754_binary32,
+                                          detail::stdr::uint_least32_t, DecimalExponentType>
+      {
+         GLZ_JKJ_FORCEINLINE static GLZ_JKJ_CONSTEXPR14 void remove_trailing_zeros(
+            detail::stdr::uint_least32_t& significand, DecimalExponentType& exponent) noexcept
+         {
+            // See https://github.com/jk-jeon/rtz_benchmark.
+            // The idea of branchless search below is by reddit users r/pigeon768 and
+            // r/TheoreticalDumbass.
+
+            auto r = detail::bits::rotr<32>(detail::stdr::uint_least32_t(significand * UINT32_C(184254097)), 4);
+            auto b = r < UINT32_C(429497);
+            auto s = detail::stdr::size_t(b);
+            significand = b ? r : significand;
+
+            r = detail::bits::rotr<32>(detail::stdr::uint_least32_t(significand * UINT32_C(42949673)), 2);
+            b = r < UINT32_C(42949673);
+            s = s * 2 + b;
+            significand = b ? r : significand;
+
+            r = detail::bits::rotr<32>(detail::stdr::uint_least32_t(significand * UINT32_C(1288490189)), 1);
+            b = r < UINT32_C(429496730);
+            s = s * 2 + b;
+            significand = b ? r : significand;
+
+            exponent += s;
+         }
+      };
+
+      template <class DecimalExponentType>
+      struct remove_trailing_zeros_traits<policy::trailing_zero::remove_t, ieee754_binary64,
+                                          detail::stdr::uint_least64_t, DecimalExponentType>
+      {
+         GLZ_JKJ_FORCEINLINE static GLZ_JKJ_CONSTEXPR14 void remove_trailing_zeros(
+            detail::stdr::uint_least64_t& significand, DecimalExponentType& exponent) noexcept
+         {
+            // See https://github.com/jk-jeon/rtz_benchmark.
+            // The idea of branchless search below is by reddit users r/pigeon768 and
+            // r/TheoreticalDumbass.
+
+            auto r = detail::bits::rotr<64>(detail::stdr::uint_least64_t(significand * UINT64_C(28999941890838049)), 8);
+            auto b = r < UINT64_C(184467440738);
+            auto s = detail::stdr::size_t(b);
+            significand = b ? r : significand;
+
+            r = detail::bits::rotr<64>(detail::stdr::uint_least64_t(significand * UINT64_C(182622766329724561)), 4);
+            b = r < UINT64_C(1844674407370956);
+            s = s * 2 + b;
+            significand = b ? r : significand;
+
+            r = detail::bits::rotr<64>(detail::stdr::uint_least64_t(significand * UINT64_C(10330176681277348905)), 2);
+            b = r < UINT64_C(184467440737095517);
+            s = s * 2 + b;
+            significand = b ? r : significand;
+
+            r = detail::bits::rotr<64>(detail::stdr::uint_least64_t(significand * UINT32_C(14757395258967641293)), 1);
+            b = r < UINT64_C(1844674407370955162);
+            s = s * 2 + b;
+            significand = b ? r : significand;
+
+            exponent += s;
+         }
+      };
+
+      template <class DecimalExponentType>
+      struct remove_trailing_zeros_traits<policy::trailing_zero::remove_compact_t, ieee754_binary32,
+                                          detail::stdr::uint_least32_t, DecimalExponentType>
+      {
+         GLZ_JKJ_FORCEINLINE static GLZ_JKJ_CONSTEXPR14 void remove_trailing_zeros(
+            detail::stdr::uint_least32_t& significand, DecimalExponentType& exponent) noexcept
+         {
+            // See https://github.com/jk-jeon/rtz_benchmark.
+            while (true) {
+               const auto r = detail::stdr::uint_least32_t(significand * UINT32_C(1288490189));
+               if (r < UINT32_C(429496731)) {
+                  significand = detail::stdr::uint_least32_t(r >> 1);
+                  exponent += 1;
+               }
+               else {
+                  break;
+               }
+            }
+         }
+      };
+
+      template <class DecimalExponentType>
+      struct remove_trailing_zeros_traits<policy::trailing_zero::remove_compact_t, ieee754_binary64,
+                                          detail::stdr::uint_least64_t, DecimalExponentType>
+      {
+         GLZ_JKJ_FORCEINLINE static GLZ_JKJ_CONSTEXPR14 void remove_trailing_zeros(
+            detail::stdr::uint_least64_t& significand, DecimalExponentType& exponent) noexcept
+         {
+            // See https://github.com/jk-jeon/rtz_benchmark.
+            while (true) {
+               const auto r = detail::stdr::uint_least64_t(significand * UINT64_C(5534023222112865485));
+               if (r < UINT64_C(1844674407370955163)) {
+                  significand = detail::stdr::uint_least64_t(r >> 1);
+                  exponent += 1;
+               }
+               else {
+                  break;
+               }
+            }
+         }
+      };
+
+      template <class ExponentInt>
+      struct multiplication_traits<ieee754_binary_traits<ieee754_binary32, detail::stdr::uint_least32_t, ExponentInt>,
+                                   detail::stdr::uint_least64_t, 64>
+         : public multiplication_traits_base<ieee754_binary_traits<ieee754_binary32, detail::stdr::uint_least32_t>,
+                                             detail::stdr::uint_least64_t, 64>
+      {
+         static GLZ_JKJ_CONSTEXPR20 compute_mul_result compute_mul(carrier_uint u,
+                                                                   const cache_entry_type& cache) noexcept
+         {
+            const auto r = detail::wuint::umul96_upper64(u, cache);
+            return {carrier_uint(r >> 32), carrier_uint(r) == 0};
+         }
+
+         template <class ShiftAmountType>
+         static constexpr detail::stdr::uint_least64_t compute_delta(const cache_entry_type& cache,
+                                                                     ShiftAmountType beta) noexcept
+         {
+            return detail::stdr::uint_least64_t(cache >> ShiftAmountType(cache_bits - 1 - beta));
+         }
+
+         template <class ShiftAmountType>
+         static GLZ_JKJ_CONSTEXPR20 compute_mul_parity_result compute_mul_parity(carrier_uint two_f,
+                                                                                 const cache_entry_type& cache,
+                                                                                 ShiftAmountType beta) noexcept
+         {
+            assert(beta >= 1);
+            assert(beta <= 32);
+
+            const auto r = detail::wuint::umul96_lower64(two_f, cache);
+            return {((r >> ShiftAmountType(64 - beta)) & 1) != 0,
+                    (UINT32_C(0xffffffff) & (r >> ShiftAmountType(32 - beta))) == 0};
+         }
+
+         template <class ShiftAmountType>
+         static constexpr carrier_uint compute_left_endpoint_for_shorter_interval_case(const cache_entry_type& cache,
+                                                                                       ShiftAmountType beta) noexcept
+         {
+            return carrier_uint((cache - (cache >> (significand_bits + 2))) >>
+                                ShiftAmountType(cache_bits - significand_bits - 1 - beta));
+         }
+
+         template <class ShiftAmountType>
+         static constexpr carrier_uint compute_right_endpoint_for_shorter_interval_case(const cache_entry_type& cache,
+                                                                                        ShiftAmountType beta) noexcept
+         {
+            return carrier_uint((cache + (cache >> (significand_bits + 1))) >>
+                                ShiftAmountType(cache_bits - significand_bits - 1 - beta));
+         }
+
+         template <class ShiftAmountType>
+         static constexpr carrier_uint compute_round_up_for_shorter_interval_case(const cache_entry_type& cache,
+                                                                                  ShiftAmountType beta) noexcept
+         {
+            return (carrier_uint(cache >> ShiftAmountType(cache_bits - significand_bits - 2 - beta)) + 1) / 2;
+         }
+      };
+
+      template <class ExponentInt>
+      struct multiplication_traits<ieee754_binary_traits<ieee754_binary64, detail::stdr::uint_least64_t, ExponentInt>,
+                                   detail::wuint::uint128, 128>
+         : public multiplication_traits_base<ieee754_binary_traits<ieee754_binary64, detail::stdr::uint_least64_t>,
+                                             detail::wuint::uint128, 128>
+      {
+         static GLZ_JKJ_CONSTEXPR20 compute_mul_result compute_mul(carrier_uint u,
+                                                                   const cache_entry_type& cache) noexcept
+         {
+            const auto r = detail::wuint::umul192_upper128(u, cache);
+            return {r.high(), r.low() == 0};
+         }
+
+         template <class ShiftAmountType>
+         static constexpr detail::stdr::uint_least64_t compute_delta(const cache_entry_type& cache,
+                                                                     ShiftAmountType beta) noexcept
+         {
+            return detail::stdr::uint_least64_t(cache.high() >> ShiftAmountType(total_bits - 1 - beta));
+         }
+
+         template <class ShiftAmountType>
+         static GLZ_JKJ_CONSTEXPR20 compute_mul_parity_result compute_mul_parity(carrier_uint two_f,
+                                                                                 const cache_entry_type& cache,
+                                                                                 ShiftAmountType beta) noexcept
+         {
+            assert(beta >= 1);
+            assert(beta < 64);
+
+            const auto r = detail::wuint::umul192_lower128(two_f, cache);
+            return {
+               ((r.high() >> ShiftAmountType(64 - beta)) & 1) != 0,
+               (((r.high() << beta) & UINT64_C(0xffffffffffffffff)) | (r.low() >> ShiftAmountType(64 - beta))) == 0};
+         }
+
+         template <class ShiftAmountType>
+         static constexpr carrier_uint compute_left_endpoint_for_shorter_interval_case(const cache_entry_type& cache,
+                                                                                       ShiftAmountType beta) noexcept
+         {
+            return (cache.high() - (cache.high() >> (significand_bits + 2))) >>
+                   ShiftAmountType(total_bits - significand_bits - 1 - beta);
+         }
+
+         template <class ShiftAmountType>
+         static constexpr carrier_uint compute_right_endpoint_for_shorter_interval_case(const cache_entry_type& cache,
+                                                                                        ShiftAmountType beta) noexcept
+         {
+            return (cache.high() + (cache.high() >> (significand_bits + 1))) >>
+                   ShiftAmountType(total_bits - significand_bits - 1 - beta);
+         }
+
+         template <class ShiftAmountType>
+         static constexpr carrier_uint compute_round_up_for_shorter_interval_case(const cache_entry_type& cache,
+                                                                                  ShiftAmountType beta) noexcept
+         {
+            return ((cache.high() >> ShiftAmountType(total_bits - significand_bits - 2 - beta)) + 1) / 2;
+         }
+      };
+
+      namespace detail
+      {
+         ////////////////////////////////////////////////////////////////////////////////////////
+         // The main algorithm.
+         ////////////////////////////////////////////////////////////////////////////////////////
+
+         template <class FormatTraits>
+         struct impl : private FormatTraits::format
+         {
+            using format = typename FormatTraits::format;
+            using carrier_uint = typename FormatTraits::carrier_uint;
+            static constexpr int carrier_bits = FormatTraits::carrier_bits;
+            using exponent_int = typename FormatTraits::exponent_int;
+
+            using format::exponent_bias;
+            using format::max_exponent;
+            using format::min_exponent;
+            using format::significand_bits;
+
+            static constexpr int kappa = log::floor_log10_pow2(carrier_bits - significand_bits - 2) - 1;
+            static_assert(kappa >= 1, "");
+            static_assert(carrier_bits >= significand_bits + 2 + log::floor_log2_pow10(kappa + 1), "");
+#undef min
+#undef max
+            static constexpr int min(int x, int y) noexcept { return x < y ? x : y; }
+            static constexpr int max(int x, int y) noexcept { return x > y ? x : y; }
+
+            static constexpr int min_k =
+               min(-log::floor_log10_pow2_minus_log10_4_over_3(max_exponent - significand_bits),
+                   -log::floor_log10_pow2(max_exponent - significand_bits) + kappa);
+
+            // We do invoke shorter_interval_case for exponent == min_exponent case,
+            // so we should not add 1 here.
+            static constexpr int max_k =
+               max(-log::floor_log10_pow2_minus_log10_4_over_3(min_exponent - significand_bits /*+ 1*/),
+                   -log::floor_log10_pow2(min_exponent - significand_bits) + kappa);
+
+            static constexpr int case_shorter_interval_left_endpoint_lower_threshold = 2;
+            static constexpr int case_shorter_interval_left_endpoint_upper_threshold =
+               2 + log::floor_log2(
+                      compute_power<count_factors<5>((carrier_uint(1) << (significand_bits + 2)) - 1) + 1>(10) / 3);
+
+            static constexpr int case_shorter_interval_right_endpoint_lower_threshold = 0;
+            static constexpr int case_shorter_interval_right_endpoint_upper_threshold =
+               2 + log::floor_log2(
+                      compute_power<count_factors<5>((carrier_uint(1) << (significand_bits + 1)) + 1) + 1>(10) / 3);
+
+            static constexpr int shorter_interval_tie_lower_threshold =
+               -log::floor_log5_pow2_minus_log5_3(significand_bits + 4) - 2 - significand_bits;
+            static constexpr int shorter_interval_tie_upper_threshold =
+               -log::floor_log5_pow2(significand_bits + 2) - 2 - significand_bits;
+
+            template <class PreferredIntegerTypesPolicy>
+            using remainder_type = typename PreferredIntegerTypesPolicy::template remainder_type<
+               FormatTraits, compute_power<kappa + 1>(detail::stdr::uint_least64_t(10))>;
+
+            template <class PreferredIntegerTypesPolicy>
+            using decimal_exponent_type = typename PreferredIntegerTypesPolicy::template decimal_exponent_type<
+               FormatTraits, detail::stdr::int_least32_t(min(-max_k, min_k)),
+               detail::stdr::int_least32_t(max(max_k, -min_k + kappa + 1))>;
+
+            template <class SignPolicy, class TrailingZeroPolicy, class PreferredIntegerTypesPolicy>
+            using return_type = decimal_fp<carrier_uint, decimal_exponent_type<PreferredIntegerTypesPolicy>,
+                                           SignPolicy::return_has_sign, TrailingZeroPolicy::report_trailing_zeros>;
+
+            //// The main algorithm assumes the input is a normal/subnormal finite number.
+
+            template <class SignPolicy, class TrailingZeroPolicy, class IntervalTypeProvider,
+                      class BinaryToDecimalRoundingPolicy, class CachePolicy, class PreferredIntegerTypesPolicy>
+            GLZ_JKJ_SAFEBUFFERS static GLZ_JKJ_CONSTEXPR20
+               return_type<SignPolicy, TrailingZeroPolicy, PreferredIntegerTypesPolicy>
+               compute_nearest(signed_significand_bits<FormatTraits> s, exponent_int exponent_bits) noexcept
+            {
+               using cache_holder_type = typename CachePolicy::template cache_holder_type<format>;
+               static_assert(min_k >= cache_holder_type::min_k && max_k <= cache_holder_type::max_k, "");
+
+               using remainder_type_ = remainder_type<PreferredIntegerTypesPolicy>;
+               using decimal_exponent_type_ = decimal_exponent_type<PreferredIntegerTypesPolicy>;
+               using shift_amount_type = typename PreferredIntegerTypesPolicy::template shift_amount_type<FormatTraits>;
+
+               using multiplication_traits_ =
+                  multiplication_traits<FormatTraits, typename cache_holder_type::cache_entry_type,
+                                        cache_holder_type::cache_bits>;
+
+               auto two_fc = s.remove_sign_bit_and_shift();
+               auto binary_exponent = exponent_bits;
+
+               // Is the input a normal number?
+               if (binary_exponent != 0) {
+                  binary_exponent += format::exponent_bias - format::significand_bits;
+
+                  // Shorter interval case; proceed like Schubfach.
+                  // One might think this condition is wrong, since when exponent_bits ==
+                  // 1 and two_fc == 0, the interval is actually regular. However, it
+                  // turns out that this seemingly wrong condition is actually fine,
+                  // because the end result is anyway the same.
+                  //
+                  // [binary32]
+                  // (fc-1/2) * 2^e = 1.175'494'28... * 10^-38
+                  // (fc-1/4) * 2^e = 1.175'494'31... * 10^-38
+                  //    fc    * 2^e = 1.175'494'35... * 10^-38
+                  // (fc+1/2) * 2^e = 1.175'494'42... * 10^-38
+                  //
+                  // Hence, shorter_interval_case will return 1.175'494'4 * 10^-38.
+                  // 1.175'494'3 * 10^-38 is also a correct shortest representation that
+                  // will be rejected if we assume shorter interval, but 1.175'494'4 *
+                  // 10^-38 is closer to the true value so it doesn't matter.
+                  //
+                  // [binary64]
+                  // (fc-1/2) * 2^e = 2.225'073'858'507'201'13... * 10^-308
+                  // (fc-1/4) * 2^e = 2.225'073'858'507'201'25... * 10^-308
+                  //    fc    * 2^e = 2.225'073'858'507'201'38... * 10^-308
+                  // (fc+1/2) * 2^e = 2.225'073'858'507'201'63... * 10^-308
+                  //
+                  // Hence, shorter_interval_case will return 2.225'073'858'507'201'4 *
+                  // 10^-308. This is indeed of the shortest length, and it is the unique
+                  // one closest to the true value among valid representations of the same
+                  // length.
+                  static_assert(
+                     stdr::is_same<format, ieee754_binary32>::value || stdr::is_same<format, ieee754_binary64>::value,
+                     "");
+
+                  // Shorter interval case.
+                  if (two_fc == 0) {
+                     auto interval_type = IntervalTypeProvider::shorter_interval(s);
+
+                     // Compute k and beta.
+                     const auto minus_k =
+                        log::floor_log10_pow2_minus_log10_4_over_3<min_exponent - format::significand_bits,
+                                                                   max_exponent - format::significand_bits,
+                                                                   decimal_exponent_type_>(binary_exponent);
+                     const auto beta = shift_amount_type(
+                        binary_exponent + log::floor_log2_pow10<min_k, max_k>(decimal_exponent_type_(-minus_k)));
+
+                     // Compute xi and zi.
+                     const auto cache =
+                        CachePolicy::template get_cache<format, shift_amount_type>(decimal_exponent_type_(-minus_k));
+
+                     auto xi = multiplication_traits_::compute_left_endpoint_for_shorter_interval_case(cache, beta);
+                     auto zi = multiplication_traits_::compute_right_endpoint_for_shorter_interval_case(cache, beta);
+
+                     // If we don't accept the right endpoint and
+                     // if the right endpoint is an integer, decrease it.
+                     if (!interval_type.include_right_endpoint() &&
+                         is_right_endpoint_integer_shorter_interval(binary_exponent)) {
+                        --zi;
+                     }
+                     // If we don't accept the left endpoint or
+                     // if the left endpoint is not an integer, increase it.
+                     if (!interval_type.include_left_endpoint() ||
+                         !is_left_endpoint_integer_shorter_interval(binary_exponent)) {
+                        ++xi;
+                     }
+
+                     // Try bigger divisor.
+                     // zi is at most floor((f_c + 1/2) * 2^e * 10^k0).
+                     // Substituting f_c = 2^p and k0 = -floor(log10(3 * 2^(e-2))), we get
+                     // zi <= floor((2^(p+1) + 1) * 20/3) <= ceil((2^(p+1) + 1)/3) * 20.
+                     // This computation does not overflow for any of the formats I care about.
+                     carrier_uint decimal_significand = div::divide_by_pow10<
+                        1, carrier_uint,
+                        carrier_uint(((((carrier_uint(1) << (significand_bits + 1)) + 1) / 3) + 1) * 20)>(zi);
+
+                     // If succeed, remove trailing zeros if necessary and return.
+                     if (decimal_significand * 10 >= xi) {
+                        return SignPolicy::handle_sign(s, TrailingZeroPolicy::template on_trailing_zeros<format>(
+                                                             decimal_significand, decimal_exponent_type_(minus_k + 1)));
+                     }
+
+                     // Otherwise, compute the round-up of y.
+                     decimal_significand =
+                        multiplication_traits_::compute_round_up_for_shorter_interval_case(cache, beta);
+
+                     // When tie occurs, choose one of them according to the rule.
+                     if (BinaryToDecimalRoundingPolicy::prefer_round_down(decimal_significand) &&
+                         binary_exponent >= shorter_interval_tie_lower_threshold &&
+                         binary_exponent <= shorter_interval_tie_upper_threshold) {
+                        --decimal_significand;
+                     }
+                     else if (decimal_significand < xi) {
+                        ++decimal_significand;
+                     }
+                     return SignPolicy::handle_sign(s, TrailingZeroPolicy::template no_trailing_zeros<format>(
+                                                          decimal_significand, decimal_exponent_type_(minus_k)));
+                  }
+
+                  // Normal interval case.
+                  two_fc |= (carrier_uint(1) << (format::significand_bits + 1));
+               }
+               // Is the input a subnormal number?
+               else {
+                  // Normal interval case.
+                  binary_exponent = format::min_exponent - format::significand_bits;
+               }
+
+               //////////////////////////////////////////////////////////////////////
+               // Step 1: Schubfach multiplier calculation.
+               //////////////////////////////////////////////////////////////////////
+
+               auto interval_type = IntervalTypeProvider::normal_interval(s);
+
+               // Compute k and beta.
+               const auto minus_k = decimal_exponent_type_(
+                  log::floor_log10_pow2<min_exponent - format::significand_bits,
+                                        max_exponent - format::significand_bits, decimal_exponent_type_>(
+                     binary_exponent) -
+                  kappa);
+               const auto cache =
+                  CachePolicy::template get_cache<format, shift_amount_type>(decimal_exponent_type_(-minus_k));
+               const auto beta = shift_amount_type(
+                  binary_exponent + log::floor_log2_pow10<min_k, max_k>(decimal_exponent_type_(-minus_k)));
+
+               // Compute zi and deltai.
+               // 10^kappa <= deltai < 10^(kappa + 1)
+               const auto deltai = static_cast<remainder_type_>(multiplication_traits_::compute_delta(cache, beta));
+               // For the case of binary32, the result of integer check is not correct for
+               // 29711844 * 2^-82
+               // = 6.1442653300000000008655037797566933477355632930994033813476... * 10^-18
+               // and 29711844 * 2^-81
+               // = 1.2288530660000000001731007559513386695471126586198806762695... * 10^-17,
+               // and they are the unique counterexamples. However, since 29711844 is even,
+               // this does not cause any problem for the endpoints calculations; it can only
+               // cause a problem when we need to perform integer check for the center.
+               // Fortunately, with these inputs, that branch is never executed, so we are
+               // fine.
+               const auto z_result = multiplication_traits_::compute_mul(carrier_uint((two_fc | 1) << beta), cache);
+
+               //////////////////////////////////////////////////////////////////////
+               // Step 2: Try larger divisor; remove trailing zeros if necessary.
+               //////////////////////////////////////////////////////////////////////
+
+               constexpr auto big_divisor = compute_power<kappa + 1>(remainder_type_(10));
+               constexpr auto small_divisor = compute_power<kappa>(remainder_type_(10));
+
+               // Using an upper bound on zi, we might be able to optimize the division
+               // better than the compiler; we are computing zi / big_divisor here.
+               carrier_uint decimal_significand =
+                  div::divide_by_pow10<kappa + 1, carrier_uint,
+                                       carrier_uint((carrier_uint(1) << (significand_bits + 1)) * big_divisor - 1)>(
+                     z_result.integer_part);
+               auto r = remainder_type_(z_result.integer_part - big_divisor * decimal_significand);
+
+               do {
+                  if (r < deltai) {
+                     // Exclude the right endpoint if necessary.
+                     if ((r | remainder_type_(!z_result.is_integer) |
+                          remainder_type_(interval_type.include_right_endpoint())) == 0) {
+                        GLZ_JKJ_IF_CONSTEXPR(BinaryToDecimalRoundingPolicy::tag ==
+                                             policy::binary_to_decimal_rounding::tag_t::do_not_care)
+                        {
+                           decimal_significand *= 10;
+                           --decimal_significand;
+                           return SignPolicy::handle_sign(
+                              s, TrailingZeroPolicy::template no_trailing_zeros<format>(
+                                    decimal_significand, decimal_exponent_type_(minus_k + kappa)));
+                        }
+                        else
+                        {
+                           --decimal_significand;
+                           r = big_divisor;
+                           break;
+                        }
+                     }
+                  }
+                  else if (r > deltai) {
+                     break;
+                  }
+                  else {
+                     // r == deltai; compare fractional parts.
+                     const auto x_result =
+                        multiplication_traits_::compute_mul_parity(carrier_uint(two_fc - 1), cache, beta);
+
+                     if (!(x_result.parity | (x_result.is_integer & interval_type.include_left_endpoint()))) {
+                        break;
+                     }
+                  }
+
+                  // We may need to remove trailing zeros.
+                  return SignPolicy::handle_sign(s,
+                                                 TrailingZeroPolicy::template on_trailing_zeros<format>(
+                                                    decimal_significand, decimal_exponent_type_(minus_k + kappa + 1)));
+               } while (false);
+
+               //////////////////////////////////////////////////////////////////////
+               // Step 3: Find the significand with the smaller divisor.
+               //////////////////////////////////////////////////////////////////////
+
+               decimal_significand *= 10;
+
+               GLZ_JKJ_IF_CONSTEXPR(BinaryToDecimalRoundingPolicy::tag ==
+                                    policy::binary_to_decimal_rounding::tag_t::do_not_care)
+               {
+                  // Normally, we want to compute
+                  // significand += r / small_divisor
+                  // and return, but we need to take care of the case that the resulting
+                  // value is exactly the right endpoint, while that is not included in the
+                  // interval.
+                  if (!interval_type.include_right_endpoint()) {
+                     // Is r divisible by 10^kappa?
+                     if (div::check_divisibility_and_divide_by_pow10<kappa>(r) && z_result.is_integer) {
+                        // This should be in the interval.
+                        decimal_significand += r - 1;
+                     }
+                     else {
+                        decimal_significand += r;
+                     }
+                  }
+                  else {
+                     decimal_significand += div::small_division_by_pow10<kappa>(r);
+                  }
+               }
+               else
+               {
+                  // delta is equal to 10^(kappa + elog10(2) - floor(elog10(2))), so dist cannot
+                  // be larger than r.
+                  auto dist = remainder_type_(r - (deltai / 2) + (small_divisor / 2));
+                  const bool approx_y_parity = ((dist ^ (small_divisor / 2)) & 1) != 0;
+
+                  // Is dist divisible by 10^kappa?
+                  const bool divisible_by_small_divisor = div::check_divisibility_and_divide_by_pow10<kappa>(dist);
+
+                  // Add dist / 10^kappa to the significand.
+                  decimal_significand += dist;
+
+                  if (divisible_by_small_divisor) {
+                     // Check z^(f) >= epsilon^(f).
+                     // We have either yi == zi - epsiloni or yi == (zi - epsiloni) - 1,
+                     // where yi == zi - epsiloni if and only if z^(f) >= epsilon^(f).
+                     // Since there are only 2 possibilities, we only need to care about the
+                     // parity. Also, zi and r should have the same parity since the divisor
+                     // is an even number.
+                     const auto y_result = multiplication_traits_::compute_mul_parity(two_fc, cache, beta);
+                     if (y_result.parity != approx_y_parity) {
+                        --decimal_significand;
+                     }
+                     else {
+                        // If z^(f) >= epsilon^(f), we might have a tie
+                        // when z^(f) == epsilon^(f), or equivalently, when y is an integer.
+                        // For tie-to-up case, we can just choose the upper one.
+                        if (BinaryToDecimalRoundingPolicy::prefer_round_down(decimal_significand) &
+                            y_result.is_integer) {
+                           --decimal_significand;
+                        }
+                     }
+                  }
+               }
+               return SignPolicy::handle_sign(s, TrailingZeroPolicy::template no_trailing_zeros<format>(
+                                                    decimal_significand, decimal_exponent_type_(minus_k + kappa)));
+            }
+
+            template <class SignPolicy, class TrailingZeroPolicy, class CachePolicy, class PreferredIntegerTypesPolicy>
+            GLZ_JKJ_FORCEINLINE GLZ_JKJ_SAFEBUFFERS static GLZ_JKJ_CONSTEXPR20
+               return_type<SignPolicy, TrailingZeroPolicy, PreferredIntegerTypesPolicy>
+               compute_left_closed_directed(signed_significand_bits<FormatTraits> s,
+                                            exponent_int exponent_bits) noexcept
+            {
+               using cache_holder_type = typename CachePolicy::template cache_holder_type<format>;
+               static_assert(min_k >= cache_holder_type::min_k && max_k <= cache_holder_type::max_k, "");
+
+               using remainder_type_ = remainder_type<PreferredIntegerTypesPolicy>;
+               using decimal_exponent_type_ = decimal_exponent_type<PreferredIntegerTypesPolicy>;
+               using shift_amount_type = typename PreferredIntegerTypesPolicy::template shift_amount_type<FormatTraits>;
+
+               using multiplication_traits_ =
+                  multiplication_traits<FormatTraits, typename cache_holder_type::cache_entry_type,
+                                        cache_holder_type::cache_bits>;
+
+               auto two_fc = s.remove_sign_bit_and_shift();
+               auto binary_exponent = exponent_bits;
+
+               // Is the input a normal number?
+               if (binary_exponent != 0) {
+                  binary_exponent += format::exponent_bias - format::significand_bits;
+                  two_fc |= (carrier_uint(1) << (format::significand_bits + 1));
+               }
+               // Is the input a subnormal number?
+               else {
+                  binary_exponent = format::min_exponent - format::significand_bits;
+               }
+
+               //////////////////////////////////////////////////////////////////////
+               // Step 1: Schubfach multiplier calculation.
+               //////////////////////////////////////////////////////////////////////
+
+               // Compute k and beta.
+               const auto minus_k = decimal_exponent_type_(
+                  log::floor_log10_pow2<format::min_exponent - format::significand_bits,
+                                        format::max_exponent - format::significand_bits, decimal_exponent_type_>(
+                     binary_exponent) -
+                  kappa);
+               const auto cache =
+                  CachePolicy::template get_cache<format, shift_amount_type>(decimal_exponent_type_(-minus_k));
+               const auto beta = shift_amount_type(
+                  binary_exponent + log::floor_log2_pow10<min_k, max_k>(decimal_exponent_type_(-minus_k)));
+
+               // Compute xi and deltai.
+               // 10^kappa <= deltai < 10^(kappa + 1)
+               const auto deltai = static_cast<remainder_type_>(multiplication_traits_::compute_delta(cache, beta));
+               auto x_result = multiplication_traits_::compute_mul(carrier_uint(two_fc << beta), cache);
+
+               // Deal with the unique exceptional cases
+               // 29711844 * 2^-82
+               // = 6.1442653300000000008655037797566933477355632930994033813476... * 10^-18
+               // and 29711844 * 2^-81
+               // = 1.2288530660000000001731007559513386695471126586198806762695... * 10^-17
+               // for binary32.
+               GLZ_JKJ_IF_CONSTEXPR(stdr::is_same<format, ieee754_binary32>::value)
+               {
+                  if (binary_exponent <= -80) {
+                     x_result.is_integer = false;
+                  }
+               }
+
+               if (!x_result.is_integer) {
+                  ++x_result.integer_part;
+               }
+
+               //////////////////////////////////////////////////////////////////////
+               // Step 2: Try larger divisor; remove trailing zeros if necessary.
+               //////////////////////////////////////////////////////////////////////
+
+               constexpr auto big_divisor = compute_power<kappa + 1>(remainder_type_(10));
+
+               // Using an upper bound on xi, we might be able to optimize the division
+               // better than the compiler; we are computing xi / big_divisor here.
+               carrier_uint decimal_significand =
+                  div::divide_by_pow10<kappa + 1, carrier_uint,
+                                       carrier_uint((carrier_uint(1) << (significand_bits + 1)) * big_divisor - 1)>(
+                     x_result.integer_part);
+               auto r = remainder_type_(x_result.integer_part - big_divisor * decimal_significand);
+
+               if (r != 0) {
+                  ++decimal_significand;
+                  r = remainder_type_(big_divisor - r);
+               }
+
+               do {
+                  if (r > deltai) {
+                     break;
+                  }
+                  else if (r == deltai) {
+                     // Compare the fractional parts.
+                     // This branch is never taken for the exceptional cases
+                     // 2f_c = 29711482, e = -81
+                     // (6.1442649164096937243516663440523473127541365101933479309082... *
+                     // 10^-18) and 2f_c = 29711482, e = -80
+                     // (1.2288529832819387448703332688104694625508273020386695861816... *
+                     // 10^-17).
+                     // For the case of compressed cache for binary32, there is another
+                     // exceptional case 2f_c = 33554430, e = -10 (16383.9990234375). In this
+                     // case, the recovered cache is two large to make compute_mul_parity
+                     // mistakenly conclude that z is not an integer, but actually z = 16384 is
+                     // an integer.
+                     GLZ_JKJ_IF_CONSTEXPR(
+                        stdr::is_same<cache_holder_type, compressed_cache_holder<ieee754_binary32>>::value)
+                     {
+                        if (two_fc == 33554430 && binary_exponent == -10) {
+                           break;
+                        }
+                     }
+                     const auto z_result =
+                        multiplication_traits_::compute_mul_parity(carrier_uint(two_fc + 2), cache, beta);
+                     if (z_result.parity || z_result.is_integer) {
+                        break;
+                     }
+                  }
+
+                  // The ceiling is inside, so we are done.
+                  return SignPolicy::handle_sign(s,
+                                                 TrailingZeroPolicy::template on_trailing_zeros<format>(
+                                                    decimal_significand, decimal_exponent_type_(minus_k + kappa + 1)));
+               } while (false);
+
+               //////////////////////////////////////////////////////////////////////
+               // Step 3: Find the significand with the smaller divisor.
+               //////////////////////////////////////////////////////////////////////
+
+               decimal_significand *= 10;
+               decimal_significand -= div::small_division_by_pow10<kappa>(r);
+               return SignPolicy::handle_sign(s, TrailingZeroPolicy::template no_trailing_zeros<format>(
+                                                    decimal_significand, decimal_exponent_type_(minus_k + kappa)));
+            }
+
+            template <class SignPolicy, class TrailingZeroPolicy, class CachePolicy, class PreferredIntegerTypesPolicy>
+            GLZ_JKJ_FORCEINLINE GLZ_JKJ_SAFEBUFFERS static GLZ_JKJ_CONSTEXPR20
+               return_type<SignPolicy, TrailingZeroPolicy, PreferredIntegerTypesPolicy>
+               compute_right_closed_directed(signed_significand_bits<FormatTraits> s,
+                                             exponent_int exponent_bits) noexcept
+            {
+               using cache_holder_type = typename CachePolicy::template cache_holder_type<format>;
+               static_assert(min_k >= cache_holder_type::min_k && max_k <= cache_holder_type::max_k, "");
+
+               using remainder_type_ = remainder_type<PreferredIntegerTypesPolicy>;
+               using decimal_exponent_type_ = decimal_exponent_type<PreferredIntegerTypesPolicy>;
+               using shift_amount_type = typename PreferredIntegerTypesPolicy::template shift_amount_type<FormatTraits>;
+
+               using multiplication_traits_ =
+                  multiplication_traits<FormatTraits, typename cache_holder_type::cache_entry_type,
+                                        cache_holder_type::cache_bits>;
+
+               auto two_fc = s.remove_sign_bit_and_shift();
+               auto binary_exponent = exponent_bits;
+               bool shorter_interval = false;
+
+               // Is the input a normal number?
+               if (binary_exponent != 0) {
+                  if (two_fc == 0 && binary_exponent != 1) {
+                     shorter_interval = true;
+                  }
+                  binary_exponent += format::exponent_bias - format::significand_bits;
+                  two_fc |= (carrier_uint(1) << (format::significand_bits + 1));
+               }
+               // Is the input a subnormal number?
+               else {
+                  binary_exponent = format::min_exponent - format::significand_bits;
+               }
+
+               //////////////////////////////////////////////////////////////////////
+               // Step 1: Schubfach multiplier calculation.
+               //////////////////////////////////////////////////////////////////////
+
+               // Compute k and beta.
+               const auto minus_k = decimal_exponent_type_(
+                  log::floor_log10_pow2<format::min_exponent - format::significand_bits,
+                                        format::max_exponent - format::significand_bits, decimal_exponent_type_>(
+                     exponent_int(binary_exponent - (shorter_interval ? 1 : 0))) -
+                  kappa);
+               const auto cache =
+                  CachePolicy::template get_cache<format, shift_amount_type>(decimal_exponent_type_(-minus_k));
+               const auto beta =
+                  shift_amount_type(binary_exponent + log::floor_log2_pow10(decimal_exponent_type_(-minus_k)));
+
+               // Compute zi and deltai.
+               // 10^kappa <= deltai < 10^(kappa + 1)
+               const auto deltai = static_cast<remainder_type_>(
+                  multiplication_traits_::compute_delta(cache, shift_amount_type(beta - (shorter_interval ? 1 : 0))));
+               const carrier_uint zi =
+                  multiplication_traits_::compute_mul(carrier_uint(two_fc << beta), cache).integer_part;
+
+               //////////////////////////////////////////////////////////////////////
+               // Step 2: Try larger divisor; remove trailing zeros if necessary.
+               //////////////////////////////////////////////////////////////////////
+
+               constexpr auto big_divisor = compute_power<kappa + 1>(remainder_type_(10));
+
+               // Using an upper bound on zi, we might be able to optimize the division better
+               // than the compiler; we are computing zi / big_divisor here.
+               carrier_uint decimal_significand =
+                  div::divide_by_pow10<kappa + 1, carrier_uint,
+                                       carrier_uint((carrier_uint(1) << (significand_bits + 1)) * big_divisor - 1)>(zi);
+               const auto r = remainder_type_(zi - big_divisor * decimal_significand);
+
+               do {
+                  if (r > deltai) {
+                     break;
+                  }
+                  else if (r == deltai) {
+                     // Compare the fractional parts.
+                     if (!multiplication_traits_::compute_mul_parity(carrier_uint(two_fc - (shorter_interval ? 1 : 2)),
+                                                                     cache, beta)
+                             .parity) {
+                        break;
+                     }
+                  }
+
+                  // The floor is inside, so we are done.
+                  return SignPolicy::handle_sign(s,
+                                                 TrailingZeroPolicy::template on_trailing_zeros<format>(
+                                                    decimal_significand, decimal_exponent_type_(minus_k + kappa + 1)));
+               } while (false);
+
+               //////////////////////////////////////////////////////////////////////
+               // Step 3: Find the significand with the small divisor.
+               //////////////////////////////////////////////////////////////////////
+
+               decimal_significand *= 10;
+               decimal_significand += div::small_division_by_pow10<kappa>(r);
+               return SignPolicy::handle_sign(s, TrailingZeroPolicy::template no_trailing_zeros<format>(
+                                                    decimal_significand, decimal_exponent_type_(minus_k + kappa)));
+            }
+
+            static constexpr bool is_right_endpoint_integer_shorter_interval(exponent_int binary_exponent) noexcept
+            {
+               return binary_exponent >= case_shorter_interval_right_endpoint_lower_threshold &&
+                      binary_exponent <= case_shorter_interval_right_endpoint_upper_threshold;
+            }
+
+            static constexpr bool is_left_endpoint_integer_shorter_interval(exponent_int binary_exponent) noexcept
+            {
+               return binary_exponent >= case_shorter_interval_left_endpoint_lower_threshold &&
+                      binary_exponent <= case_shorter_interval_left_endpoint_upper_threshold;
+            }
+         };
+
+         ////////////////////////////////////////////////////////////////////////////////////////
+         // Policy holder.
+         ////////////////////////////////////////////////////////////////////////////////////////
+
+         // The library will specify a list of accepted kinds of policies and their defaults,
+         // and the user will pass a list of policies parameters. The policy parameters are
+         // supposed to be stateless and only convey information through their types.
+         // The aim of the helper classes/functions given below is to do the following:
+         //   1. Check if the policy parameters given by the user are all valid; that means,
+         //      each of them should be at least of one of the kinds specified by the library.
+         //      If that's not the case, then the compilation fails.
+         //   2. Check if multiple policy parameters for the same kind is specified by the
+         //      user. If that's the case, then the compilation fails.
+         //   3. Build a class deriving from all policies the user have given, and also from
+         //      the default policies if the user did not specify one for some kinds.
+         // The library considers a certain policy parameter to belong to a specific kind if and only
+         // if the parameter's type has a member type with a specific name; for example, it belongs
+         // to "sign policy" kind if there is a member type sign_policy.
+
+         // For a given kind, find a policy belonging to that kind.
+         // Check if there are more than one such policies.
+         enum class policy_found_info { not_found, unique, repeated };
+         template <class Policy, policy_found_info info>
+         struct found_policy_pair
+         {
+            // Either the policy parameter type given by the user, or the default policy.
+            using policy = Policy;
+            static constexpr auto found_info = info;
+         };
+
+         template <class KindDetector, class DefaultPolicy>
+         struct detector_default_pair
+         {
+            using kind_detector = KindDetector;
+
+            // Iterate through all given policy parameter types and see if there is a policy
+            // parameter type belonging to the policy kind specified by KindDetector.
+            // 1. If there is none, get_found_policy_pair returns
+            //    found_policy_pair<DefaultPolicy, policy_found_info::not_found>.
+            // 2. If there is only one parameter type belonging to the specified kind, then
+            //    get_found_policy_pair returns
+            //    found_policy_pair<Policy, policy_found_info::unique>
+            //    where Policy is the unique parameter type belonging to the specified kind.
+            // 3. If there are multiple parameter types belonging to the specified kind, then
+            //    get_found_policy_pair returns
+            //    found_policy_pair<FirstPolicy, policy_found_info::repeated>
+            //    where FirstPolicy is the first parameter type belonging to the specified kind.
+            //    The compilation must fail if this happens.
+            // This is done by first setting FoundPolicyInfo below to
+            // found_policy_pair<DefaultPolicy, policy_found_info::not_found>, and then iterate
+            // over Policies, replacing FoundPolicyInfo by the appropriate one if a parameter
+            // type belonging to the specified kind is found.
+
+            template <class FoundPolicyInfo, class... Policies>
+            struct get_found_policy_pair_impl;
+
+            template <class FoundPolicyInfo>
+            struct get_found_policy_pair_impl<FoundPolicyInfo>
+            {
+               using type = FoundPolicyInfo;
+            };
+
+            template <class FoundPolicyInfo, class FirstPolicy, class... RemainingPolicies>
+            struct get_found_policy_pair_impl<FoundPolicyInfo, FirstPolicy, RemainingPolicies...>
+            {
+               using type = typename stdr::conditional<
+                  KindDetector{}(dummy<FirstPolicy>{}),
+                  typename stdr::conditional<
+                     FoundPolicyInfo::found_info == policy_found_info::not_found,
+                     typename get_found_policy_pair_impl<found_policy_pair<FirstPolicy, policy_found_info::unique>,
+                                                         RemainingPolicies...>::type,
+                     typename get_found_policy_pair_impl<found_policy_pair<FirstPolicy, policy_found_info::repeated>,
+                                                         RemainingPolicies...>::type>::type,
+                  typename get_found_policy_pair_impl<FoundPolicyInfo, RemainingPolicies...>::type>::type;
+            };
+
+            template <class... Policies>
+            using get_found_policy_pair =
+               typename get_found_policy_pair_impl<found_policy_pair<DefaultPolicy, policy_found_info::not_found>,
+                                                   Policies...>::type;
+         };
+
+         // Simple typelist of detector_default_pair's.
+         template <class... DetectorDefaultPairs>
+         struct detector_default_pair_list
+         {};
+
+         // Check if a given policy belongs to one of the kinds specified by the library.
+         template <class Policy>
+         constexpr bool check_policy_validity(dummy<Policy>, detector_default_pair_list<>) noexcept
+         {
+            return false;
+         }
+         template <class Policy, class FirstDetectorDefaultPair, class... RemainingDetectorDefaultPairs>
+         constexpr bool check_policy_validity(
+            dummy<Policy>,
+            detector_default_pair_list<FirstDetectorDefaultPair, RemainingDetectorDefaultPairs...>) noexcept
+         {
+            return
+               typename FirstDetectorDefaultPair::kind_detector{}(dummy<Policy>{}) ||
+               check_policy_validity(dummy<Policy>{}, detector_default_pair_list<RemainingDetectorDefaultPairs...>{});
+         }
+
+         // Check if all of policies belong to some of the kinds specified by the library.
+         template <class DetectorDefaultPairList>
+         constexpr bool check_policy_list_validity(DetectorDefaultPairList) noexcept
+         {
+            return true;
+         }
+         template <class DetectorDefaultPairList, class FirstPolicy, class... RemainingPolicies>
+         constexpr bool check_policy_list_validity(DetectorDefaultPairList, dummy<FirstPolicy> first_policy,
+                                                   dummy<RemainingPolicies>... remaining_policies)
+         {
+            return check_policy_validity(first_policy, DetectorDefaultPairList{}) &&
+                   check_policy_list_validity(DetectorDefaultPairList{}, remaining_policies...);
+         }
+
+         // Actual policy holder class deriving from all specified policy types.
+         template <class... Policies>
+         struct policy_holder : Policies...
+         {};
+
+         // Iterate through the library-specified list of base-default pairs, i.e., the list of
+         // policy kinds and their defaults. For each base-default pair, call
+         // base_default_pair::get_found_policy_pair on the list of user-specified list of
+         // policies to get found_policy_pair, and build the list of them.
+
+         template <bool repeated_, class... FoundPolicyPairs>
+         struct found_policy_pair_list
+         {
+            // This will be set to be true if and only if there exists at least one
+            // found_policy_pair inside FoundPolicyPairs with
+            // found_info == policy_found_info::repeated, in which case the compilation must
+            // fail.
+            static constexpr bool repeated = repeated_;
+         };
+
+         // Iterate through DetectorDefaultPairList and augment FoundPolicyPairList by one at each
+         // iteration.
+         template <class DetectorDefaultPairList, class FoundPolicyPairList, class... Policies>
+         struct make_policy_pair_list_impl;
+
+         // When there is no more detector-default pair to iterate, then the current
+         // found_policy_pair_list is the final result.
+         template <bool repeated, class... FoundPolicyPairs, class... Policies>
+         struct make_policy_pair_list_impl<detector_default_pair_list<>,
+                                           found_policy_pair_list<repeated, FoundPolicyPairs...>, Policies...>
+         {
+            using type = found_policy_pair_list<repeated, FoundPolicyPairs...>;
+         };
+
+         // For the first detector-default pair in the remaining list, call
+         // detector_default_pair::get_found_policy_pair on Policies and add the returned
+         // found_policy_pair into the current list of found_policy_pair's, and move to the next
+         // detector-default pair.
+         template <class FirstDetectorDefaultPair, class... RemainingDetectorDefaultPairs, bool repeated,
+                   class... FoundPolicyPairs, class... Policies>
+         struct make_policy_pair_list_impl<
+            detector_default_pair_list<FirstDetectorDefaultPair, RemainingDetectorDefaultPairs...>,
+            found_policy_pair_list<repeated, FoundPolicyPairs...>, Policies...>
+         {
+            using new_found_policy_pair =
+               typename FirstDetectorDefaultPair::template get_found_policy_pair<Policies...>;
+
+            using type = typename make_policy_pair_list_impl<
+               detector_default_pair_list<RemainingDetectorDefaultPairs...>,
+               found_policy_pair_list<(repeated || new_found_policy_pair::found_info == policy_found_info::repeated),
+                                      new_found_policy_pair, FoundPolicyPairs...>,
+               Policies...>::type;
+         };
+
+         template <class DetectorDefaultPairList, class... Policies>
+         using policy_pair_list = typename make_policy_pair_list_impl<DetectorDefaultPairList,
+                                                                      found_policy_pair_list<false>, Policies...>::type;
+
+         // Unpack FoundPolicyPairList into found_policy_pair's and build the policy_holder type
+         // from the corresponding typelist of found_policy_pair::policy's.
+         template <class FoundPolicyPairList, class... RawPolicies>
+         struct convert_to_policy_holder_impl;
+
+         template <bool repeated, class... RawPolicies>
+         struct convert_to_policy_holder_impl<found_policy_pair_list<repeated>, RawPolicies...>
+         {
+            using type = policy_holder<RawPolicies...>;
+         };
+
+         template <bool repeated, class FirstFoundPolicyPair, class... RemainingFoundPolicyPairs, class... RawPolicies>
+         struct convert_to_policy_holder_impl<
+            found_policy_pair_list<repeated, FirstFoundPolicyPair, RemainingFoundPolicyPairs...>, RawPolicies...>
+         {
+            using type =
+               typename convert_to_policy_holder_impl<found_policy_pair_list<repeated, RemainingFoundPolicyPairs...>,
+                                                      typename FirstFoundPolicyPair::policy, RawPolicies...>::type;
+         };
+
+         template <class FoundPolicyPairList>
+         using convert_to_policy_holder = typename convert_to_policy_holder_impl<FoundPolicyPairList>::type;
+
+         template <class DetectorDefaultPairList, class... Policies>
+         struct make_policy_holder_impl
+         {
+            static_assert(check_policy_list_validity(DetectorDefaultPairList{}, dummy<Policies>{}...),
+                          "jkj::dragonbox: an invalid policy is specified");
+
+            static_assert(!policy_pair_list<DetectorDefaultPairList, Policies...>::repeated,
+                          "jkj::dragonbox: at most one policy should be specified for each policy kind");
+
+            using type = convert_to_policy_holder<policy_pair_list<DetectorDefaultPairList, Policies...>>;
+         };
+
+         template <class DetectorDefaultPairList, class... Policies>
+         using make_policy_holder = typename make_policy_holder_impl<DetectorDefaultPairList, Policies...>::type;
+
+         // Policy kind detectors.
+         struct is_sign_policy
+         {
+            constexpr bool operator()(...) noexcept { return false; }
+            template <class Policy, class = typename Policy::sign_policy>
+            constexpr bool operator()(dummy<Policy>) noexcept
+            {
+               return true;
+            }
+         };
+         struct is_trailing_zero_policy
+         {
+            constexpr bool operator()(...) noexcept { return false; }
+            template <class Policy, class = typename Policy::trailing_zero_policy>
+            constexpr bool operator()(dummy<Policy>) noexcept
+            {
+               return true;
+            }
+         };
+         struct is_decimal_to_binary_rounding_policy
+         {
+            constexpr bool operator()(...) noexcept { return false; }
+            template <class Policy, class = typename Policy::decimal_to_binary_rounding_policy>
+            constexpr bool operator()(dummy<Policy>) noexcept
+            {
+               return true;
+            }
+         };
+         struct is_binary_to_decimal_rounding_policy
+         {
+            constexpr bool operator()(...) noexcept { return false; }
+            template <class Policy, class = typename Policy::binary_to_decimal_rounding_policy>
+            constexpr bool operator()(dummy<Policy>) noexcept
+            {
+               return true;
+            }
+         };
+         struct is_cache_policy
+         {
+            constexpr bool operator()(...) noexcept { return false; }
+            template <class Policy, class = typename Policy::cache_policy>
+            constexpr bool operator()(dummy<Policy>) noexcept
+            {
+               return true;
+            }
+         };
+         struct is_preferred_integer_types_policy
+         {
+            constexpr bool operator()(...) noexcept { return false; }
+            template <class Policy, class = typename Policy::preferred_integer_types_policy>
+            constexpr bool operator()(dummy<Policy>) noexcept
+            {
+               return true;
+            }
+         };
+
+         template <class... Policies>
+         using to_decimal_policy_holder = make_policy_holder<
+            detector_default_pair_list<
+               detector_default_pair<is_sign_policy, policy::sign::return_sign_t>,
+               detector_default_pair<is_trailing_zero_policy, policy::trailing_zero::remove_t>,
+               detector_default_pair<is_decimal_to_binary_rounding_policy,
+                                     policy::decimal_to_binary_rounding::nearest_to_even_t>,
+               detector_default_pair<is_binary_to_decimal_rounding_policy,
+                                     policy::binary_to_decimal_rounding::to_even_t>,
+               detector_default_pair<is_cache_policy, policy::cache::full_t>,
+               detector_default_pair<is_preferred_integer_types_policy, policy::preferred_integer_types::match_t>>,
+            Policies...>;
+
+         template <class FormatTraits, class... Policies>
+         using to_decimal_return_type = typename impl<FormatTraits>::template return_type<
+            typename to_decimal_policy_holder<Policies...>::sign_policy,
+            typename to_decimal_policy_holder<Policies...>::trailing_zero_policy,
+            typename to_decimal_policy_holder<Policies...>::preferred_integer_types_policy>;
+
+         template <class FormatTraits, class PolicyHolder>
+         struct to_decimal_dispatcher
+         {
+            using sign_policy = typename PolicyHolder::sign_policy;
+            using trailing_zero_policy = typename PolicyHolder::trailing_zero_policy;
+            using binary_to_decimal_rounding_policy = typename PolicyHolder::binary_to_decimal_rounding_policy;
+            using cache_policy = typename PolicyHolder::cache_policy;
+            using preferred_integer_types_policy = typename PolicyHolder::preferred_integer_types_policy;
+            using return_type = typename impl<FormatTraits>::template return_type<sign_policy, trailing_zero_policy,
+                                                                                  preferred_integer_types_policy>;
+
+            template <class IntervalTypeProvider>
+            GLZ_JKJ_FORCEINLINE GLZ_JKJ_SAFEBUFFERS GLZ_JKJ_CONSTEXPR20 return_type
+            operator()(IntervalTypeProvider, signed_significand_bits<FormatTraits> s,
+                       typename FormatTraits::exponent_int exponent_bits) noexcept
+            {
+               constexpr auto tag = IntervalTypeProvider::tag;
+
+               GLZ_JKJ_IF_CONSTEXPR(tag == policy::decimal_to_binary_rounding::tag_t::to_nearest)
+               {
+                  return impl<FormatTraits>::template compute_nearest<
+                     sign_policy, trailing_zero_policy, IntervalTypeProvider, binary_to_decimal_rounding_policy,
+                     cache_policy, preferred_integer_types_policy>(s, exponent_bits);
+               }
+               else GLZ_JKJ_IF_CONSTEXPR(tag == policy::decimal_to_binary_rounding::tag_t::left_closed_directed)
+               {
+                  return impl<FormatTraits>::template compute_left_closed_directed<
+                     sign_policy, trailing_zero_policy, cache_policy, preferred_integer_types_policy>(s, exponent_bits);
+               }
+               else
+               {
+#if GLZ_JKJ_HAS_IF_CONSTEXPR
+                  static_assert(tag == policy::decimal_to_binary_rounding::tag_t::right_closed_directed, "");
+#endif
+                  return impl<FormatTraits>::template compute_right_closed_directed<
+                     sign_policy, trailing_zero_policy, cache_policy, preferred_integer_types_policy>(s, exponent_bits);
+               }
+            }
+         };
+      }
+
+      ////////////////////////////////////////////////////////////////////////////////////////
+      // The interface function.
+      ////////////////////////////////////////////////////////////////////////////////////////
+
+      template <class FormatTraits, class ExponentBits, class... Policies>
+      GLZ_JKJ_FORCEINLINE GLZ_JKJ_SAFEBUFFERS GLZ_JKJ_CONSTEXPR20
+         detail::to_decimal_return_type<FormatTraits, Policies...>
+         to_decimal_ex(signed_significand_bits<FormatTraits> s, ExponentBits exponent_bits, Policies...) noexcept
+      {
+         // Build policy holder type.
+         using policy_holder = detail::to_decimal_policy_holder<Policies...>;
+
+         return policy_holder::delegate(s, detail::to_decimal_dispatcher<FormatTraits, policy_holder>{}, s,
+                                        exponent_bits);
+      }
+
+      template <class Float, class ConversionTraits = default_float_bit_carrier_conversion_traits<Float>,
+                class FormatTraits =
+                   ieee754_binary_traits<typename ConversionTraits::format, typename ConversionTraits::carrier_uint>,
+                class... Policies>
+      GLZ_JKJ_FORCEINLINE GLZ_JKJ_SAFEBUFFERS GLZ_JKJ_CONSTEXPR20
+         detail::to_decimal_return_type<FormatTraits, Policies...>
+         to_decimal(Float x, Policies... policies) noexcept
+      {
+         const auto br = make_float_bits<Float, ConversionTraits, FormatTraits>(x);
+         const auto exponent_bits = br.extract_exponent_bits();
+         const auto s = br.remove_exponent_bits();
+         assert(br.is_finite() && br.is_nonzero());
+
+         return to_decimal_ex(s, exponent_bits, policies...);
+      }
+   }
+}
+
+#undef GLZ_JKJ_HAS_BUILTIN
+#undef GLZ_JKJ_FORCEINLINE
+#undef GLZ_JKJ_SAFEBUFFERS
+#undef GLZ_JKJ_CONSTEXPR20
+#undef GLZ_JKJ_USE_IS_CONSTANT_EVALUATED
+#undef GLZ_JKJ_CAN_BRANCH_ON_CONSTEVAL
+#undef GLZ_JKJ_IF_NOT_CONSTEVAL
+#undef GLZ_JKJ_IF_CONSTEVAL
+#undef GLZ_JKJ_HAS_BIT_CAST
+#undef GLZ_JKJ_IF_CONSTEXPR
+#undef GLZ_JKJ_HAS_IF_CONSTEXPR
+#undef GLZ_JKJ_INLINE_VARIABLE
+#undef GLZ_JKJ_HAS_INLINE_VARIABLE
+#undef GLZ_JKJ_HAS_CONSTEXPR17
+#undef GLZ_JKJ_CONSTEXPR14
+#undef GLZ_JKJ_HAS_CONSTEXPR14
+#if GLZ_JKJ_STD_REPLACEMENT_NAMESPACE_DEFINED
+#undef GLZ_JKJ_STD_REPLACEMENT_NAMESPACE_DEFINED
+#else
+#undef GLZ_JKJ_STD_REPLACEMENT_NAMESPACE
+#endif
+#if GLZ_JKJ_STATIC_DATA_SECTION_DEFINED
+#undef GLZ_JKJ_STATIC_DATA_SECTION_DEFINED
+#else
+#undef GLZ_JKJ_STATIC_DATA_SECTION
+#endif
+
+#endif
diff --git a/deps/saucer/include/glaze/util/dtoa.hpp b/deps/saucer/include/glaze/util/dtoa.hpp
index 7088561..105ce4e 100644
--- a/deps/saucer/include/glaze/util/dtoa.hpp
+++ b/deps/saucer/include/glaze/util/dtoa.hpp
@@ -5,874 +5,37 @@
 #include <cstdint>
 #include <cstring>
 
+#include "glaze/util/dragonbox.hpp"
+#include "glaze/util/inline.hpp"
 #include "glaze/util/itoa.hpp"
 
-#if defined(_M_X64) || defined(_M_ARM64)
-#include <intrin.h>
-#endif
-
 namespace glz
 {
-   // Source: https://github.com/ibireme/yyjson/blob/master/src/yyjson.c
-
-   /** Multiplies two 64-bit unsigned integers (a * b),
-       returns the 128-bit result as 'hi' and 'lo'. */
-   GLZ_ALWAYS_INLINE void u128_mul(uint64_t a, uint64_t b, uint64_t* hi, uint64_t* lo) noexcept
+   // std::countl_zero uses another branch check whether the input is zero,
+   // we use this function when we know that x > 0
+   GLZ_ALWAYS_INLINE constexpr auto countl_zero(const uint32_t x) noexcept
    {
-#ifdef __SIZEOF_INT128__
-#if defined(__GNUC__) || defined(__GNUG__)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wpedantic"
-#endif
-      unsigned __int128 m = static_cast<unsigned __int128>(a) * b;
-#if defined(__GNUC__) || defined(__GNUG__)
-#pragma GCC diagnostic pop
-#endif
-      *hi = uint64_t(m >> 64);
-      *lo = uint64_t(m);
-#elif defined(_M_X64)
-      *lo = _umul128(a, b, hi);
-#elif defined(_M_ARM64)
-      *hi = __umulh(a, b);
-      *lo = a * b;
+#ifdef _MSC_VER
+      return std::countl_zero(x);
 #else
-      uint32_t a0 = (uint32_t)(a), a1 = (uint32_t)(a >> 32);
-      uint32_t b0 = (uint32_t)(b), b1 = (uint32_t)(b >> 32);
-      uint64_t p00 = (uint64_t)a0 * b0, p01 = (uint64_t)a0 * b1;
-      uint64_t p10 = (uint64_t)a1 * b0, p11 = (uint64_t)a1 * b1;
-      uint64_t m0 = p01 + (p00 >> 32);
-      uint32_t m00 = (uint32_t)(m0), m01 = (uint32_t)(m0 >> 32);
-      uint64_t m1 = p10 + m00;
-      uint32_t m10 = (uint32_t)(m1), m11 = (uint32_t)(m1 >> 32);
-      *hi = p11 + m01 + m11;
-      *lo = ((uint64_t)m10 << 32) | (uint32_t)p00;
-#endif
-   }
-
-   /** Multiplies two 64-bit unsigned integers and add a value (a * b + c),
-       returns the 128-bit result as 'hi' and 'lo'. */
-   GLZ_ALWAYS_INLINE void u128_mul_add(uint64_t a, uint64_t b, uint64_t c, uint64_t* hi, uint64_t* lo) noexcept
-   {
-#ifdef __SIZEOF_INT128__
-#if defined(__GNUC__) || defined(__GNUG__)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wpedantic"
-#endif
-      unsigned __int128 m = static_cast<unsigned __int128>(a) * b + c;
-#if defined(__GNUC__) || defined(__GNUG__)
-#pragma GCC diagnostic pop
-#endif
-      *hi = uint64_t(m >> 64);
-      *lo = uint64_t(m);
+#if __has_builtin(__builtin_ctzll)
+      return __builtin_clz(x);
 #else
-      uint64_t h, l, t;
-      u128_mul(a, b, &h, &l);
-      t = l + c;
-      h += ((t < l) | (t < c));
-      *hi = h;
-      *lo = t;
+      return std::countl_zero(x);
+#endif
 #endif
    }
 
-   /** Multiplies 128-bit integer and returns highest 64-bit rounded value. */
-   GLZ_ALWAYS_INLINE uint64_t round_to_odd(uint64_t hi, uint64_t lo, uint64_t cp) noexcept
-   {
-      uint64_t x_hi, x_lo, y_hi, y_lo;
-      u128_mul(cp, lo, &x_hi, &x_lo);
-      u128_mul_add(cp, hi, x_hi, &y_hi, &y_lo);
-      return y_hi | (y_lo > 1);
-   }
-
-   /*==============================================================================
-    * Power10 Lookup Table
-    *============================================================================*/
-
-   /** Minimum decimal exponent in pow10_sig_table. */
-   inline constexpr auto POW10_SIG_TABLE_128_MIN_EXP = -343;
-
-   /** Maximum decimal exponent in pow10_sig_table. */
-   inline constexpr auto POW10_SIG_TABLE_128_MAX_EXP = 324;
-
-   /** Minimum exact decimal exponent in pow10_sig_table */
-   inline constexpr auto POW10_SIG_TABLE_128_MIN_EXACT_EXP = 0;
-
-   /** Maximum exact decimal exponent in pow10_sig_table */
-   inline constexpr auto POW10_SIG_TABLE_128_MAX_EXACT_EXP = 55;
-
-   // TODO: Remove duplicate table (see pow10_sig_table)
-   inline constexpr std::array<uint64_t, 1336> pow10_sig_table_128 = {
-      0xBF29DCABA82FDEAE, 0x7432EE873880FC33, /* ~= 10^-343 */
-      0xEEF453D6923BD65A, 0x113FAA2906A13B3F, /* ~= 10^-342 */
-      0x9558B4661B6565F8, 0x4AC7CA59A424C507, /* ~= 10^-341 */
-      0xBAAEE17FA23EBF76, 0x5D79BCF00D2DF649, /* ~= 10^-340 */
-      0xE95A99DF8ACE6F53, 0xF4D82C2C107973DC, /* ~= 10^-339 */
-      0x91D8A02BB6C10594, 0x79071B9B8A4BE869, /* ~= 10^-338 */
-      0xB64EC836A47146F9, 0x9748E2826CDEE284, /* ~= 10^-337 */
-      0xE3E27A444D8D98B7, 0xFD1B1B2308169B25, /* ~= 10^-336 */
-      0x8E6D8C6AB0787F72, 0xFE30F0F5E50E20F7, /* ~= 10^-335 */
-      0xB208EF855C969F4F, 0xBDBD2D335E51A935, /* ~= 10^-334 */
-      0xDE8B2B66B3BC4723, 0xAD2C788035E61382, /* ~= 10^-333 */
-      0x8B16FB203055AC76, 0x4C3BCB5021AFCC31, /* ~= 10^-332 */
-      0xADDCB9E83C6B1793, 0xDF4ABE242A1BBF3D, /* ~= 10^-331 */
-      0xD953E8624B85DD78, 0xD71D6DAD34A2AF0D, /* ~= 10^-330 */
-      0x87D4713D6F33AA6B, 0x8672648C40E5AD68, /* ~= 10^-329 */
-      0xA9C98D8CCB009506, 0x680EFDAF511F18C2, /* ~= 10^-328 */
-      0xD43BF0EFFDC0BA48, 0x0212BD1B2566DEF2, /* ~= 10^-327 */
-      0x84A57695FE98746D, 0x014BB630F7604B57, /* ~= 10^-326 */
-      0xA5CED43B7E3E9188, 0x419EA3BD35385E2D, /* ~= 10^-325 */
-      0xCF42894A5DCE35EA, 0x52064CAC828675B9, /* ~= 10^-324 */
-      0x818995CE7AA0E1B2, 0x7343EFEBD1940993, /* ~= 10^-323 */
-      0xA1EBFB4219491A1F, 0x1014EBE6C5F90BF8, /* ~= 10^-322 */
-      0xCA66FA129F9B60A6, 0xD41A26E077774EF6, /* ~= 10^-321 */
-      0xFD00B897478238D0, 0x8920B098955522B4, /* ~= 10^-320 */
-      0x9E20735E8CB16382, 0x55B46E5F5D5535B0, /* ~= 10^-319 */
-      0xC5A890362FDDBC62, 0xEB2189F734AA831D, /* ~= 10^-318 */
-      0xF712B443BBD52B7B, 0xA5E9EC7501D523E4, /* ~= 10^-317 */
-      0x9A6BB0AA55653B2D, 0x47B233C92125366E, /* ~= 10^-316 */
-      0xC1069CD4EABE89F8, 0x999EC0BB696E840A, /* ~= 10^-315 */
-      0xF148440A256E2C76, 0xC00670EA43CA250D, /* ~= 10^-314 */
-      0x96CD2A865764DBCA, 0x380406926A5E5728, /* ~= 10^-313 */
-      0xBC807527ED3E12BC, 0xC605083704F5ECF2, /* ~= 10^-312 */
-      0xEBA09271E88D976B, 0xF7864A44C633682E, /* ~= 10^-311 */
-      0x93445B8731587EA3, 0x7AB3EE6AFBE0211D, /* ~= 10^-310 */
-      0xB8157268FDAE9E4C, 0x5960EA05BAD82964, /* ~= 10^-309 */
-      0xE61ACF033D1A45DF, 0x6FB92487298E33BD, /* ~= 10^-308 */
-      0x8FD0C16206306BAB, 0xA5D3B6D479F8E056, /* ~= 10^-307 */
-      0xB3C4F1BA87BC8696, 0x8F48A4899877186C, /* ~= 10^-306 */
-      0xE0B62E2929ABA83C, 0x331ACDABFE94DE87, /* ~= 10^-305 */
-      0x8C71DCD9BA0B4925, 0x9FF0C08B7F1D0B14, /* ~= 10^-304 */
-      0xAF8E5410288E1B6F, 0x07ECF0AE5EE44DD9, /* ~= 10^-303 */
-      0xDB71E91432B1A24A, 0xC9E82CD9F69D6150, /* ~= 10^-302 */
-      0x892731AC9FAF056E, 0xBE311C083A225CD2, /* ~= 10^-301 */
-      0xAB70FE17C79AC6CA, 0x6DBD630A48AAF406, /* ~= 10^-300 */
-      0xD64D3D9DB981787D, 0x092CBBCCDAD5B108, /* ~= 10^-299 */
-      0x85F0468293F0EB4E, 0x25BBF56008C58EA5, /* ~= 10^-298 */
-      0xA76C582338ED2621, 0xAF2AF2B80AF6F24E, /* ~= 10^-297 */
-      0xD1476E2C07286FAA, 0x1AF5AF660DB4AEE1, /* ~= 10^-296 */
-      0x82CCA4DB847945CA, 0x50D98D9FC890ED4D, /* ~= 10^-295 */
-      0xA37FCE126597973C, 0xE50FF107BAB528A0, /* ~= 10^-294 */
-      0xCC5FC196FEFD7D0C, 0x1E53ED49A96272C8, /* ~= 10^-293 */
-      0xFF77B1FCBEBCDC4F, 0x25E8E89C13BB0F7A, /* ~= 10^-292 */
-      0x9FAACF3DF73609B1, 0x77B191618C54E9AC, /* ~= 10^-291 */
-      0xC795830D75038C1D, 0xD59DF5B9EF6A2417, /* ~= 10^-290 */
-      0xF97AE3D0D2446F25, 0x4B0573286B44AD1D, /* ~= 10^-289 */
-      0x9BECCE62836AC577, 0x4EE367F9430AEC32, /* ~= 10^-288 */
-      0xC2E801FB244576D5, 0x229C41F793CDA73F, /* ~= 10^-287 */
-      0xF3A20279ED56D48A, 0x6B43527578C1110F, /* ~= 10^-286 */
-      0x9845418C345644D6, 0x830A13896B78AAA9, /* ~= 10^-285 */
-      0xBE5691EF416BD60C, 0x23CC986BC656D553, /* ~= 10^-284 */
-      0xEDEC366B11C6CB8F, 0x2CBFBE86B7EC8AA8, /* ~= 10^-283 */
-      0x94B3A202EB1C3F39, 0x7BF7D71432F3D6A9, /* ~= 10^-282 */
-      0xB9E08A83A5E34F07, 0xDAF5CCD93FB0CC53, /* ~= 10^-281 */
-      0xE858AD248F5C22C9, 0xD1B3400F8F9CFF68, /* ~= 10^-280 */
-      0x91376C36D99995BE, 0x23100809B9C21FA1, /* ~= 10^-279 */
-      0xB58547448FFFFB2D, 0xABD40A0C2832A78A, /* ~= 10^-278 */
-      0xE2E69915B3FFF9F9, 0x16C90C8F323F516C, /* ~= 10^-277 */
-      0x8DD01FAD907FFC3B, 0xAE3DA7D97F6792E3, /* ~= 10^-276 */
-      0xB1442798F49FFB4A, 0x99CD11CFDF41779C, /* ~= 10^-275 */
-      0xDD95317F31C7FA1D, 0x40405643D711D583, /* ~= 10^-274 */
-      0x8A7D3EEF7F1CFC52, 0x482835EA666B2572, /* ~= 10^-273 */
-      0xAD1C8EAB5EE43B66, 0xDA3243650005EECF, /* ~= 10^-272 */
-      0xD863B256369D4A40, 0x90BED43E40076A82, /* ~= 10^-271 */
-      0x873E4F75E2224E68, 0x5A7744A6E804A291, /* ~= 10^-270 */
-      0xA90DE3535AAAE202, 0x711515D0A205CB36, /* ~= 10^-269 */
-      0xD3515C2831559A83, 0x0D5A5B44CA873E03, /* ~= 10^-268 */
-      0x8412D9991ED58091, 0xE858790AFE9486C2, /* ~= 10^-267 */
-      0xA5178FFF668AE0B6, 0x626E974DBE39A872, /* ~= 10^-266 */
-      0xCE5D73FF402D98E3, 0xFB0A3D212DC8128F, /* ~= 10^-265 */
-      0x80FA687F881C7F8E, 0x7CE66634BC9D0B99, /* ~= 10^-264 */
-      0xA139029F6A239F72, 0x1C1FFFC1EBC44E80, /* ~= 10^-263 */
-      0xC987434744AC874E, 0xA327FFB266B56220, /* ~= 10^-262 */
-      0xFBE9141915D7A922, 0x4BF1FF9F0062BAA8, /* ~= 10^-261 */
-      0x9D71AC8FADA6C9B5, 0x6F773FC3603DB4A9, /* ~= 10^-260 */
-      0xC4CE17B399107C22, 0xCB550FB4384D21D3, /* ~= 10^-259 */
-      0xF6019DA07F549B2B, 0x7E2A53A146606A48, /* ~= 10^-258 */
-      0x99C102844F94E0FB, 0x2EDA7444CBFC426D, /* ~= 10^-257 */
-      0xC0314325637A1939, 0xFA911155FEFB5308, /* ~= 10^-256 */
-      0xF03D93EEBC589F88, 0x793555AB7EBA27CA, /* ~= 10^-255 */
-      0x96267C7535B763B5, 0x4BC1558B2F3458DE, /* ~= 10^-254 */
-      0xBBB01B9283253CA2, 0x9EB1AAEDFB016F16, /* ~= 10^-253 */
-      0xEA9C227723EE8BCB, 0x465E15A979C1CADC, /* ~= 10^-252 */
-      0x92A1958A7675175F, 0x0BFACD89EC191EC9, /* ~= 10^-251 */
-      0xB749FAED14125D36, 0xCEF980EC671F667B, /* ~= 10^-250 */
-      0xE51C79A85916F484, 0x82B7E12780E7401A, /* ~= 10^-249 */
-      0x8F31CC0937AE58D2, 0xD1B2ECB8B0908810, /* ~= 10^-248 */
-      0xB2FE3F0B8599EF07, 0x861FA7E6DCB4AA15, /* ~= 10^-247 */
-      0xDFBDCECE67006AC9, 0x67A791E093E1D49A, /* ~= 10^-246 */
-      0x8BD6A141006042BD, 0xE0C8BB2C5C6D24E0, /* ~= 10^-245 */
-      0xAECC49914078536D, 0x58FAE9F773886E18, /* ~= 10^-244 */
-      0xDA7F5BF590966848, 0xAF39A475506A899E, /* ~= 10^-243 */
-      0x888F99797A5E012D, 0x6D8406C952429603, /* ~= 10^-242 */
-      0xAAB37FD7D8F58178, 0xC8E5087BA6D33B83, /* ~= 10^-241 */
-      0xD5605FCDCF32E1D6, 0xFB1E4A9A90880A64, /* ~= 10^-240 */
-      0x855C3BE0A17FCD26, 0x5CF2EEA09A55067F, /* ~= 10^-239 */
-      0xA6B34AD8C9DFC06F, 0xF42FAA48C0EA481E, /* ~= 10^-238 */
-      0xD0601D8EFC57B08B, 0xF13B94DAF124DA26, /* ~= 10^-237 */
-      0x823C12795DB6CE57, 0x76C53D08D6B70858, /* ~= 10^-236 */
-      0xA2CB1717B52481ED, 0x54768C4B0C64CA6E, /* ~= 10^-235 */
-      0xCB7DDCDDA26DA268, 0xA9942F5DCF7DFD09, /* ~= 10^-234 */
-      0xFE5D54150B090B02, 0xD3F93B35435D7C4C, /* ~= 10^-233 */
-      0x9EFA548D26E5A6E1, 0xC47BC5014A1A6DAF, /* ~= 10^-232 */
-      0xC6B8E9B0709F109A, 0x359AB6419CA1091B, /* ~= 10^-231 */
-      0xF867241C8CC6D4C0, 0xC30163D203C94B62, /* ~= 10^-230 */
-      0x9B407691D7FC44F8, 0x79E0DE63425DCF1D, /* ~= 10^-229 */
-      0xC21094364DFB5636, 0x985915FC12F542E4, /* ~= 10^-228 */
-      0xF294B943E17A2BC4, 0x3E6F5B7B17B2939D, /* ~= 10^-227 */
-      0x979CF3CA6CEC5B5A, 0xA705992CEECF9C42, /* ~= 10^-226 */
-      0xBD8430BD08277231, 0x50C6FF782A838353, /* ~= 10^-225 */
-      0xECE53CEC4A314EBD, 0xA4F8BF5635246428, /* ~= 10^-224 */
-      0x940F4613AE5ED136, 0x871B7795E136BE99, /* ~= 10^-223 */
-      0xB913179899F68584, 0x28E2557B59846E3F, /* ~= 10^-222 */
-      0xE757DD7EC07426E5, 0x331AEADA2FE589CF, /* ~= 10^-221 */
-      0x9096EA6F3848984F, 0x3FF0D2C85DEF7621, /* ~= 10^-220 */
-      0xB4BCA50B065ABE63, 0x0FED077A756B53A9, /* ~= 10^-219 */
-      0xE1EBCE4DC7F16DFB, 0xD3E8495912C62894, /* ~= 10^-218 */
-      0x8D3360F09CF6E4BD, 0x64712DD7ABBBD95C, /* ~= 10^-217 */
-      0xB080392CC4349DEC, 0xBD8D794D96AACFB3, /* ~= 10^-216 */
-      0xDCA04777F541C567, 0xECF0D7A0FC5583A0, /* ~= 10^-215 */
-      0x89E42CAAF9491B60, 0xF41686C49DB57244, /* ~= 10^-214 */
-      0xAC5D37D5B79B6239, 0x311C2875C522CED5, /* ~= 10^-213 */
-      0xD77485CB25823AC7, 0x7D633293366B828B, /* ~= 10^-212 */
-      0x86A8D39EF77164BC, 0xAE5DFF9C02033197, /* ~= 10^-211 */
-      0xA8530886B54DBDEB, 0xD9F57F830283FDFC, /* ~= 10^-210 */
-      0xD267CAA862A12D66, 0xD072DF63C324FD7B, /* ~= 10^-209 */
-      0x8380DEA93DA4BC60, 0x4247CB9E59F71E6D, /* ~= 10^-208 */
-      0xA46116538D0DEB78, 0x52D9BE85F074E608, /* ~= 10^-207 */
-      0xCD795BE870516656, 0x67902E276C921F8B, /* ~= 10^-206 */
-      0x806BD9714632DFF6, 0x00BA1CD8A3DB53B6, /* ~= 10^-205 */
-      0xA086CFCD97BF97F3, 0x80E8A40ECCD228A4, /* ~= 10^-204 */
-      0xC8A883C0FDAF7DF0, 0x6122CD128006B2CD, /* ~= 10^-203 */
-      0xFAD2A4B13D1B5D6C, 0x796B805720085F81, /* ~= 10^-202 */
-      0x9CC3A6EEC6311A63, 0xCBE3303674053BB0, /* ~= 10^-201 */
-      0xC3F490AA77BD60FC, 0xBEDBFC4411068A9C, /* ~= 10^-200 */
-      0xF4F1B4D515ACB93B, 0xEE92FB5515482D44, /* ~= 10^-199 */
-      0x991711052D8BF3C5, 0x751BDD152D4D1C4A, /* ~= 10^-198 */
-      0xBF5CD54678EEF0B6, 0xD262D45A78A0635D, /* ~= 10^-197 */
-      0xEF340A98172AACE4, 0x86FB897116C87C34, /* ~= 10^-196 */
-      0x9580869F0E7AAC0E, 0xD45D35E6AE3D4DA0, /* ~= 10^-195 */
-      0xBAE0A846D2195712, 0x8974836059CCA109, /* ~= 10^-194 */
-      0xE998D258869FACD7, 0x2BD1A438703FC94B, /* ~= 10^-193 */
-      0x91FF83775423CC06, 0x7B6306A34627DDCF, /* ~= 10^-192 */
-      0xB67F6455292CBF08, 0x1A3BC84C17B1D542, /* ~= 10^-191 */
-      0xE41F3D6A7377EECA, 0x20CABA5F1D9E4A93, /* ~= 10^-190 */
-      0x8E938662882AF53E, 0x547EB47B7282EE9C, /* ~= 10^-189 */
-      0xB23867FB2A35B28D, 0xE99E619A4F23AA43, /* ~= 10^-188 */
-      0xDEC681F9F4C31F31, 0x6405FA00E2EC94D4, /* ~= 10^-187 */
-      0x8B3C113C38F9F37E, 0xDE83BC408DD3DD04, /* ~= 10^-186 */
-      0xAE0B158B4738705E, 0x9624AB50B148D445, /* ~= 10^-185 */
-      0xD98DDAEE19068C76, 0x3BADD624DD9B0957, /* ~= 10^-184 */
-      0x87F8A8D4CFA417C9, 0xE54CA5D70A80E5D6, /* ~= 10^-183 */
-      0xA9F6D30A038D1DBC, 0x5E9FCF4CCD211F4C, /* ~= 10^-182 */
-      0xD47487CC8470652B, 0x7647C3200069671F, /* ~= 10^-181 */
-      0x84C8D4DFD2C63F3B, 0x29ECD9F40041E073, /* ~= 10^-180 */
-      0xA5FB0A17C777CF09, 0xF468107100525890, /* ~= 10^-179 */
-      0xCF79CC9DB955C2CC, 0x7182148D4066EEB4, /* ~= 10^-178 */
-      0x81AC1FE293D599BF, 0xC6F14CD848405530, /* ~= 10^-177 */
-      0xA21727DB38CB002F, 0xB8ADA00E5A506A7C, /* ~= 10^-176 */
-      0xCA9CF1D206FDC03B, 0xA6D90811F0E4851C, /* ~= 10^-175 */
-      0xFD442E4688BD304A, 0x908F4A166D1DA663, /* ~= 10^-174 */
-      0x9E4A9CEC15763E2E, 0x9A598E4E043287FE, /* ~= 10^-173 */
-      0xC5DD44271AD3CDBA, 0x40EFF1E1853F29FD, /* ~= 10^-172 */
-      0xF7549530E188C128, 0xD12BEE59E68EF47C, /* ~= 10^-171 */
-      0x9A94DD3E8CF578B9, 0x82BB74F8301958CE, /* ~= 10^-170 */
-      0xC13A148E3032D6E7, 0xE36A52363C1FAF01, /* ~= 10^-169 */
-      0xF18899B1BC3F8CA1, 0xDC44E6C3CB279AC1, /* ~= 10^-168 */
-      0x96F5600F15A7B7E5, 0x29AB103A5EF8C0B9, /* ~= 10^-167 */
-      0xBCB2B812DB11A5DE, 0x7415D448F6B6F0E7, /* ~= 10^-166 */
-      0xEBDF661791D60F56, 0x111B495B3464AD21, /* ~= 10^-165 */
-      0x936B9FCEBB25C995, 0xCAB10DD900BEEC34, /* ~= 10^-164 */
-      0xB84687C269EF3BFB, 0x3D5D514F40EEA742, /* ~= 10^-163 */
-      0xE65829B3046B0AFA, 0x0CB4A5A3112A5112, /* ~= 10^-162 */
-      0x8FF71A0FE2C2E6DC, 0x47F0E785EABA72AB, /* ~= 10^-161 */
-      0xB3F4E093DB73A093, 0x59ED216765690F56, /* ~= 10^-160 */
-      0xE0F218B8D25088B8, 0x306869C13EC3532C, /* ~= 10^-159 */
-      0x8C974F7383725573, 0x1E414218C73A13FB, /* ~= 10^-158 */
-      0xAFBD2350644EEACF, 0xE5D1929EF90898FA, /* ~= 10^-157 */
-      0xDBAC6C247D62A583, 0xDF45F746B74ABF39, /* ~= 10^-156 */
-      0x894BC396CE5DA772, 0x6B8BBA8C328EB783, /* ~= 10^-155 */
-      0xAB9EB47C81F5114F, 0x066EA92F3F326564, /* ~= 10^-154 */
-      0xD686619BA27255A2, 0xC80A537B0EFEFEBD, /* ~= 10^-153 */
-      0x8613FD0145877585, 0xBD06742CE95F5F36, /* ~= 10^-152 */
-      0xA798FC4196E952E7, 0x2C48113823B73704, /* ~= 10^-151 */
-      0xD17F3B51FCA3A7A0, 0xF75A15862CA504C5, /* ~= 10^-150 */
-      0x82EF85133DE648C4, 0x9A984D73DBE722FB, /* ~= 10^-149 */
-      0xA3AB66580D5FDAF5, 0xC13E60D0D2E0EBBA, /* ~= 10^-148 */
-      0xCC963FEE10B7D1B3, 0x318DF905079926A8, /* ~= 10^-147 */
-      0xFFBBCFE994E5C61F, 0xFDF17746497F7052, /* ~= 10^-146 */
-      0x9FD561F1FD0F9BD3, 0xFEB6EA8BEDEFA633, /* ~= 10^-145 */
-      0xC7CABA6E7C5382C8, 0xFE64A52EE96B8FC0, /* ~= 10^-144 */
-      0xF9BD690A1B68637B, 0x3DFDCE7AA3C673B0, /* ~= 10^-143 */
-      0x9C1661A651213E2D, 0x06BEA10CA65C084E, /* ~= 10^-142 */
-      0xC31BFA0FE5698DB8, 0x486E494FCFF30A62, /* ~= 10^-141 */
-      0xF3E2F893DEC3F126, 0x5A89DBA3C3EFCCFA, /* ~= 10^-140 */
-      0x986DDB5C6B3A76B7, 0xF89629465A75E01C, /* ~= 10^-139 */
-      0xBE89523386091465, 0xF6BBB397F1135823, /* ~= 10^-138 */
-      0xEE2BA6C0678B597F, 0x746AA07DED582E2C, /* ~= 10^-137 */
-      0x94DB483840B717EF, 0xA8C2A44EB4571CDC, /* ~= 10^-136 */
-      0xBA121A4650E4DDEB, 0x92F34D62616CE413, /* ~= 10^-135 */
-      0xE896A0D7E51E1566, 0x77B020BAF9C81D17, /* ~= 10^-134 */
-      0x915E2486EF32CD60, 0x0ACE1474DC1D122E, /* ~= 10^-133 */
-      0xB5B5ADA8AAFF80B8, 0x0D819992132456BA, /* ~= 10^-132 */
-      0xE3231912D5BF60E6, 0x10E1FFF697ED6C69, /* ~= 10^-131 */
-      0x8DF5EFABC5979C8F, 0xCA8D3FFA1EF463C1, /* ~= 10^-130 */
-      0xB1736B96B6FD83B3, 0xBD308FF8A6B17CB2, /* ~= 10^-129 */
-      0xDDD0467C64BCE4A0, 0xAC7CB3F6D05DDBDE, /* ~= 10^-128 */
-      0x8AA22C0DBEF60EE4, 0x6BCDF07A423AA96B, /* ~= 10^-127 */
-      0xAD4AB7112EB3929D, 0x86C16C98D2C953C6, /* ~= 10^-126 */
-      0xD89D64D57A607744, 0xE871C7BF077BA8B7, /* ~= 10^-125 */
-      0x87625F056C7C4A8B, 0x11471CD764AD4972, /* ~= 10^-124 */
-      0xA93AF6C6C79B5D2D, 0xD598E40D3DD89BCF, /* ~= 10^-123 */
-      0xD389B47879823479, 0x4AFF1D108D4EC2C3, /* ~= 10^-122 */
-      0x843610CB4BF160CB, 0xCEDF722A585139BA, /* ~= 10^-121 */
-      0xA54394FE1EEDB8FE, 0xC2974EB4EE658828, /* ~= 10^-120 */
-      0xCE947A3DA6A9273E, 0x733D226229FEEA32, /* ~= 10^-119 */
-      0x811CCC668829B887, 0x0806357D5A3F525F, /* ~= 10^-118 */
-      0xA163FF802A3426A8, 0xCA07C2DCB0CF26F7, /* ~= 10^-117 */
-      0xC9BCFF6034C13052, 0xFC89B393DD02F0B5, /* ~= 10^-116 */
-      0xFC2C3F3841F17C67, 0xBBAC2078D443ACE2, /* ~= 10^-115 */
-      0x9D9BA7832936EDC0, 0xD54B944B84AA4C0D, /* ~= 10^-114 */
-      0xC5029163F384A931, 0x0A9E795E65D4DF11, /* ~= 10^-113 */
-      0xF64335BCF065D37D, 0x4D4617B5FF4A16D5, /* ~= 10^-112 */
-      0x99EA0196163FA42E, 0x504BCED1BF8E4E45, /* ~= 10^-111 */
-      0xC06481FB9BCF8D39, 0xE45EC2862F71E1D6, /* ~= 10^-110 */
-      0xF07DA27A82C37088, 0x5D767327BB4E5A4C, /* ~= 10^-109 */
-      0x964E858C91BA2655, 0x3A6A07F8D510F86F, /* ~= 10^-108 */
-      0xBBE226EFB628AFEA, 0x890489F70A55368B, /* ~= 10^-107 */
-      0xEADAB0ABA3B2DBE5, 0x2B45AC74CCEA842E, /* ~= 10^-106 */
-      0x92C8AE6B464FC96F, 0x3B0B8BC90012929D, /* ~= 10^-105 */
-      0xB77ADA0617E3BBCB, 0x09CE6EBB40173744, /* ~= 10^-104 */
-      0xE55990879DDCAABD, 0xCC420A6A101D0515, /* ~= 10^-103 */
-      0x8F57FA54C2A9EAB6, 0x9FA946824A12232D, /* ~= 10^-102 */
-      0xB32DF8E9F3546564, 0x47939822DC96ABF9, /* ~= 10^-101 */
-      0xDFF9772470297EBD, 0x59787E2B93BC56F7, /* ~= 10^-100 */
-      0x8BFBEA76C619EF36, 0x57EB4EDB3C55B65A, /* ~= 10^-99 */
-      0xAEFAE51477A06B03, 0xEDE622920B6B23F1, /* ~= 10^-98 */
-      0xDAB99E59958885C4, 0xE95FAB368E45ECED, /* ~= 10^-97 */
-      0x88B402F7FD75539B, 0x11DBCB0218EBB414, /* ~= 10^-96 */
-      0xAAE103B5FCD2A881, 0xD652BDC29F26A119, /* ~= 10^-95 */
-      0xD59944A37C0752A2, 0x4BE76D3346F0495F, /* ~= 10^-94 */
-      0x857FCAE62D8493A5, 0x6F70A4400C562DDB, /* ~= 10^-93 */
-      0xA6DFBD9FB8E5B88E, 0xCB4CCD500F6BB952, /* ~= 10^-92 */
-      0xD097AD07A71F26B2, 0x7E2000A41346A7A7, /* ~= 10^-91 */
-      0x825ECC24C873782F, 0x8ED400668C0C28C8, /* ~= 10^-90 */
-      0xA2F67F2DFA90563B, 0x728900802F0F32FA, /* ~= 10^-89 */
-      0xCBB41EF979346BCA, 0x4F2B40A03AD2FFB9, /* ~= 10^-88 */
-      0xFEA126B7D78186BC, 0xE2F610C84987BFA8, /* ~= 10^-87 */
-      0x9F24B832E6B0F436, 0x0DD9CA7D2DF4D7C9, /* ~= 10^-86 */
-      0xC6EDE63FA05D3143, 0x91503D1C79720DBB, /* ~= 10^-85 */
-      0xF8A95FCF88747D94, 0x75A44C6397CE912A, /* ~= 10^-84 */
-      0x9B69DBE1B548CE7C, 0xC986AFBE3EE11ABA, /* ~= 10^-83 */
-      0xC24452DA229B021B, 0xFBE85BADCE996168, /* ~= 10^-82 */
-      0xF2D56790AB41C2A2, 0xFAE27299423FB9C3, /* ~= 10^-81 */
-      0x97C560BA6B0919A5, 0xDCCD879FC967D41A, /* ~= 10^-80 */
-      0xBDB6B8E905CB600F, 0x5400E987BBC1C920, /* ~= 10^-79 */
-      0xED246723473E3813, 0x290123E9AAB23B68, /* ~= 10^-78 */
-      0x9436C0760C86E30B, 0xF9A0B6720AAF6521, /* ~= 10^-77 */
-      0xB94470938FA89BCE, 0xF808E40E8D5B3E69, /* ~= 10^-76 */
-      0xE7958CB87392C2C2, 0xB60B1D1230B20E04, /* ~= 10^-75 */
-      0x90BD77F3483BB9B9, 0xB1C6F22B5E6F48C2, /* ~= 10^-74 */
-      0xB4ECD5F01A4AA828, 0x1E38AEB6360B1AF3, /* ~= 10^-73 */
-      0xE2280B6C20DD5232, 0x25C6DA63C38DE1B0, /* ~= 10^-72 */
-      0x8D590723948A535F, 0x579C487E5A38AD0E, /* ~= 10^-71 */
-      0xB0AF48EC79ACE837, 0x2D835A9DF0C6D851, /* ~= 10^-70 */
-      0xDCDB1B2798182244, 0xF8E431456CF88E65, /* ~= 10^-69 */
-      0x8A08F0F8BF0F156B, 0x1B8E9ECB641B58FF, /* ~= 10^-68 */
-      0xAC8B2D36EED2DAC5, 0xE272467E3D222F3F, /* ~= 10^-67 */
-      0xD7ADF884AA879177, 0x5B0ED81DCC6ABB0F, /* ~= 10^-66 */
-      0x86CCBB52EA94BAEA, 0x98E947129FC2B4E9, /* ~= 10^-65 */
-      0xA87FEA27A539E9A5, 0x3F2398D747B36224, /* ~= 10^-64 */
-      0xD29FE4B18E88640E, 0x8EEC7F0D19A03AAD, /* ~= 10^-63 */
-      0x83A3EEEEF9153E89, 0x1953CF68300424AC, /* ~= 10^-62 */
-      0xA48CEAAAB75A8E2B, 0x5FA8C3423C052DD7, /* ~= 10^-61 */
-      0xCDB02555653131B6, 0x3792F412CB06794D, /* ~= 10^-60 */
-      0x808E17555F3EBF11, 0xE2BBD88BBEE40BD0, /* ~= 10^-59 */
-      0xA0B19D2AB70E6ED6, 0x5B6ACEAEAE9D0EC4, /* ~= 10^-58 */
-      0xC8DE047564D20A8B, 0xF245825A5A445275, /* ~= 10^-57 */
-      0xFB158592BE068D2E, 0xEED6E2F0F0D56712, /* ~= 10^-56 */
-      0x9CED737BB6C4183D, 0x55464DD69685606B, /* ~= 10^-55 */
-      0xC428D05AA4751E4C, 0xAA97E14C3C26B886, /* ~= 10^-54 */
-      0xF53304714D9265DF, 0xD53DD99F4B3066A8, /* ~= 10^-53 */
-      0x993FE2C6D07B7FAB, 0xE546A8038EFE4029, /* ~= 10^-52 */
-      0xBF8FDB78849A5F96, 0xDE98520472BDD033, /* ~= 10^-51 */
-      0xEF73D256A5C0F77C, 0x963E66858F6D4440, /* ~= 10^-50 */
-      0x95A8637627989AAD, 0xDDE7001379A44AA8, /* ~= 10^-49 */
-      0xBB127C53B17EC159, 0x5560C018580D5D52, /* ~= 10^-48 */
-      0xE9D71B689DDE71AF, 0xAAB8F01E6E10B4A6, /* ~= 10^-47 */
-      0x9226712162AB070D, 0xCAB3961304CA70E8, /* ~= 10^-46 */
-      0xB6B00D69BB55C8D1, 0x3D607B97C5FD0D22, /* ~= 10^-45 */
-      0xE45C10C42A2B3B05, 0x8CB89A7DB77C506A, /* ~= 10^-44 */
-      0x8EB98A7A9A5B04E3, 0x77F3608E92ADB242, /* ~= 10^-43 */
-      0xB267ED1940F1C61C, 0x55F038B237591ED3, /* ~= 10^-42 */
-      0xDF01E85F912E37A3, 0x6B6C46DEC52F6688, /* ~= 10^-41 */
-      0x8B61313BBABCE2C6, 0x2323AC4B3B3DA015, /* ~= 10^-40 */
-      0xAE397D8AA96C1B77, 0xABEC975E0A0D081A, /* ~= 10^-39 */
-      0xD9C7DCED53C72255, 0x96E7BD358C904A21, /* ~= 10^-38 */
-      0x881CEA14545C7575, 0x7E50D64177DA2E54, /* ~= 10^-37 */
-      0xAA242499697392D2, 0xDDE50BD1D5D0B9E9, /* ~= 10^-36 */
-      0xD4AD2DBFC3D07787, 0x955E4EC64B44E864, /* ~= 10^-35 */
-      0x84EC3C97DA624AB4, 0xBD5AF13BEF0B113E, /* ~= 10^-34 */
-      0xA6274BBDD0FADD61, 0xECB1AD8AEACDD58E, /* ~= 10^-33 */
-      0xCFB11EAD453994BA, 0x67DE18EDA5814AF2, /* ~= 10^-32 */
-      0x81CEB32C4B43FCF4, 0x80EACF948770CED7, /* ~= 10^-31 */
-      0xA2425FF75E14FC31, 0xA1258379A94D028D, /* ~= 10^-30 */
-      0xCAD2F7F5359A3B3E, 0x096EE45813A04330, /* ~= 10^-29 */
-      0xFD87B5F28300CA0D, 0x8BCA9D6E188853FC, /* ~= 10^-28 */
-      0x9E74D1B791E07E48, 0x775EA264CF55347D, /* ~= 10^-27 */
-      0xC612062576589DDA, 0x95364AFE032A819D, /* ~= 10^-26 */
-      0xF79687AED3EEC551, 0x3A83DDBD83F52204, /* ~= 10^-25 */
-      0x9ABE14CD44753B52, 0xC4926A9672793542, /* ~= 10^-24 */
-      0xC16D9A0095928A27, 0x75B7053C0F178293, /* ~= 10^-23 */
-      0xF1C90080BAF72CB1, 0x5324C68B12DD6338, /* ~= 10^-22 */
-      0x971DA05074DA7BEE, 0xD3F6FC16EBCA5E03, /* ~= 10^-21 */
-      0xBCE5086492111AEA, 0x88F4BB1CA6BCF584, /* ~= 10^-20 */
-      0xEC1E4A7DB69561A5, 0x2B31E9E3D06C32E5, /* ~= 10^-19 */
-      0x9392EE8E921D5D07, 0x3AFF322E62439FCF, /* ~= 10^-18 */
-      0xB877AA3236A4B449, 0x09BEFEB9FAD487C2, /* ~= 10^-17 */
-      0xE69594BEC44DE15B, 0x4C2EBE687989A9B3, /* ~= 10^-16 */
-      0x901D7CF73AB0ACD9, 0x0F9D37014BF60A10, /* ~= 10^-15 */
-      0xB424DC35095CD80F, 0x538484C19EF38C94, /* ~= 10^-14 */
-      0xE12E13424BB40E13, 0x2865A5F206B06FB9, /* ~= 10^-13 */
-      0x8CBCCC096F5088CB, 0xF93F87B7442E45D3, /* ~= 10^-12 */
-      0xAFEBFF0BCB24AAFE, 0xF78F69A51539D748, /* ~= 10^-11 */
-      0xDBE6FECEBDEDD5BE, 0xB573440E5A884D1B, /* ~= 10^-10 */
-      0x89705F4136B4A597, 0x31680A88F8953030, /* ~= 10^-9 */
-      0xABCC77118461CEFC, 0xFDC20D2B36BA7C3D, /* ~= 10^-8 */
-      0xD6BF94D5E57A42BC, 0x3D32907604691B4C, /* ~= 10^-7 */
-      0x8637BD05AF6C69B5, 0xA63F9A49C2C1B10F, /* ~= 10^-6 */
-      0xA7C5AC471B478423, 0x0FCF80DC33721D53, /* ~= 10^-5 */
-      0xD1B71758E219652B, 0xD3C36113404EA4A8, /* ~= 10^-4 */
-      0x83126E978D4FDF3B, 0x645A1CAC083126E9, /* ~= 10^-3 */
-      0xA3D70A3D70A3D70A, 0x3D70A3D70A3D70A3, /* ~= 10^-2 */
-      0xCCCCCCCCCCCCCCCC, 0xCCCCCCCCCCCCCCCC, /* ~= 10^-1 */
-      0x8000000000000000, 0x0000000000000000, /* == 10^0 */
-      0xA000000000000000, 0x0000000000000000, /* == 10^1 */
-      0xC800000000000000, 0x0000000000000000, /* == 10^2 */
-      0xFA00000000000000, 0x0000000000000000, /* == 10^3 */
-      0x9C40000000000000, 0x0000000000000000, /* == 10^4 */
-      0xC350000000000000, 0x0000000000000000, /* == 10^5 */
-      0xF424000000000000, 0x0000000000000000, /* == 10^6 */
-      0x9896800000000000, 0x0000000000000000, /* == 10^7 */
-      0xBEBC200000000000, 0x0000000000000000, /* == 10^8 */
-      0xEE6B280000000000, 0x0000000000000000, /* == 10^9 */
-      0x9502F90000000000, 0x0000000000000000, /* == 10^10 */
-      0xBA43B74000000000, 0x0000000000000000, /* == 10^11 */
-      0xE8D4A51000000000, 0x0000000000000000, /* == 10^12 */
-      0x9184E72A00000000, 0x0000000000000000, /* == 10^13 */
-      0xB5E620F480000000, 0x0000000000000000, /* == 10^14 */
-      0xE35FA931A0000000, 0x0000000000000000, /* == 10^15 */
-      0x8E1BC9BF04000000, 0x0000000000000000, /* == 10^16 */
-      0xB1A2BC2EC5000000, 0x0000000000000000, /* == 10^17 */
-      0xDE0B6B3A76400000, 0x0000000000000000, /* == 10^18 */
-      0x8AC7230489E80000, 0x0000000000000000, /* == 10^19 */
-      0xAD78EBC5AC620000, 0x0000000000000000, /* == 10^20 */
-      0xD8D726B7177A8000, 0x0000000000000000, /* == 10^21 */
-      0x878678326EAC9000, 0x0000000000000000, /* == 10^22 */
-      0xA968163F0A57B400, 0x0000000000000000, /* == 10^23 */
-      0xD3C21BCECCEDA100, 0x0000000000000000, /* == 10^24 */
-      0x84595161401484A0, 0x0000000000000000, /* == 10^25 */
-      0xA56FA5B99019A5C8, 0x0000000000000000, /* == 10^26 */
-      0xCECB8F27F4200F3A, 0x0000000000000000, /* == 10^27 */
-      0x813F3978F8940984, 0x4000000000000000, /* == 10^28 */
-      0xA18F07D736B90BE5, 0x5000000000000000, /* == 10^29 */
-      0xC9F2C9CD04674EDE, 0xA400000000000000, /* == 10^30 */
-      0xFC6F7C4045812296, 0x4D00000000000000, /* == 10^31 */
-      0x9DC5ADA82B70B59D, 0xF020000000000000, /* == 10^32 */
-      0xC5371912364CE305, 0x6C28000000000000, /* == 10^33 */
-      0xF684DF56C3E01BC6, 0xC732000000000000, /* == 10^34 */
-      0x9A130B963A6C115C, 0x3C7F400000000000, /* == 10^35 */
-      0xC097CE7BC90715B3, 0x4B9F100000000000, /* == 10^36 */
-      0xF0BDC21ABB48DB20, 0x1E86D40000000000, /* == 10^37 */
-      0x96769950B50D88F4, 0x1314448000000000, /* == 10^38 */
-      0xBC143FA4E250EB31, 0x17D955A000000000, /* == 10^39 */
-      0xEB194F8E1AE525FD, 0x5DCFAB0800000000, /* == 10^40 */
-      0x92EFD1B8D0CF37BE, 0x5AA1CAE500000000, /* == 10^41 */
-      0xB7ABC627050305AD, 0xF14A3D9E40000000, /* == 10^42 */
-      0xE596B7B0C643C719, 0x6D9CCD05D0000000, /* == 10^43 */
-      0x8F7E32CE7BEA5C6F, 0xE4820023A2000000, /* == 10^44 */
-      0xB35DBF821AE4F38B, 0xDDA2802C8A800000, /* == 10^45 */
-      0xE0352F62A19E306E, 0xD50B2037AD200000, /* == 10^46 */
-      0x8C213D9DA502DE45, 0x4526F422CC340000, /* == 10^47 */
-      0xAF298D050E4395D6, 0x9670B12B7F410000, /* == 10^48 */
-      0xDAF3F04651D47B4C, 0x3C0CDD765F114000, /* == 10^49 */
-      0x88D8762BF324CD0F, 0xA5880A69FB6AC800, /* == 10^50 */
-      0xAB0E93B6EFEE0053, 0x8EEA0D047A457A00, /* == 10^51 */
-      0xD5D238A4ABE98068, 0x72A4904598D6D880, /* == 10^52 */
-      0x85A36366EB71F041, 0x47A6DA2B7F864750, /* == 10^53 */
-      0xA70C3C40A64E6C51, 0x999090B65F67D924, /* == 10^54 */
-      0xD0CF4B50CFE20765, 0xFFF4B4E3F741CF6D, /* == 10^55 */
-      0x82818F1281ED449F, 0xBFF8F10E7A8921A4, /* ~= 10^56 */
-      0xA321F2D7226895C7, 0xAFF72D52192B6A0D, /* ~= 10^57 */
-      0xCBEA6F8CEB02BB39, 0x9BF4F8A69F764490, /* ~= 10^58 */
-      0xFEE50B7025C36A08, 0x02F236D04753D5B4, /* ~= 10^59 */
-      0x9F4F2726179A2245, 0x01D762422C946590, /* ~= 10^60 */
-      0xC722F0EF9D80AAD6, 0x424D3AD2B7B97EF5, /* ~= 10^61 */
-      0xF8EBAD2B84E0D58B, 0xD2E0898765A7DEB2, /* ~= 10^62 */
-      0x9B934C3B330C8577, 0x63CC55F49F88EB2F, /* ~= 10^63 */
-      0xC2781F49FFCFA6D5, 0x3CBF6B71C76B25FB, /* ~= 10^64 */
-      0xF316271C7FC3908A, 0x8BEF464E3945EF7A, /* ~= 10^65 */
-      0x97EDD871CFDA3A56, 0x97758BF0E3CBB5AC, /* ~= 10^66 */
-      0xBDE94E8E43D0C8EC, 0x3D52EEED1CBEA317, /* ~= 10^67 */
-      0xED63A231D4C4FB27, 0x4CA7AAA863EE4BDD, /* ~= 10^68 */
-      0x945E455F24FB1CF8, 0x8FE8CAA93E74EF6A, /* ~= 10^69 */
-      0xB975D6B6EE39E436, 0xB3E2FD538E122B44, /* ~= 10^70 */
-      0xE7D34C64A9C85D44, 0x60DBBCA87196B616, /* ~= 10^71 */
-      0x90E40FBEEA1D3A4A, 0xBC8955E946FE31CD, /* ~= 10^72 */
-      0xB51D13AEA4A488DD, 0x6BABAB6398BDBE41, /* ~= 10^73 */
-      0xE264589A4DCDAB14, 0xC696963C7EED2DD1, /* ~= 10^74 */
-      0x8D7EB76070A08AEC, 0xFC1E1DE5CF543CA2, /* ~= 10^75 */
-      0xB0DE65388CC8ADA8, 0x3B25A55F43294BCB, /* ~= 10^76 */
-      0xDD15FE86AFFAD912, 0x49EF0EB713F39EBE, /* ~= 10^77 */
-      0x8A2DBF142DFCC7AB, 0x6E3569326C784337, /* ~= 10^78 */
-      0xACB92ED9397BF996, 0x49C2C37F07965404, /* ~= 10^79 */
-      0xD7E77A8F87DAF7FB, 0xDC33745EC97BE906, /* ~= 10^80 */
-      0x86F0AC99B4E8DAFD, 0x69A028BB3DED71A3, /* ~= 10^81 */
-      0xA8ACD7C0222311BC, 0xC40832EA0D68CE0C, /* ~= 10^82 */
-      0xD2D80DB02AABD62B, 0xF50A3FA490C30190, /* ~= 10^83 */
-      0x83C7088E1AAB65DB, 0x792667C6DA79E0FA, /* ~= 10^84 */
-      0xA4B8CAB1A1563F52, 0x577001B891185938, /* ~= 10^85 */
-      0xCDE6FD5E09ABCF26, 0xED4C0226B55E6F86, /* ~= 10^86 */
-      0x80B05E5AC60B6178, 0x544F8158315B05B4, /* ~= 10^87 */
-      0xA0DC75F1778E39D6, 0x696361AE3DB1C721, /* ~= 10^88 */
-      0xC913936DD571C84C, 0x03BC3A19CD1E38E9, /* ~= 10^89 */
-      0xFB5878494ACE3A5F, 0x04AB48A04065C723, /* ~= 10^90 */
-      0x9D174B2DCEC0E47B, 0x62EB0D64283F9C76, /* ~= 10^91 */
-      0xC45D1DF942711D9A, 0x3BA5D0BD324F8394, /* ~= 10^92 */
-      0xF5746577930D6500, 0xCA8F44EC7EE36479, /* ~= 10^93 */
-      0x9968BF6ABBE85F20, 0x7E998B13CF4E1ECB, /* ~= 10^94 */
-      0xBFC2EF456AE276E8, 0x9E3FEDD8C321A67E, /* ~= 10^95 */
-      0xEFB3AB16C59B14A2, 0xC5CFE94EF3EA101E, /* ~= 10^96 */
-      0x95D04AEE3B80ECE5, 0xBBA1F1D158724A12, /* ~= 10^97 */
-      0xBB445DA9CA61281F, 0x2A8A6E45AE8EDC97, /* ~= 10^98 */
-      0xEA1575143CF97226, 0xF52D09D71A3293BD, /* ~= 10^99 */
-      0x924D692CA61BE758, 0x593C2626705F9C56, /* ~= 10^100 */
-      0xB6E0C377CFA2E12E, 0x6F8B2FB00C77836C, /* ~= 10^101 */
-      0xE498F455C38B997A, 0x0B6DFB9C0F956447, /* ~= 10^102 */
-      0x8EDF98B59A373FEC, 0x4724BD4189BD5EAC, /* ~= 10^103 */
-      0xB2977EE300C50FE7, 0x58EDEC91EC2CB657, /* ~= 10^104 */
-      0xDF3D5E9BC0F653E1, 0x2F2967B66737E3ED, /* ~= 10^105 */
-      0x8B865B215899F46C, 0xBD79E0D20082EE74, /* ~= 10^106 */
-      0xAE67F1E9AEC07187, 0xECD8590680A3AA11, /* ~= 10^107 */
-      0xDA01EE641A708DE9, 0xE80E6F4820CC9495, /* ~= 10^108 */
-      0x884134FE908658B2, 0x3109058D147FDCDD, /* ~= 10^109 */
-      0xAA51823E34A7EEDE, 0xBD4B46F0599FD415, /* ~= 10^110 */
-      0xD4E5E2CDC1D1EA96, 0x6C9E18AC7007C91A, /* ~= 10^111 */
-      0x850FADC09923329E, 0x03E2CF6BC604DDB0, /* ~= 10^112 */
-      0xA6539930BF6BFF45, 0x84DB8346B786151C, /* ~= 10^113 */
-      0xCFE87F7CEF46FF16, 0xE612641865679A63, /* ~= 10^114 */
-      0x81F14FAE158C5F6E, 0x4FCB7E8F3F60C07E, /* ~= 10^115 */
-      0xA26DA3999AEF7749, 0xE3BE5E330F38F09D, /* ~= 10^116 */
-      0xCB090C8001AB551C, 0x5CADF5BFD3072CC5, /* ~= 10^117 */
-      0xFDCB4FA002162A63, 0x73D9732FC7C8F7F6, /* ~= 10^118 */
-      0x9E9F11C4014DDA7E, 0x2867E7FDDCDD9AFA, /* ~= 10^119 */
-      0xC646D63501A1511D, 0xB281E1FD541501B8, /* ~= 10^120 */
-      0xF7D88BC24209A565, 0x1F225A7CA91A4226, /* ~= 10^121 */
-      0x9AE757596946075F, 0x3375788DE9B06958, /* ~= 10^122 */
-      0xC1A12D2FC3978937, 0x0052D6B1641C83AE, /* ~= 10^123 */
-      0xF209787BB47D6B84, 0xC0678C5DBD23A49A, /* ~= 10^124 */
-      0x9745EB4D50CE6332, 0xF840B7BA963646E0, /* ~= 10^125 */
-      0xBD176620A501FBFF, 0xB650E5A93BC3D898, /* ~= 10^126 */
-      0xEC5D3FA8CE427AFF, 0xA3E51F138AB4CEBE, /* ~= 10^127 */
-      0x93BA47C980E98CDF, 0xC66F336C36B10137, /* ~= 10^128 */
-      0xB8A8D9BBE123F017, 0xB80B0047445D4184, /* ~= 10^129 */
-      0xE6D3102AD96CEC1D, 0xA60DC059157491E5, /* ~= 10^130 */
-      0x9043EA1AC7E41392, 0x87C89837AD68DB2F, /* ~= 10^131 */
-      0xB454E4A179DD1877, 0x29BABE4598C311FB, /* ~= 10^132 */
-      0xE16A1DC9D8545E94, 0xF4296DD6FEF3D67A, /* ~= 10^133 */
-      0x8CE2529E2734BB1D, 0x1899E4A65F58660C, /* ~= 10^134 */
-      0xB01AE745B101E9E4, 0x5EC05DCFF72E7F8F, /* ~= 10^135 */
-      0xDC21A1171D42645D, 0x76707543F4FA1F73, /* ~= 10^136 */
-      0x899504AE72497EBA, 0x6A06494A791C53A8, /* ~= 10^137 */
-      0xABFA45DA0EDBDE69, 0x0487DB9D17636892, /* ~= 10^138 */
-      0xD6F8D7509292D603, 0x45A9D2845D3C42B6, /* ~= 10^139 */
-      0x865B86925B9BC5C2, 0x0B8A2392BA45A9B2, /* ~= 10^140 */
-      0xA7F26836F282B732, 0x8E6CAC7768D7141E, /* ~= 10^141 */
-      0xD1EF0244AF2364FF, 0x3207D795430CD926, /* ~= 10^142 */
-      0x8335616AED761F1F, 0x7F44E6BD49E807B8, /* ~= 10^143 */
-      0xA402B9C5A8D3A6E7, 0x5F16206C9C6209A6, /* ~= 10^144 */
-      0xCD036837130890A1, 0x36DBA887C37A8C0F, /* ~= 10^145 */
-      0x802221226BE55A64, 0xC2494954DA2C9789, /* ~= 10^146 */
-      0xA02AA96B06DEB0FD, 0xF2DB9BAA10B7BD6C, /* ~= 10^147 */
-      0xC83553C5C8965D3D, 0x6F92829494E5ACC7, /* ~= 10^148 */
-      0xFA42A8B73ABBF48C, 0xCB772339BA1F17F9, /* ~= 10^149 */
-      0x9C69A97284B578D7, 0xFF2A760414536EFB, /* ~= 10^150 */
-      0xC38413CF25E2D70D, 0xFEF5138519684ABA, /* ~= 10^151 */
-      0xF46518C2EF5B8CD1, 0x7EB258665FC25D69, /* ~= 10^152 */
-      0x98BF2F79D5993802, 0xEF2F773FFBD97A61, /* ~= 10^153 */
-      0xBEEEFB584AFF8603, 0xAAFB550FFACFD8FA, /* ~= 10^154 */
-      0xEEAABA2E5DBF6784, 0x95BA2A53F983CF38, /* ~= 10^155 */
-      0x952AB45CFA97A0B2, 0xDD945A747BF26183, /* ~= 10^156 */
-      0xBA756174393D88DF, 0x94F971119AEEF9E4, /* ~= 10^157 */
-      0xE912B9D1478CEB17, 0x7A37CD5601AAB85D, /* ~= 10^158 */
-      0x91ABB422CCB812EE, 0xAC62E055C10AB33A, /* ~= 10^159 */
-      0xB616A12B7FE617AA, 0x577B986B314D6009, /* ~= 10^160 */
-      0xE39C49765FDF9D94, 0xED5A7E85FDA0B80B, /* ~= 10^161 */
-      0x8E41ADE9FBEBC27D, 0x14588F13BE847307, /* ~= 10^162 */
-      0xB1D219647AE6B31C, 0x596EB2D8AE258FC8, /* ~= 10^163 */
-      0xDE469FBD99A05FE3, 0x6FCA5F8ED9AEF3BB, /* ~= 10^164 */
-      0x8AEC23D680043BEE, 0x25DE7BB9480D5854, /* ~= 10^165 */
-      0xADA72CCC20054AE9, 0xAF561AA79A10AE6A, /* ~= 10^166 */
-      0xD910F7FF28069DA4, 0x1B2BA1518094DA04, /* ~= 10^167 */
-      0x87AA9AFF79042286, 0x90FB44D2F05D0842, /* ~= 10^168 */
-      0xA99541BF57452B28, 0x353A1607AC744A53, /* ~= 10^169 */
-      0xD3FA922F2D1675F2, 0x42889B8997915CE8, /* ~= 10^170 */
-      0x847C9B5D7C2E09B7, 0x69956135FEBADA11, /* ~= 10^171 */
-      0xA59BC234DB398C25, 0x43FAB9837E699095, /* ~= 10^172 */
-      0xCF02B2C21207EF2E, 0x94F967E45E03F4BB, /* ~= 10^173 */
-      0x8161AFB94B44F57D, 0x1D1BE0EEBAC278F5, /* ~= 10^174 */
-      0xA1BA1BA79E1632DC, 0x6462D92A69731732, /* ~= 10^175 */
-      0xCA28A291859BBF93, 0x7D7B8F7503CFDCFE, /* ~= 10^176 */
-      0xFCB2CB35E702AF78, 0x5CDA735244C3D43E, /* ~= 10^177 */
-      0x9DEFBF01B061ADAB, 0x3A0888136AFA64A7, /* ~= 10^178 */
-      0xC56BAEC21C7A1916, 0x088AAA1845B8FDD0, /* ~= 10^179 */
-      0xF6C69A72A3989F5B, 0x8AAD549E57273D45, /* ~= 10^180 */
-      0x9A3C2087A63F6399, 0x36AC54E2F678864B, /* ~= 10^181 */
-      0xC0CB28A98FCF3C7F, 0x84576A1BB416A7DD, /* ~= 10^182 */
-      0xF0FDF2D3F3C30B9F, 0x656D44A2A11C51D5, /* ~= 10^183 */
-      0x969EB7C47859E743, 0x9F644AE5A4B1B325, /* ~= 10^184 */
-      0xBC4665B596706114, 0x873D5D9F0DDE1FEE, /* ~= 10^185 */
-      0xEB57FF22FC0C7959, 0xA90CB506D155A7EA, /* ~= 10^186 */
-      0x9316FF75DD87CBD8, 0x09A7F12442D588F2, /* ~= 10^187 */
-      0xB7DCBF5354E9BECE, 0x0C11ED6D538AEB2F, /* ~= 10^188 */
-      0xE5D3EF282A242E81, 0x8F1668C8A86DA5FA, /* ~= 10^189 */
-      0x8FA475791A569D10, 0xF96E017D694487BC, /* ~= 10^190 */
-      0xB38D92D760EC4455, 0x37C981DCC395A9AC, /* ~= 10^191 */
-      0xE070F78D3927556A, 0x85BBE253F47B1417, /* ~= 10^192 */
-      0x8C469AB843B89562, 0x93956D7478CCEC8E, /* ~= 10^193 */
-      0xAF58416654A6BABB, 0x387AC8D1970027B2, /* ~= 10^194 */
-      0xDB2E51BFE9D0696A, 0x06997B05FCC0319E, /* ~= 10^195 */
-      0x88FCF317F22241E2, 0x441FECE3BDF81F03, /* ~= 10^196 */
-      0xAB3C2FDDEEAAD25A, 0xD527E81CAD7626C3, /* ~= 10^197 */
-      0xD60B3BD56A5586F1, 0x8A71E223D8D3B074, /* ~= 10^198 */
-      0x85C7056562757456, 0xF6872D5667844E49, /* ~= 10^199 */
-      0xA738C6BEBB12D16C, 0xB428F8AC016561DB, /* ~= 10^200 */
-      0xD106F86E69D785C7, 0xE13336D701BEBA52, /* ~= 10^201 */
-      0x82A45B450226B39C, 0xECC0024661173473, /* ~= 10^202 */
-      0xA34D721642B06084, 0x27F002D7F95D0190, /* ~= 10^203 */
-      0xCC20CE9BD35C78A5, 0x31EC038DF7B441F4, /* ~= 10^204 */
-      0xFF290242C83396CE, 0x7E67047175A15271, /* ~= 10^205 */
-      0x9F79A169BD203E41, 0x0F0062C6E984D386, /* ~= 10^206 */
-      0xC75809C42C684DD1, 0x52C07B78A3E60868, /* ~= 10^207 */
-      0xF92E0C3537826145, 0xA7709A56CCDF8A82, /* ~= 10^208 */
-      0x9BBCC7A142B17CCB, 0x88A66076400BB691, /* ~= 10^209 */
-      0xC2ABF989935DDBFE, 0x6ACFF893D00EA435, /* ~= 10^210 */
-      0xF356F7EBF83552FE, 0x0583F6B8C4124D43, /* ~= 10^211 */
-      0x98165AF37B2153DE, 0xC3727A337A8B704A, /* ~= 10^212 */
-      0xBE1BF1B059E9A8D6, 0x744F18C0592E4C5C, /* ~= 10^213 */
-      0xEDA2EE1C7064130C, 0x1162DEF06F79DF73, /* ~= 10^214 */
-      0x9485D4D1C63E8BE7, 0x8ADDCB5645AC2BA8, /* ~= 10^215 */
-      0xB9A74A0637CE2EE1, 0x6D953E2BD7173692, /* ~= 10^216 */
-      0xE8111C87C5C1BA99, 0xC8FA8DB6CCDD0437, /* ~= 10^217 */
-      0x910AB1D4DB9914A0, 0x1D9C9892400A22A2, /* ~= 10^218 */
-      0xB54D5E4A127F59C8, 0x2503BEB6D00CAB4B, /* ~= 10^219 */
-      0xE2A0B5DC971F303A, 0x2E44AE64840FD61D, /* ~= 10^220 */
-      0x8DA471A9DE737E24, 0x5CEAECFED289E5D2, /* ~= 10^221 */
-      0xB10D8E1456105DAD, 0x7425A83E872C5F47, /* ~= 10^222 */
-      0xDD50F1996B947518, 0xD12F124E28F77719, /* ~= 10^223 */
-      0x8A5296FFE33CC92F, 0x82BD6B70D99AAA6F, /* ~= 10^224 */
-      0xACE73CBFDC0BFB7B, 0x636CC64D1001550B, /* ~= 10^225 */
-      0xD8210BEFD30EFA5A, 0x3C47F7E05401AA4E, /* ~= 10^226 */
-      0x8714A775E3E95C78, 0x65ACFAEC34810A71, /* ~= 10^227 */
-      0xA8D9D1535CE3B396, 0x7F1839A741A14D0D, /* ~= 10^228 */
-      0xD31045A8341CA07C, 0x1EDE48111209A050, /* ~= 10^229 */
-      0x83EA2B892091E44D, 0x934AED0AAB460432, /* ~= 10^230 */
-      0xA4E4B66B68B65D60, 0xF81DA84D5617853F, /* ~= 10^231 */
-      0xCE1DE40642E3F4B9, 0x36251260AB9D668E, /* ~= 10^232 */
-      0x80D2AE83E9CE78F3, 0xC1D72B7C6B426019, /* ~= 10^233 */
-      0xA1075A24E4421730, 0xB24CF65B8612F81F, /* ~= 10^234 */
-      0xC94930AE1D529CFC, 0xDEE033F26797B627, /* ~= 10^235 */
-      0xFB9B7CD9A4A7443C, 0x169840EF017DA3B1, /* ~= 10^236 */
-      0x9D412E0806E88AA5, 0x8E1F289560EE864E, /* ~= 10^237 */
-      0xC491798A08A2AD4E, 0xF1A6F2BAB92A27E2, /* ~= 10^238 */
-      0xF5B5D7EC8ACB58A2, 0xAE10AF696774B1DB, /* ~= 10^239 */
-      0x9991A6F3D6BF1765, 0xACCA6DA1E0A8EF29, /* ~= 10^240 */
-      0xBFF610B0CC6EDD3F, 0x17FD090A58D32AF3, /* ~= 10^241 */
-      0xEFF394DCFF8A948E, 0xDDFC4B4CEF07F5B0, /* ~= 10^242 */
-      0x95F83D0A1FB69CD9, 0x4ABDAF101564F98E, /* ~= 10^243 */
-      0xBB764C4CA7A4440F, 0x9D6D1AD41ABE37F1, /* ~= 10^244 */
-      0xEA53DF5FD18D5513, 0x84C86189216DC5ED, /* ~= 10^245 */
-      0x92746B9BE2F8552C, 0x32FD3CF5B4E49BB4, /* ~= 10^246 */
-      0xB7118682DBB66A77, 0x3FBC8C33221DC2A1, /* ~= 10^247 */
-      0xE4D5E82392A40515, 0x0FABAF3FEAA5334A, /* ~= 10^248 */
-      0x8F05B1163BA6832D, 0x29CB4D87F2A7400E, /* ~= 10^249 */
-      0xB2C71D5BCA9023F8, 0x743E20E9EF511012, /* ~= 10^250 */
-      0xDF78E4B2BD342CF6, 0x914DA9246B255416, /* ~= 10^251 */
-      0x8BAB8EEFB6409C1A, 0x1AD089B6C2F7548E, /* ~= 10^252 */
-      0xAE9672ABA3D0C320, 0xA184AC2473B529B1, /* ~= 10^253 */
-      0xDA3C0F568CC4F3E8, 0xC9E5D72D90A2741E, /* ~= 10^254 */
-      0x8865899617FB1871, 0x7E2FA67C7A658892, /* ~= 10^255 */
-      0xAA7EEBFB9DF9DE8D, 0xDDBB901B98FEEAB7, /* ~= 10^256 */
-      0xD51EA6FA85785631, 0x552A74227F3EA565, /* ~= 10^257 */
-      0x8533285C936B35DE, 0xD53A88958F87275F, /* ~= 10^258 */
-      0xA67FF273B8460356, 0x8A892ABAF368F137, /* ~= 10^259 */
-      0xD01FEF10A657842C, 0x2D2B7569B0432D85, /* ~= 10^260 */
-      0x8213F56A67F6B29B, 0x9C3B29620E29FC73, /* ~= 10^261 */
-      0xA298F2C501F45F42, 0x8349F3BA91B47B8F, /* ~= 10^262 */
-      0xCB3F2F7642717713, 0x241C70A936219A73, /* ~= 10^263 */
-      0xFE0EFB53D30DD4D7, 0xED238CD383AA0110, /* ~= 10^264 */
-      0x9EC95D1463E8A506, 0xF4363804324A40AA, /* ~= 10^265 */
-      0xC67BB4597CE2CE48, 0xB143C6053EDCD0D5, /* ~= 10^266 */
-      0xF81AA16FDC1B81DA, 0xDD94B7868E94050A, /* ~= 10^267 */
-      0x9B10A4E5E9913128, 0xCA7CF2B4191C8326, /* ~= 10^268 */
-      0xC1D4CE1F63F57D72, 0xFD1C2F611F63A3F0, /* ~= 10^269 */
-      0xF24A01A73CF2DCCF, 0xBC633B39673C8CEC, /* ~= 10^270 */
-      0x976E41088617CA01, 0xD5BE0503E085D813, /* ~= 10^271 */
-      0xBD49D14AA79DBC82, 0x4B2D8644D8A74E18, /* ~= 10^272 */
-      0xEC9C459D51852BA2, 0xDDF8E7D60ED1219E, /* ~= 10^273 */
-      0x93E1AB8252F33B45, 0xCABB90E5C942B503, /* ~= 10^274 */
-      0xB8DA1662E7B00A17, 0x3D6A751F3B936243, /* ~= 10^275 */
-      0xE7109BFBA19C0C9D, 0x0CC512670A783AD4, /* ~= 10^276 */
-      0x906A617D450187E2, 0x27FB2B80668B24C5, /* ~= 10^277 */
-      0xB484F9DC9641E9DA, 0xB1F9F660802DEDF6, /* ~= 10^278 */
-      0xE1A63853BBD26451, 0x5E7873F8A0396973, /* ~= 10^279 */
-      0x8D07E33455637EB2, 0xDB0B487B6423E1E8, /* ~= 10^280 */
-      0xB049DC016ABC5E5F, 0x91CE1A9A3D2CDA62, /* ~= 10^281 */
-      0xDC5C5301C56B75F7, 0x7641A140CC7810FB, /* ~= 10^282 */
-      0x89B9B3E11B6329BA, 0xA9E904C87FCB0A9D, /* ~= 10^283 */
-      0xAC2820D9623BF429, 0x546345FA9FBDCD44, /* ~= 10^284 */
-      0xD732290FBACAF133, 0xA97C177947AD4095, /* ~= 10^285 */
-      0x867F59A9D4BED6C0, 0x49ED8EABCCCC485D, /* ~= 10^286 */
-      0xA81F301449EE8C70, 0x5C68F256BFFF5A74, /* ~= 10^287 */
-      0xD226FC195C6A2F8C, 0x73832EEC6FFF3111, /* ~= 10^288 */
-      0x83585D8FD9C25DB7, 0xC831FD53C5FF7EAB, /* ~= 10^289 */
-      0xA42E74F3D032F525, 0xBA3E7CA8B77F5E55, /* ~= 10^290 */
-      0xCD3A1230C43FB26F, 0x28CE1BD2E55F35EB, /* ~= 10^291 */
-      0x80444B5E7AA7CF85, 0x7980D163CF5B81B3, /* ~= 10^292 */
-      0xA0555E361951C366, 0xD7E105BCC332621F, /* ~= 10^293 */
-      0xC86AB5C39FA63440, 0x8DD9472BF3FEFAA7, /* ~= 10^294 */
-      0xFA856334878FC150, 0xB14F98F6F0FEB951, /* ~= 10^295 */
-      0x9C935E00D4B9D8D2, 0x6ED1BF9A569F33D3, /* ~= 10^296 */
-      0xC3B8358109E84F07, 0x0A862F80EC4700C8, /* ~= 10^297 */
-      0xF4A642E14C6262C8, 0xCD27BB612758C0FA, /* ~= 10^298 */
-      0x98E7E9CCCFBD7DBD, 0x8038D51CB897789C, /* ~= 10^299 */
-      0xBF21E44003ACDD2C, 0xE0470A63E6BD56C3, /* ~= 10^300 */
-      0xEEEA5D5004981478, 0x1858CCFCE06CAC74, /* ~= 10^301 */
-      0x95527A5202DF0CCB, 0x0F37801E0C43EBC8, /* ~= 10^302 */
-      0xBAA718E68396CFFD, 0xD30560258F54E6BA, /* ~= 10^303 */
-      0xE950DF20247C83FD, 0x47C6B82EF32A2069, /* ~= 10^304 */
-      0x91D28B7416CDD27E, 0x4CDC331D57FA5441, /* ~= 10^305 */
-      0xB6472E511C81471D, 0xE0133FE4ADF8E952, /* ~= 10^306 */
-      0xE3D8F9E563A198E5, 0x58180FDDD97723A6, /* ~= 10^307 */
-      0x8E679C2F5E44FF8F, 0x570F09EAA7EA7648, /* ~= 10^308 */
-      0xB201833B35D63F73, 0x2CD2CC6551E513DA, /* ~= 10^309 */
-      0xDE81E40A034BCF4F, 0xF8077F7EA65E58D1, /* ~= 10^310 */
-      0x8B112E86420F6191, 0xFB04AFAF27FAF782, /* ~= 10^311 */
-      0xADD57A27D29339F6, 0x79C5DB9AF1F9B563, /* ~= 10^312 */
-      0xD94AD8B1C7380874, 0x18375281AE7822BC, /* ~= 10^313 */
-      0x87CEC76F1C830548, 0x8F2293910D0B15B5, /* ~= 10^314 */
-      0xA9C2794AE3A3C69A, 0xB2EB3875504DDB22, /* ~= 10^315 */
-      0xD433179D9C8CB841, 0x5FA60692A46151EB, /* ~= 10^316 */
-      0x849FEEC281D7F328, 0xDBC7C41BA6BCD333, /* ~= 10^317 */
-      0xA5C7EA73224DEFF3, 0x12B9B522906C0800, /* ~= 10^318 */
-      0xCF39E50FEAE16BEF, 0xD768226B34870A00, /* ~= 10^319 */
-      0x81842F29F2CCE375, 0xE6A1158300D46640, /* ~= 10^320 */
-      0xA1E53AF46F801C53, 0x60495AE3C1097FD0, /* ~= 10^321 */
-      0xCA5E89B18B602368, 0x385BB19CB14BDFC4, /* ~= 10^322 */
-      0xFCF62C1DEE382C42, 0x46729E03DD9ED7B5, /* ~= 10^323 */
-      0x9E19DB92B4E31BA9, 0x6C07A2C26A8346D1 /* ~= 10^324 */
-   };
-
-   /**
-    Get the cached pow10 value from pow10_sig_table.
-    @param exp10 The exponent of pow(10, e). This value must in range
-                 POW10_SIG_TABLE_MIN_EXP to POW10_SIG_TABLE_MAX_EXP.
-    @param hi    The highest 64 bits of pow(10, e).
-    @param lo    The lower 64 bits after `hi`.
-    */
-   /*inline void pow10_table_get_sig_128(int32_t exp10, uint64_t *hi, uint64_t *lo) noexcept
-   {
-      const int32_t idx = exp10 - (POW10_SIG_TABLE_128_MIN_EXP);
-      *hi = pow10_sig_table_128[idx * 2];
-      *lo = pow10_sig_table_128[idx * 2 + 1];
-   }*/
-
-   inline void pow10_table_get_sig_128(const int32_t exp10, uint64_t hilo[2]) noexcept
-   {
-      const int32_t idx = exp10 - (POW10_SIG_TABLE_128_MIN_EXP);
-      std::memcpy(hilo, pow10_sig_table_128.data() + idx * 2, 16);
-   }
-
-   /**
-    Convert double number from binary to decimal.
-    The output significand is shortest decimal but may have trailing zeros.
-
-    This function use the Schubfach algorithm:
-    Raffaello Giulietti, The Schubfach way to render doubles, 2020.
-    https://drive.google.com/open?id=1luHhyQF9zKlM8yJ1nebU0OgVYhfC6CBN
-    https://github.com/abolz/Drachennest
-
-    See also:
-    Dragonbox: A New Floating-Point Binary-to-Decimal Conversion Algorithm, 2020.
-    https://github.com/jk-jeon/dragonbox/blob/master/other_files/Dragonbox.pdf
-    https://github.com/jk-jeon/dragonbox
-
-    @param sig_raw The raw value of significand in IEEE 754 format.
-    @param exp_raw The raw value of exponent in IEEE 754 format.
-    @param sig_bin The decoded value of significand in binary.
-    @param exp_bin The decoded value of exponent in binary.
-    @param sig_dec The output value of significand in decimal.
-    @param exp_dec The output value of exponent in decimal.
-    @warning The input double number should not be 0, inf, nan.
-    */
-   inline void f64_bin_to_dec(uint64_t sig_raw, int32_t exp_raw, uint64_t sig_bin, int32_t exp_bin, uint64_t* sig_dec,
-                              int32_t* exp_dec) noexcept
-   {
-      uint64_t sp, mid;
-
-      const bool is_even = !(sig_bin & 1);
-      const bool lower_bound_closer = (sig_raw == 0 && exp_raw > 1);
-
-      const uint64_t cb = 4 * sig_bin;
-      const uint64_t cbl = cb - 2 + lower_bound_closer;
-      const uint64_t cbr = cb + 2;
-
-      /* exp_bin: [-1074, 971]                                                  */
-      /* k = lower_bound_closer ? floor(log10(pow(2, exp_bin)))                 */
-      /*                        : floor(log10(pow(2, exp_bin) * 3.0 / 4.0))     */
-      /*   = lower_bound_closer ? floor(exp_bin * log10(2))                     */
-      /*                        : floor(exp_bin * log10(2) + log10(3.0 / 4.0))  */
-      const int32_t k = (exp_bin * 315653 - (lower_bound_closer ? 131237 : 0)) >> 20;
-
-      /* k: [-324, 292]                                                         */
-      /* h = exp_bin + floor(log2(pow(10, e)))                                  */
-      /*   = exp_bin + floor(log2(10) * e)                                      */
-      const int32_t exp10 = -k;
-      const int32_t h = exp_bin + ((exp10 * 217707) >> 16) + 1;
-
-      uint64_t pow10hilo[2];
-      pow10_table_get_sig_128(exp10, pow10hilo);
-      const uint64_t& pow10hi = pow10hilo[0];
-      uint64_t& pow10lo = pow10hilo[1];
-      pow10lo += (exp10 < POW10_SIG_TABLE_128_MIN_EXACT_EXP || exp10 > POW10_SIG_TABLE_128_MAX_EXACT_EXP);
-      const uint64_t vbl = round_to_odd(pow10hi, pow10lo, cbl << h);
-      const uint64_t vb = round_to_odd(pow10hi, pow10lo, cb << h);
-      const uint64_t vbr = round_to_odd(pow10hi, pow10lo, cbr << h);
-
-      const uint64_t lower = vbl + !is_even;
-      const uint64_t upper = vbr - !is_even;
+   constexpr int int_log2(uint32_t x) noexcept { return 31 - glz::countl_zero(x | 1); }
 
-      bool u_inside, w_inside;
+   inline constexpr uint64_t digit_count_table[] = {
+      4294967296,  8589934582,  8589934582,  8589934582,  12884901788, 12884901788, 12884901788, 17179868184,
+      17179868184, 17179868184, 21474826480, 21474826480, 21474826480, 21474826480, 25769703776, 25769703776,
+      25769703776, 30063771072, 30063771072, 30063771072, 34349738368, 34349738368, 34349738368, 34349738368,
+      38554705664, 38554705664, 38554705664, 41949672960, 41949672960, 41949672960, 42949672960, 42949672960};
 
-      const uint64_t s = vb / 4;
-      if (s >= 10) {
-         sp = s / 10;
-         u_inside = (lower <= 40 * sp);
-         w_inside = (upper >= 40 * sp + 40);
-         if (u_inside != w_inside) {
-            *sig_dec = sp + w_inside;
-            *exp_dec = k + 1;
-            return;
-         }
-      }
-
-      u_inside = (lower <= 4 * s);
-      w_inside = (upper >= 4 * s + 4);
-
-      mid = 4 * s + 2;
-      const bool round_up = (vb > mid) || (vb == mid && (s & 1) != 0);
-
-      *sig_dec = s + ((u_inside != w_inside) ? w_inside : round_up);
-      *exp_dec = k;
-   }
+   // https://lemire.me/blog/2021/06/03/computing-the-number-of-digits-of-an-integer-even-faster/
+   constexpr int fast_digit_count(const uint32_t x) noexcept { return (x + digit_count_table[int_log2(x)]) >> 32; }
 
    /** Trailing zero count table for number 0 to 99.
     (generate with misc/make_tables.c) */
@@ -914,20 +77,14 @@ namespace glz
          uint32_t hhii = ffgghhii - ffgg * 10000; /* (val % 10000) */
          uint32_t ff = (ffgg * 5243) >> 19; /* (aabb / 100) */
          uint32_t gg = ffgg - ff * 100; /* (aabb % 100) */
-         //((uint16_t *)buf)[2] = ((const uint16_t *)char_table)[dd];
          std::memcpy(buf + 4, char_table + 2 * dd, 2);
-         //((uint16_t *)buf)[3] = ((const uint16_t *)char_table)[ee];
          std::memcpy(buf + 6, char_table + 2 * ee, 2);
-         //((uint16_t *)buf)[4] = ((const uint16_t *)char_table)[ff];
          std::memcpy(buf + 8, char_table + 2 * ff, 2);
-         //((uint16_t *)buf)[5] = ((const uint16_t *)char_table)[gg];
          std::memcpy(buf + 10, char_table + 2 * gg, 2);
          if (hhii) {
             uint32_t hh = (hhii * 5243) >> 19; /* (ccdd / 100) */
             uint32_t ii = hhii - hh * 100; /* (ccdd % 100) */
-            //((uint16_t *)buf)[6] = ((const uint16_t *)char_table)[hh];
             std::memcpy(buf + 12, char_table + 2 * hh, 2);
-            //((uint16_t *)buf)[7] = ((const uint16_t *)char_table)[ii];
             std::memcpy(buf + 14, char_table + 2 * ii, 2);
             tz1 = dec_trailing_zero_table[hh];
             tz2 = dec_trailing_zero_table[ii];
@@ -947,9 +104,7 @@ namespace glz
          if (ddee) {
             uint32_t dd = (ddee * 5243) >> 19; /* (ddee / 100) */
             uint32_t ee = ddee - dd * 100; /* (ddee % 100) */
-            //((uint16_t *)buf)[2] = ((const uint16_t *)char_table)[dd];
             std::memcpy(buf + 4, char_table + 2 * dd, 2);
-            //((uint16_t *)buf)[3] = ((const uint16_t *)char_table)[ee];
             std::memcpy(buf + 6, char_table + 2 * ee, 2);
             tz1 = dec_trailing_zero_table[dd];
             tz2 = dec_trailing_zero_table[ee];
@@ -967,130 +122,198 @@ namespace glz
       }
    }
 
+   inline auto* write_u32_len_1_to_9(auto* buf, uint32_t val) noexcept
+   {
+      if (val < 10) {
+         *buf = uint8_t(val + '0');
+         return buf + 1;
+      }
+
+      if (val < 100) {
+         std::memcpy(buf, char_table + (val * 2), 2);
+         return buf + 2;
+      }
+
+      const uint32_t digits = fast_digit_count(val);
+
+      // Write digits in reverse order
+      auto* end = buf + digits;
+      auto* p = end;
+      while (val >= 100) {
+         const uint32_t q = val / 100;
+         const uint32_t r = val % 100;
+         val = q;
+         std::memcpy(p - 2, char_table + (r * 2), 2);
+         p -= 2;
+      }
+
+      if (val < 10) {
+         *--p = uint8_t(val + '0');
+      }
+      else {
+         std::memcpy(p - 2, char_table + (val * 2), 2);
+      }
+
+      return end;
+   }
+
    consteval uint32_t numbits(uint32_t x) noexcept { return x < 2 ? x : 1 + numbits(x >> 1); }
 
    template <std::floating_point T>
-   inline auto* to_chars(auto* buffer, T val) noexcept
+   inline auto* to_chars(auto* buf, T val) noexcept
    {
       static_assert(std::numeric_limits<T>::is_iec559);
       static_assert(std::numeric_limits<T>::radix == 2);
       static_assert(std::is_same_v<float, T> || std::is_same_v<double, T>);
       static_assert(sizeof(float) == 4 && sizeof(double) == 8);
+      constexpr bool is_float = std::is_same_v<float, T>;
       using Raw = std::conditional_t<std::is_same_v<float, T>, uint32_t, uint64_t>;
 
-      Raw raw;
-      std::memcpy(&raw, &val, sizeof(T));
+      if (val == 0.0) {
+         *buf = '-';
+         buf += (std::bit_cast<Raw>(val) >> (sizeof(T) * 8 - 1)); // if negative
+         *buf = '0';
+         return buf + 1;
+      }
 
-      /* decode from raw bytes from IEEE-754 double format. */
-      constexpr uint32_t exponent_bits =
+      using Conversion = glz::jkj::dragonbox::default_float_bit_carrier_conversion_traits<T>;
+      using FormatTraits =
+         glz::jkj::dragonbox::ieee754_binary_traits<typename Conversion::format, typename Conversion::carrier_uint>;
+      static constexpr uint32_t exp_bits_count =
          numbits(std::numeric_limits<T>::max_exponent - std::numeric_limits<T>::min_exponent + 1);
-      constexpr Raw sig_mask = Raw(-1) >> (exponent_bits + 1);
-      bool sign = (raw >> (sizeof(T) * 8 - 1));
-      uint64_t sig_raw = raw & sig_mask;
-      int32_t exp_raw = raw << 1 >> (sizeof(Raw) * 8 - exponent_bits);
-
-      if (exp_raw == (uint32_t(1) << exponent_bits) - 1) [[unlikely]] {
-         // NaN or Infinity
-         std::memcpy(buffer, "null", 4);
-         return buffer + 4;
-      }
-      if (sign) {
-         *buffer = '-';
-         ++buffer;
+      const auto float_bits = glz::jkj::dragonbox::make_float_bits<T, Conversion, FormatTraits>(val);
+      const auto exp_bits = float_bits.extract_exponent_bits();
+      const auto s = float_bits.remove_exponent_bits();
+
+      // NaN or Infinity
+      if (exp_bits == (uint32_t(1) << exp_bits_count) - 1) [[unlikely]] {
+         std::memcpy(buf, "null", 4);
+         return buf + 4;
       }
-      if ((raw << 1) != 0) [[likely]] {
-         uint64_t sig_bin;
-         int32_t exp_bin;
-         if (exp_raw == 0) [[unlikely]] {
-            // subnormal
-            sig_bin = sig_raw;
-            exp_bin = 1 - (std::numeric_limits<T>::max_exponent - 1) - (std::numeric_limits<T>::digits - 1);
+
+      *buf = '-';
+      constexpr auto zero = T(0.0);
+      buf += (val < zero);
+
+      if constexpr (is_float) {
+         const auto v = glz::jkj::dragonbox::to_decimal_ex(s, exp_bits, glz::jkj::dragonbox::policy::sign::ignore,
+                                                           glz::jkj::dragonbox::policy::trailing_zero::remove);
+
+         uint32_t sig_dec = uint32_t(v.significand);
+         int32_t exp_dec = v.exponent;
+         const int32_t num_digits = int32_t(fast_digit_count(sig_dec));
+         int32_t dot_pos = num_digits + exp_dec; // the decimal point position relative to the first digit
+
+         if (-6 < dot_pos && dot_pos <= 9) {
+            // no need to write exponent part
+            if (dot_pos <= 0) {
+               *buf++ = '0';
+               *buf++ = '.';
+               while (dot_pos < 0) {
+                  *buf++ = '0';
+                  ++dot_pos;
+               }
+               return write_u32_len_1_to_9(buf, sig_dec);
+            }
+            else {
+               auto num_end = write_u32_len_1_to_9(buf, sig_dec);
+               int32_t digits_written = int32_t(num_end - buf);
+               if (dot_pos < digits_written) {
+                  std::memmove(buf + dot_pos + 1, buf + dot_pos, digits_written - dot_pos);
+                  buf[dot_pos] = '.';
+                  return num_end + 1;
+               }
+               else if (dot_pos > digits_written) {
+                  std::memset(num_end, '0', dot_pos - digits_written);
+                  return buf + dot_pos;
+               }
+               else {
+                  return num_end; // Whole number, no decimal point needed
+               }
+            }
          }
          else {
-            sig_bin = sig_raw | uint64_t(1ull << (std::numeric_limits<T>::digits - 1));
-            exp_bin =
-               int32_t(exp_raw) - (std::numeric_limits<T>::max_exponent - 1) - (std::numeric_limits<T>::digits - 1);
+            // write with scientific notation
+            auto end = write_u32_len_1_to_9(buf + 1, sig_dec);
+            exp_dec += int32_t(end - (buf + 1)) - 1; // Adjust exponent based on actual digits written
+            buf[0] = buf[1];
+            buf[1] = '.';
+            if (end == buf + 2) { // Only one digit was written
+               buf[2] = '0'; // Add trailing zero
+               ++end;
+            }
+            *end = 'E';
+            buf = end + 1;
+            if (exp_dec < 0) {
+               *buf = '-';
+               ++buf;
+               exp_dec = -exp_dec;
+            }
+            exp_dec = std::abs(exp_dec);
+            uint32_t lz = exp_dec < 10;
+            std::memcpy(buf, char_table + (exp_dec * 2 + lz), 2);
+            return buf + 2 - lz;
          }
+      }
+      else {
+         const auto v = glz::jkj::dragonbox::to_decimal_ex(s, exp_bits, glz::jkj::dragonbox::policy::sign::ignore,
+                                                           glz::jkj::dragonbox::policy::trailing_zero::ignore);
 
-         // if constexpr (std::same_as<T, float>) {
-         //    constexpr auto shift = std::numeric_limits<double>::digits - std::numeric_limits<float>::digits;
-         //    sig_bin <<= shift;
-         //    exp_bin -= shift;
-         // }
-
-         /* binary to decimal */
-         uint64_t sig_dec;
-         int32_t exp_dec;
-         f64_bin_to_dec(sig_raw, exp_raw, sig_bin, exp_bin, &sig_dec, &exp_dec);
-         if constexpr (std::same_as<T, float>) {
-            sig_dec *= 100000000;
-            exp_dec -= 8;
-         }
+         uint64_t sig_dec = v.significand;
+         int32_t exp_dec = v.exponent;
 
          int32_t sig_len = 17;
          sig_len -= (sig_dec < 100000000ull * 100000000ull);
          sig_len -= (sig_dec < 100000000ull * 10000000ull);
-
-         /* the decimal point position relative to the first digit */
          int32_t dot_pos = sig_len + exp_dec;
 
          if (-6 < dot_pos && dot_pos <= 21) {
-            /* no need to write exponent part */
+            // no need to write exponent part
             if (dot_pos <= 0) {
-               auto num_hdr = buffer + (2 - dot_pos);
+               auto num_hdr = buf + (2 - dot_pos);
                auto num_end = write_u64_len_15_to_17_trim(num_hdr, sig_dec);
-               buffer[0] = '0';
-               buffer[1] = '.';
-               buffer += 2;
-               // we don't have to increment the buffer because we are returning
-               std::memset(buffer, '0', num_hdr - buffer);
+               buf[0] = '0';
+               buf[1] = '.';
+               buf += 2;
+               std::memset(buf, '0', size_t(num_hdr - buf));
                return num_end;
             }
             else {
-               /* dot after first digit */
-               /* such as 1.234, 1234.0, 123400000000000000000.0 */
-               std::memset(buffer, '0', 8);
-               std::memset(buffer + 8, '0', 8);
-               std::memset(buffer + 16, '0', 8);
-               auto num_hdr = buffer + 1;
+               // dot after first digit
+               // such as 1.234, 1234.0, 123400000000000000000.0
+               std::memset(buf, '0', 24);
+               auto num_hdr = buf + 1;
                auto num_end = write_u64_len_15_to_17_trim(num_hdr, sig_dec);
-               std::memmove(buffer, buffer + 1, dot_pos); // shift characters to the left
-               buffer[dot_pos] = '.';
-               return ((num_end - num_hdr) <= dot_pos) ? buffer + dot_pos : num_end;
+               std::memmove(buf, buf + 1, size_t(dot_pos));
+               buf[dot_pos] = '.';
+               return ((num_end - num_hdr) <= dot_pos) ? buf + dot_pos : num_end;
             }
          }
          else {
-            /* write with scientific notation */
-            /* such as 1.234e56 */
-            auto end = write_u64_len_15_to_17_trim(buffer + 1, sig_dec);
-            end -= (end == buffer + 2); /* remove '.0', e.g. 2.0e34 -> 2e34 */
+            // write with scientific notation
+            auto end = write_u64_len_15_to_17_trim(buf + 1, sig_dec);
+            end -= (end == buf + 2); // remove '.0', e.g. 2.0e34 -> 2e34
             exp_dec += sig_len - 1;
-            buffer[0] = buffer[1];
-            buffer[1] = '.';
+            buf[0] = buf[1];
+            buf[1] = '.';
             end[0] = 'E';
-            buffer = end + 1;
-            buffer[0] = '-';
-            buffer += exp_dec < 0;
+            buf = end + 1;
+            buf[0] = '-';
+            buf += exp_dec < 0;
             exp_dec = std::abs(exp_dec);
             if (exp_dec < 100) {
                uint32_t lz = exp_dec < 10;
-               //*(uint16_t *)buffer = *(const uint16_t *)(char_table + (exp_dec * 2 + lz));
-               std::memcpy(buffer, char_table + (exp_dec * 2 + lz), 2);
-               return buffer + 2 - lz;
+               std::memcpy(buf, char_table + (exp_dec * 2 + lz), 2);
+               return buf + 2 - lz;
             }
             else {
-               const uint32_t hi = (uint32_t(exp_dec) * 656) >> 16; /* exp / 100 */
-               const uint32_t lo = uint32_t(exp_dec) - hi * 100; /* exp % 100 */
-               buffer[0] = uint8_t(hi) + '0';
-               std::memcpy(&buffer[1], char_table + (lo * 2), 2);
-               return buffer + 3;
+               const uint32_t hi = (uint32_t(exp_dec) * 656) >> 16; // exp / 100
+               const uint32_t lo = uint32_t(exp_dec) - hi * 100; // exp % 100
+               buf[0] = uint8_t(hi) + '0';
+               std::memcpy(&buf[1], char_table + (lo * 2), 2);
+               return buf + 3;
             }
          }
       }
-      else [[unlikely]] {
-         *buffer = '0';
-         return buffer + 1;
-      }
    }
-
 }
diff --git a/deps/saucer/include/glaze/util/dump.hpp b/deps/saucer/include/glaze/util/dump.hpp
index b407a33..ad4e755 100644
--- a/deps/saucer/include/glaze/util/dump.hpp
+++ b/deps/saucer/include/glaze/util/dump.hpp
@@ -10,50 +10,36 @@
 #include <string_view>
 
 #include "glaze/concepts/container_concepts.hpp"
+#include "glaze/core/opts.hpp"
+#include "glaze/util/convert.hpp"
 
-namespace glz::detail
+namespace glz
 {
    template <class T, class V = std::remove_cvref_t<T>>
    concept byte_sized = sizeof(T) == 1 && (std::same_as<V, char> || std::same_as<V, std::byte>);
 
-   template <class T>
-   [[nodiscard]] GLZ_ALWAYS_INLINE auto data_ptr(T& buffer) noexcept
-   {
-      if constexpr (has_data<T>) {
-         if constexpr (std::same_as<std::decay_t<typename T::value_type>, std::byte>) {
-            return reinterpret_cast<char*>(buffer.data());
-         }
-         else {
-            return buffer.data();
-         }
-      }
-      else {
-         return buffer;
-      }
-   }
-
    template <uint32_t N, class B>
-   GLZ_ALWAYS_INLINE void maybe_pad(B& b, auto& ix) noexcept
+   GLZ_ALWAYS_INLINE void maybe_pad(B& b, size_t ix) noexcept(not vector_like<B>)
    {
       if constexpr (vector_like<B>) {
          if (const auto k = ix + N; k > b.size()) [[unlikely]] {
-            b.resize((std::max)(b.size() * 2, k));
+            b.resize(2 * k);
          }
       }
    }
 
    template <class B>
-   GLZ_ALWAYS_INLINE void maybe_pad(const size_t n, B& b, auto& ix) noexcept
+   GLZ_ALWAYS_INLINE void maybe_pad(const size_t n, B& b, size_t ix) noexcept(not vector_like<B>)
    {
       if constexpr (vector_like<B>) {
          if (const auto k = ix + n; k > b.size()) [[unlikely]] {
-            b.resize((std::max)(b.size() * 2, k));
+            b.resize(2 * k);
          }
       }
    }
 
    template <auto c>
-   GLZ_ALWAYS_INLINE void assign_maybe_cast(auto& b, auto& ix) noexcept
+   GLZ_ALWAYS_INLINE void assign_maybe_cast(auto& b, size_t& ix) noexcept
    {
       using V = std::decay_t<decltype(b[0])>;
       using C = std::decay_t<decltype(c)>;
@@ -65,7 +51,7 @@ namespace glz::detail
       }
    }
 
-   GLZ_ALWAYS_INLINE void assign_maybe_cast(const byte_sized auto c, auto& b, auto& ix) noexcept
+   GLZ_ALWAYS_INLINE void assign_maybe_cast(const byte_sized auto c, auto& b, size_t& ix) noexcept
    {
       using V = std::decay_t<decltype(b[0])>;
       using C = std::decay_t<decltype(c)>;
@@ -77,10 +63,10 @@ namespace glz::detail
       }
    }
 
-   template <class B>
-   GLZ_ALWAYS_INLINE void dump(const byte_sized auto c, B& b, auto& ix) noexcept
+   template <bool Checked = true, class B>
+   GLZ_ALWAYS_INLINE void dump(const byte_sized auto c, B& b, size_t& ix) noexcept(not vector_like<B>)
    {
-      if constexpr (vector_like<B>) {
+      if constexpr (Checked && vector_like<B>) {
          if (ix == b.size()) [[unlikely]] {
             b.resize(b.size() == 0 ? 128 : b.size() * 2);
          }
@@ -89,10 +75,10 @@ namespace glz::detail
       ++ix;
    }
 
-   template <auto c, class B>
-   GLZ_ALWAYS_INLINE void dump(B& b, auto& ix) noexcept
+   template <auto c, bool Checked = true, class B>
+   GLZ_ALWAYS_INLINE void dump(B& b, size_t& ix) noexcept(not vector_like<B>)
    {
-      if constexpr (vector_like<B>) {
+      if constexpr (Checked && vector_like<B>) {
          if (ix == b.size()) [[unlikely]] {
             b.resize(b.size() == 0 ? 128 : b.size() * 2);
          }
@@ -101,207 +87,151 @@ namespace glz::detail
       ++ix;
    }
 
-   template <string_literal str, class B>
-   GLZ_ALWAYS_INLINE void dump(B& b, auto& ix) noexcept
+   template <string_literal str, bool Checked = true, class B>
+   GLZ_ALWAYS_INLINE void dump(B& b, size_t& ix) noexcept(not vector_like<B>)
    {
       static constexpr auto s = str.sv();
       static constexpr auto n = s.size();
 
       if constexpr (vector_like<B>) {
-         if (ix + n > b.size()) [[unlikely]] {
-            b.resize((std::max)(b.size() * 2, ix + n));
+         if constexpr (Checked) {
+            const auto k = ix + n;
+            if (k > b.size()) [[unlikely]] {
+               b.resize(2 * k);
+            }
          }
-         std::memcpy(b.data() + ix, s.data(), n);
-      }
-      else {
-         std::memcpy(b + ix, s.data(), n);
       }
+      std::memcpy(&b[ix], s.data(), n);
       ix += n;
    }
 
-   template <auto c>
-   GLZ_ALWAYS_INLINE void dump_unchecked(auto& b, auto& ix) noexcept
-   {
-      assign_maybe_cast<c>(b, ix);
-      ++ix;
-   }
-
-   GLZ_ALWAYS_INLINE void dump_unchecked(const byte_sized auto c, auto& b, auto& ix) noexcept
-   {
-      assign_maybe_cast(c, b, ix);
-      ++ix;
-   }
-
-   template <class B>
-   GLZ_ALWAYS_INLINE void dump_unchecked(const sv str, B& b, auto& ix) noexcept
+   template <bool Checked = true, class B>
+   GLZ_ALWAYS_INLINE void dump(const sv str, B& b, size_t& ix) noexcept(not vector_like<B>)
    {
       const auto n = str.size();
       if constexpr (vector_like<B>) {
-         std::memcpy(b.data() + ix, str.data(), n);
-      }
-      else {
-         std::memcpy(b + ix, str.data(), n);
-      }
-      ix += n;
-   }
-
-   template <string_literal str, class B>
-   GLZ_ALWAYS_INLINE void dump_unchecked(B& b, auto& ix) noexcept
-   {
-      static constexpr auto s = str.sv();
-      static constexpr auto n = s.size();
-
-      if constexpr (vector_like<B>) {
-         std::memcpy(b.data() + ix, s.data(), n);
-      }
-      else {
-         std::memcpy(b + ix, s.data(), n);
+         if constexpr (Checked) {
+            const auto k = ix + n;
+            if (ix + n > b.size()) [[unlikely]] {
+               b.resize(2 * k);
+            }
+         }
       }
+      std::memcpy(&b[ix], str.data(), n);
       ix += n;
    }
 
    template <auto c, class B>
-   GLZ_ALWAYS_INLINE void dumpn(size_t n, B& b, auto& ix) noexcept
+   GLZ_ALWAYS_INLINE void dumpn(size_t n, B& b, size_t& ix) noexcept(not vector_like<B>)
    {
       if constexpr (vector_like<B>) {
-         if (ix + n > b.size()) [[unlikely]] {
-            b.resize((std::max)(b.size() * 2, ix + n));
+         const auto k = ix + n;
+         if (k > b.size()) [[unlikely]] {
+            b.resize(2 * k);
          }
-         std::memset(b.data() + ix, c, n);
-      }
-      else {
-         std::memset(b + ix, c, n);
       }
+      std::memset(&b[ix], c, n);
       ix += n;
    }
 
    template <auto c, class B>
-   GLZ_ALWAYS_INLINE void dumpn_unchecked(size_t n, B& b, auto& ix) noexcept
+   GLZ_ALWAYS_INLINE void dumpn_unchecked(size_t n, B& b, size_t& ix) noexcept
    {
-      if constexpr (vector_like<B>) {
-         std::memset(b.data() + ix, c, n);
-      }
-      else {
-         std::memset(b + ix, c, n);
-      }
+      std::memset(&b[ix], c, n);
       ix += n;
    }
 
    template <char IndentChar, class B>
-   GLZ_ALWAYS_INLINE void dump_newline_indent(size_t n, B& b, auto& ix) noexcept
+   GLZ_ALWAYS_INLINE void dump_newline_indent(size_t n, B& b, size_t& ix) noexcept(not vector_like<B>)
    {
       if constexpr (vector_like<B>) {
          if (const auto k = ix + n + write_padding_bytes; k > b.size()) [[unlikely]] {
-            b.resize((std::max)(b.size() * 2, k));
+            b.resize(2 * k);
          }
       }
 
       assign_maybe_cast<'\n'>(b, ix);
       ++ix;
-      if constexpr (vector_like<B>) {
-         std::memset(b.data() + ix, IndentChar, n);
-      }
-      else {
-         std::memset(b + ix, IndentChar, n);
-      }
+      std::memset(&b[ix], IndentChar, n);
       ix += n;
    }
 
-   template <const sv& str, class B>
-   GLZ_ALWAYS_INLINE void dump(B& b, auto& ix) noexcept
+   template <const sv& str, bool Checked = true, class B>
+   GLZ_ALWAYS_INLINE void dump(B& b, size_t& ix) noexcept(not vector_like<B> && not Checked)
    {
       static constexpr auto s = str;
       static constexpr auto n = s.size();
 
       if constexpr (vector_like<B>) {
-         if (ix + n > b.size()) [[unlikely]] {
-            b.resize((std::max)(b.size() * 2, ix + n));
+         if constexpr (Checked) {
+            const auto k = ix + n;
+            if (k > b.size()) [[unlikely]] {
+               b.resize(2 * k);
+            }
          }
-         std::memcpy(b.data() + ix, s.data(), n);
-      }
-      else {
-         std::memcpy(b + ix, s.data(), n);
       }
+      std::memcpy(&b[ix], s.data(), n);
       ix += n;
    }
 
-   template <const sv& str, class B>
-   GLZ_ALWAYS_INLINE void dump_unchecked(B& b, auto& ix) noexcept
-   {
-      static constexpr auto s = str;
-      static constexpr auto n = s.size();
-
-      if constexpr (vector_like<B>) {
-         std::memcpy(b.data() + ix, s.data(), n);
-      }
-      else {
-         std::memcpy(b + ix, s.data(), n);
-      }
-      ix += n;
-   }
-
-   template <class B>
-   GLZ_ALWAYS_INLINE void dump_not_empty(const sv str, B& b, auto& ix) noexcept
+   template <bool Checked = true, class B>
+   GLZ_ALWAYS_INLINE void dump_not_empty(const sv str, B& b, size_t& ix) noexcept(not vector_like<B> && not Checked)
    {
       const auto n = str.size();
       if constexpr (vector_like<B>) {
-         if (ix + n > b.size()) [[unlikely]] {
-            b.resize((std::max)(b.size() * 2, ix + n));
+         if constexpr (Checked) {
+            const auto k = ix + n;
+            if (k > b.size()) [[unlikely]] {
+               b.resize(2 * k);
+            }
          }
-         std::memcpy(b.data() + ix, str.data(), n);
-      }
-      else {
-         std::memcpy(b + ix, str.data(), n);
       }
+      std::memcpy(&b[ix], str.data(), n);
       ix += n;
    }
 
-   template <class B>
-   GLZ_ALWAYS_INLINE void dump_maybe_empty(const sv str, B& b, auto& ix) noexcept
+   template <bool Checked = true, class B>
+   GLZ_ALWAYS_INLINE void dump_maybe_empty(const sv str, B& b, size_t& ix) noexcept(not vector_like<B> && not Checked)
    {
       const auto n = str.size();
       if (n) {
          if constexpr (vector_like<B>) {
-            if (ix + n > b.size()) [[unlikely]] {
-               b.resize((std::max)(b.size() * 2, ix + n));
+            if constexpr (Checked) {
+               const auto k = ix + n;
+               if (k > b.size()) [[unlikely]] {
+                  b.resize(2 * k);
+               }
             }
-            std::memcpy(b.data() + ix, str.data(), n);
-         }
-         else {
-            std::memcpy(b + ix, str.data(), n);
          }
+         std::memcpy(&b[ix], str.data(), n);
          ix += n;
       }
    }
 
    template <class B>
-   GLZ_ALWAYS_INLINE void dump(const vector_like auto& bytes, B& b, auto& ix) noexcept
+   GLZ_ALWAYS_INLINE void dump(const vector_like auto& bytes, B& b, size_t& ix) noexcept(not vector_like<B>)
    {
       const auto n = bytes.size();
       if constexpr (vector_like<B>) {
-         if (ix + n > b.size()) [[unlikely]] {
-            b.resize((std::max)(b.size() * 2, ix + n));
+         const auto k = ix + n;
+         if (k > b.size()) [[unlikely]] {
+            b.resize(2 * k);
          }
-         std::memcpy(b.data() + ix, bytes.data(), n);
-      }
-      else {
-         std::memcpy(b + ix, bytes.data(), n);
       }
+      std::memcpy(&b[ix], bytes.data(), n);
       ix += n;
    }
 
    template <size_t N, class B>
-   GLZ_ALWAYS_INLINE void dump(const std::array<uint8_t, N>& bytes, B& b, auto& ix) noexcept
+   GLZ_ALWAYS_INLINE void dump(const std::array<uint8_t, N>& bytes, B& b, size_t& ix) noexcept(not vector_like<B>)
    {
       if constexpr (vector_like<B>) {
-         if (ix + N > b.size()) [[unlikely]] {
-            b.resize((std::max)(b.size() * 2, ix + N));
+         const auto k = ix + N;
+         if (k > b.size()) [[unlikely]] {
+            b.resize(2 * k);
          }
-         std::memcpy(b.data() + ix, bytes.data(), N);
-      }
-      else {
-         std::memcpy(b + ix, bytes.data(), N);
       }
+      std::memcpy(&b[ix], bytes.data(), N);
       ix += N;
    }
 }
diff --git a/deps/saucer/include/glaze/util/expected.hpp b/deps/saucer/include/glaze/util/expected.hpp
index 43d14bd..294b3cf 100644
--- a/deps/saucer/include/glaze/util/expected.hpp
+++ b/deps/saucer/include/glaze/util/expected.hpp
@@ -1,62 +1,13 @@
-/*
- * MIT License
- *
- * Copyright (c) 2022 Rishabh Dwivedi<rishabhdwivedi17@gmail.com>
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
+// Glaze Library
+// For the license information refer to glaze.hpp
 
 #pragma once
 
-#include <utility>
-
-#ifndef GLZ_THROW_OR_ABORT
-#if __cpp_exceptions
-#define GLZ_THROW_OR_ABORT(EXC) (throw(EXC))
-#define GLZ_NOEXCEPT noexcept(false)
-#else
-#define GLZ_THROW_OR_ABORT(EXC) (std::abort())
-#define GLZ_NOEXCEPT noexcept(true)
-#endif
-#endif
-
-#if __cpp_exceptions
-#include <stdexcept>
-#endif
-
-namespace glz
-{
-   inline void glaze_error([[maybe_unused]] const char* msg) GLZ_NOEXCEPT
-   {
-      GLZ_THROW_OR_ABORT(std::runtime_error(msg));
-   }
-}
-
-#ifdef __has_include
-#if __has_include(<expected>)
+#include <concepts>
 #include <expected>
-#elif __has_include(<experimental/expected>)
-#include <experimental/expected>
-#endif
-#endif
+#include <utility>
+#include <version>
 
-#if defined(__cpp_lib_expected)
 namespace glz
 {
    template <class Expected, class Unexpected>
@@ -78,1448 +29,4 @@ namespace glz
    template <class Unexpected>
    using unexpected = std::unexpected<Unexpected>;
 #endif
-}
-#else
-
-#include <concepts>
-#include <deque>
-#include <exception>
-#include <functional>
-#include <memory>
-#include <type_traits>
-#include <variant>
-
-namespace glz
-{
-
-   template <class E>
-   class unexpected
-   {
-     public:
-      using value_type = E;
-      constexpr unexpected(const unexpected&) = default;
-      constexpr unexpected(unexpected&&) = default; // NOLINT
-      constexpr auto operator=(const unexpected&) -> unexpected& = default;
-      constexpr auto operator=(unexpected&&) -> unexpected& = default; // NOLINT
-      ~unexpected() = default;
-
-      template <class... Args>
-         requires std::constructible_from<E, Args...>
-      constexpr explicit unexpected(std::in_place_t /*unused*/, Args&&... args) : val(std::forward<Args>(args)...)
-      {}
-
-      template <class U, class... Args>
-         requires std::constructible_from<E, std::initializer_list<U>&, Args...>
-      constexpr explicit unexpected(std::in_place_t /*unused*/, std::initializer_list<U> i_list, Args&&... args)
-         : val(i_list, std::forward<Args>(args)...)
-      {}
-
-      template <class Err = E>
-         requires(!std::same_as<std::remove_cvref_t<Err>, unexpected>) &&
-                 (!std::same_as<std::remove_cvref_t<Err>, std::in_place_t>) && std::constructible_from<E, Err>
-      constexpr explicit unexpected(Err&& err) // NOLINT
-         : val(std::forward<Err>(err))
-      {}
-
-      constexpr auto value() const& noexcept -> const E& { return val; }
-      constexpr auto value() & noexcept -> E& { return val; }
-      constexpr auto value() const&& noexcept -> const E&& { return std::move(val); }
-      constexpr auto value() && noexcept -> E&& { return std::move(val); }
-
-      constexpr void swap(unexpected& other) noexcept(std::is_nothrow_swappable_v<E>)
-         requires(std::is_swappable_v<E>)
-      {
-         using std::swap;
-         swap(val, other.val);
-      }
-
-      template <class E2>
-         requires(requires(const E& x, E2 const& y) {
-            {
-               x == y
-            } -> std::convertible_to<bool>;
-         })
-      friend constexpr auto operator==(const unexpected& x, const unexpected<E2>& y) -> bool
-      {
-         return x.value() == y.value();
-      }
-
-      friend constexpr void swap(unexpected& x, unexpected& y) noexcept(noexcept(x.swap(y)))
-         requires(std::is_swappable_v<E>)
-      {
-         x.swap(y);
-      }
-
-     private:
-      E val;
-   };
-
-   template <class E>
-   unexpected(E) -> unexpected<E>;
-
-   template <class E>
-   class bad_expected_access;
-
-   template <>
-   class bad_expected_access<void> : public std::exception
-   {
-     protected:
-      bad_expected_access() noexcept = default;
-      bad_expected_access(const bad_expected_access&) = default;
-      bad_expected_access(bad_expected_access&&) = default;
-      auto operator=(const bad_expected_access&) -> bad_expected_access& = default;
-      auto operator=(bad_expected_access&&) -> bad_expected_access& = default;
-      ~bad_expected_access() override = default;
-
-     public:
-      auto what() const noexcept -> const char* override
-      { // NOLINT
-         return "bad expected access";
-      }
-   };
-
-   template <class E>
-   class bad_expected_access : public bad_expected_access<void>
-   {
-     public:
-      explicit bad_expected_access(E e) : val(std::move(e)) {}
-      auto what() const noexcept -> const char* override
-      { // NOLINT
-         return "bad expected access";
-      }
-
-      auto error() & noexcept -> E& { return val; }
-      auto error() const& noexcept -> const E& { return val; }
-      auto error() && noexcept -> E&& { return std::move(val); }
-      auto error() const&& noexcept -> const E&& { return std::move(val); }
-
-     private:
-      E val;
-   };
-
-   struct unexpect_t
-   {};
-   inline constexpr unexpect_t unexpect{};
-
-   namespace detail
-   {
-      template <typename T>
-      concept non_void_destructible = std::same_as<T, void> || std::destructible<T>;
-   }
-
-   template <detail::non_void_destructible T, std::destructible E>
-   class expected;
-
-   namespace detail
-   {
-      template <typename T, typename E, typename U, typename G, typename UF, typename GF>
-      concept expected_constructible_from_other =
-         std::constructible_from<T, UF> && std::constructible_from<E, GF> &&
-         (!std::constructible_from<T, expected<U, G>&>)&&(!std::constructible_from<T, expected<U, G> >)&&(!std::constructible_from<T, const expected<U, G>&>)&&(
-            !std::constructible_from<
-               T,
-               const expected<
-                  U,
-                  G> >)&&(!std::
-                             convertible_to<
-                                expected<U, G>&,
-                                T>)&&(!std::
-                                         convertible_to<
-                                            expected<U, G>&&,
-                                            T>)&&(!std::
-                                                     convertible_to<
-                                                        const expected<U, G>&,
-                                                        T>)&&(!std::
-                                                                 convertible_to<
-                                                                    const expected<U, G>&&,
-                                                                    T>)&&(!std::
-                                                                             constructible_from<
-                                                                                unexpected<E>,
-                                                                                expected<
-                                                                                   U,
-                                                                                   G>&>)&&(!std::
-                                                                                              constructible_from<
-                                                                                                 unexpected<E>,
-                                                                                                 expected<
-                                                                                                    U,
-                                                                                                    G> >)&&(!std::
-                                                                                                               constructible_from<
-                                                                                                                  unexpected<
-                                                                                                                     E>,
-                                                                                                                  const expected<
-                                                                                                                     U,
-                                                                                                                     G>&>)&&(!std::
-                                                                                                                                constructible_from<
-                                                                                                                                   unexpected<
-                                                                                                                                      E>,
-                                                                                                                                   const expected<
-                                                                                                                                      U,
-                                                                                                                                      G> >);
-
-      template <typename T>
-      concept is_unexpected = std::same_as<std::remove_cvref_t<T>, unexpected<typename T::value_type> >;
-
-      template <typename T>
-      concept is_expected =
-         std::same_as<std::remove_cvref_t<T>, expected<typename T::value_type, typename T::error_type> >;
-
-      // This function makes sure expected doesn't get into valueless_by_exception
-      // state due to any exception while assignment
-      template <class T, class U, class... Args>
-      constexpr void reinit_expected(T& newval, U& oldval, Args&&... args)
-      {
-         if constexpr (std::is_nothrow_constructible_v<T, Args...>) {
-            std::destroy_at(std::addressof(oldval));
-            std::construct_at(std::addressof(newval), std::forward<Args>(args)...);
-         }
-         else if constexpr (std::is_nothrow_move_constructible_v<T>) {
-            T tmp(std::forward<Args>(args)...);
-            std::destroy_at(std::addressof(oldval));
-            std::construct_at(std::addressof(newval), std::move(tmp));
-         }
-         else {
-            U tmp(std::move(oldval));
-            std::destroy_at(std::addressof(oldval));
-#if __cpp_exceptions
-            try {
-               std::construct_at(std::addressof(newval), std::forward<Args>(args)...);
-            }
-            catch (...) {
-               std::construct_at(std::addressof(oldval), std::move(tmp));
-               throw;
-            }
-#else
-            std::abort();
-#endif
-         }
-      }
-
-   } // namespace detail
-
-   template <detail::non_void_destructible T, std::destructible E>
-   class expected
-   {
-     public:
-      using value_type = T;
-      using error_type = E;
-      using unexpected_type = unexpected<E>;
-
-      template <class U>
-      using rebind = expected<U, error_type>;
-
-      // constructors
-      // postcondition: has_value() = true
-      constexpr expected()
-         requires std::default_initializable<T>
-         : val{} {};
-
-      // postcondition: has_value() = rhs.has_value()
-      constexpr expected(const expected& rhs)
-         requires std::copy_constructible<T> && std::copy_constructible<E> &&
-                     std::is_trivially_copy_constructible_v<T> && std::is_trivially_copy_constructible_v<E>
-      = default;
-
-      // postcondition: has_value() = rhs.has_value()
-      constexpr expected(const expected& rhs)
-         requires std::copy_constructible<T> && std::copy_constructible<E>
-         : has_val(rhs.has_val)
-      {
-         if (rhs.has_value()) {
-            std::construct_at(std::addressof(this->val), *rhs);
-         }
-         else {
-            std::construct_at(std::addressof(this->unex), rhs.error());
-         }
-      }
-
-      constexpr expected(expected&&) noexcept(
-         std::is_nothrow_move_constructible_v<T>&& std::is_nothrow_move_constructible_v<T>)
-         requires std::move_constructible<T> && std::move_constructible<E> &&
-                     std::is_trivially_move_constructible_v<T> && std::is_trivially_move_constructible_v<E>
-      = default;
-
-      constexpr expected(expected&& rhs) noexcept(
-         std::is_nothrow_move_constructible_v<T>&& std::is_nothrow_move_constructible_v<T>)
-         requires std::move_constructible<T> && std::move_constructible<E>
-         : has_val(rhs.has_value())
-      {
-         if (rhs.has_value()) {
-            std::construct_at(std::addressof(this->val), std::move(*rhs));
-         }
-         else {
-            std::construct_at(std::addressof(this->unex), std::move(rhs.error()));
-         }
-      }
-
-      template <class U, class G>
-         requires detail::expected_constructible_from_other<T, E, U, G, const U&, const G&>
-      constexpr explicit(!std::convertible_to<const U&, T> || !std::convertible_to<const G&, E>)
-         expected(const expected<U, G>& rhs) // NOLINT
-         : has_val(rhs.has_value())
-      {
-         using UF = const U&;
-         using GF = const G&;
-         if (rhs.has_value()) {
-            std::construct_at(std::addressof(this->val), std::forward<UF>(*rhs));
-         }
-         else {
-            std::construct_at(std::addressof(this->unex), std::forward<GF>(rhs.error()));
-         }
-      }
-
-      template <class U, class G>
-         requires detail::expected_constructible_from_other<T, E, U, G, U, G>
-      constexpr explicit(!std::convertible_to<U, T> || !std::convertible_to<G, E>)
-         expected(expected<U, G>&& rhs) // NOLINT
-         : has_val(rhs.has_value())
-      {
-         using UF = const U&;
-         using GF = const G&;
-         if (rhs.has_value()) {
-            std::construct_at(std::addressof(this->val), std::forward<UF>(*rhs));
-         }
-         else {
-            std::construct_at(std::addressof(this->unex), std::forward<GF>(rhs.error()));
-         }
-      }
-
-      template <class U = T>
-         requires(!std::same_as<std::remove_cvref_t<U>, std::in_place_t>) &&
-                 (!std::same_as<expected<T, E>, std::remove_cvref_t<U> >) &&
-                 (!detail::is_unexpected<U>) && std::constructible_from<T, U>
-      constexpr explicit(!std::convertible_to<U, T>) expected(U&& v) // NOLINT
-         : val(std::forward<U>(v))
-      {}
-
-      template <class G>
-         requires std::constructible_from<E, const G&>
-      constexpr explicit(!std::convertible_to<const G&, E>) expected(const unexpected<G>& e) // NOLINT
-         : has_val{false}, unex(std::forward<const G&>(e.value()))
-      {}
-
-      template <class G>
-         requires std::constructible_from<E, G>
-      constexpr explicit(!std::convertible_to<G, E>) expected(unexpected<G>&& e) // NOLINT
-         : has_val{false}, unex(std::forward<G>(e.value()))
-      {}
-
-      template <class... Args>
-         requires std::constructible_from<T, Args...>
-      constexpr explicit expected(std::in_place_t /*unused*/, Args&&... args) : val(std::forward<Args>(args)...)
-      {}
-
-      template <class U, class... Args>
-         requires std::constructible_from<T, std::initializer_list<U>&, Args...>
-      constexpr explicit expected(std::in_place_t /*unused*/, std::initializer_list<U> il, Args&&... args)
-         : val(il, std::forward<Args>(args)...)
-      {}
-
-      template <class... Args>
-         requires std::constructible_from<E, Args...>
-      constexpr explicit expected(unexpect_t /*unused*/, Args&&... args)
-         : has_val{false}, unex(std::forward<Args>(args)...)
-      {}
-
-      template <class U, class... Args>
-         requires std::constructible_from<E, std::initializer_list<U>&, Args...>
-      constexpr explicit expected(unexpect_t /*unused*/, std::initializer_list<U> il, Args&&... args)
-         : has_val(false), unex(il, std::forward<Args>(args)...)
-      {}
-
-      // destructor
-      constexpr ~expected()
-      {
-         if constexpr (std::is_trivially_destructible_v<T> and std::is_trivially_destructible_v<E>) {
-         }
-         else if constexpr (std::is_trivially_destructible_v<T>) {
-            if (!has_val) {
-               std::destroy_at(std::addressof(this->unex));
-            }
-         }
-         else if constexpr (std::is_trivially_destructible_v<E>) {
-            if (has_val) {
-               std::destroy_at(std::addressof(this->val));
-            }
-         }
-         else {
-            if (has_val) {
-               std::destroy_at(std::addressof(this->val));
-            }
-            else {
-               std::destroy_at(std::addressof(this->unex));
-            }
-         }
-      }
-
-      // assignment
-      constexpr auto operator=(const expected& rhs) // NOLINT
-         -> expected&
-         requires std::is_copy_assignable_v<T> && std::is_copy_constructible_v<T> && std::is_copy_assignable_v<E> &&
-                  std::is_copy_constructible_v<E> &&
-                  (std::is_nothrow_move_constructible_v<E> || std::is_nothrow_move_constructible_v<T>)
-      {
-         has_val = rhs.has_value();
-         if (this->has_value() and rhs.has_value()) {
-            this->val = *rhs;
-         }
-         else if (this->has_value()) {
-            detail::reinit_expected(this->unex, this->val, rhs.error());
-         }
-         else if (rhs.has_value()) {
-            detail::reinit_expected(this->val, this->unex, *rhs);
-         }
-         else {
-            this->unex = rhs.error();
-         }
-         return *this;
-      }
-
-      constexpr auto operator=(expected&& rhs) //
-         noexcept(std::is_nothrow_move_assignable_v<T>&& std::is_nothrow_move_constructible_v<T>&&
-                     std::is_nothrow_move_assignable_v<E>&& std::is_nothrow_move_constructible_v<E>) -> expected&
-         requires std::is_move_constructible_v<T> && std::is_move_assignable_v<T> && std::is_move_constructible_v<E> &&
-                  std::is_move_assignable_v<E> &&
-                  (std::is_nothrow_move_constructible_v<T> || std::is_nothrow_move_constructible_v<E>)
-      {
-         has_val = rhs.has_value();
-         if (this->has_value() and rhs.has_value()) {
-            this->val = std::move(*rhs);
-         }
-         else if (this->has_value()) {
-            detail::reinit_expected(this->unex, this->val, std::move(rhs.error()));
-         }
-         else if (rhs.has_value()) {
-            detail::reinit_expected(this->val, this->unex, std::move(*rhs));
-         }
-         else {
-            this->unex = std::move(rhs.error());
-         }
-         return *this;
-      }
-
-      template <class U = T>
-         constexpr auto operator=(U&& rhs) -> expected& requires(!std::same_as<expected, std::remove_cvref_t<U> >) &&
-         (!detail::is_unexpected<std::remove_cvref_t<U> >)&&std::constructible_from<T, U>&& std::is_assignable_v<T&,
-                                                                                                                 U> &&
-         (std::is_nothrow_constructible_v<T, U> || std::is_nothrow_move_constructible_v<T> ||
-          std::is_nothrow_move_constructible_v<E>)
-      {
-         if (this->has_value()) {
-            this->val = std::forward<U>(rhs);
-            return *this;
-         }
-         detail::reinit_expected(this->val, this->unex, std::forward<U>(rhs));
-         has_val = true;
-         return *this;
-      }
-
-      template <class G>
-         requires std::constructible_from<E, const G&> && std::is_assignable_v<E&, const G&> &&
-                  (std::is_nothrow_constructible_v<E, const G&> || std::is_nothrow_move_constructible_v<T> ||
-                   std::is_nothrow_move_constructible_v<E>)
-      constexpr auto operator=(const unexpected<G>& e) -> expected&
-      {
-         using GF = const G&;
-         if (has_value()) {
-            detail::reinit_expected(this->unex, this->val, std::forward<GF>(e.value()));
-         }
-         else {
-            this->unex = std::forward<GF>(e.value());
-         }
-         has_val = false;
-         return *this;
-      }
-
-      template <class G>
-         requires std::constructible_from<E, G> && std::is_assignable_v<E&, G> &&
-                  (std::is_nothrow_constructible_v<E, G> || std::is_nothrow_move_constructible_v<T> ||
-                   std::is_nothrow_move_constructible_v<E>)
-      constexpr auto operator=(unexpected<G>&& e) -> expected&
-      {
-         using GF = G;
-         if (has_value()) {
-            detail::reinit_expected(this->unex, this->val, std::forward<GF>(e.value()));
-         }
-         else {
-            this->unex = std::forward<GF>(e.value());
-         }
-         has_val = false;
-         return *this;
-      }
-
-      // modifiers
-      template <class... Args>
-         requires std::is_nothrow_constructible_v<T, Args...>
-      constexpr auto emplace(Args&&... args) noexcept -> T&
-      {
-         if (has_value()) {
-            std::destroy_at(std::addressof(this->val));
-         }
-         else {
-            std::destroy_at(std::addressof(this->unex));
-            has_val = true;
-         }
-         return *std::construct_at(std::addressof(this->val), std::forward<Args>(args)...);
-      }
-
-      template <class U, class... Args>
-         requires std::is_nothrow_constructible_v<T, std::initializer_list<U>&, Args...>
-      constexpr auto emplace(std::initializer_list<U> il, Args&&... args) noexcept -> T&
-      {
-         if (has_value()) {
-            std::destroy_at(std::addressof(this->val));
-         }
-         else {
-            std::destroy_at(std::addressof(this->unex));
-            has_val = true;
-         }
-         return *std::construct_at(std::addressof(this->val), il, std::forward<Args>(args)...);
-      }
-
-      // swap
-      constexpr void swap(expected& rhs) noexcept(
-         std::is_nothrow_constructible_v<T>&& std::is_nothrow_swappable_v<T>&& std::is_nothrow_move_constructible_v<E>&&
-            std::is_nothrow_swappable_v<E>)
-         requires std::is_swappable_v<T> && std::is_swappable_v<E> && std::is_move_constructible_v<T> &&
-                  std::is_move_constructible_v<E> &&
-                  (std::is_nothrow_constructible_v<T> || std::is_nothrow_constructible_v<E>)
-      {
-         if (rhs.has_value()) {
-            if (has_value()) {
-               using std::swap;
-               swap(this->val, rhs.val);
-            }
-            else {
-               rhs.swap(*this);
-            }
-         }
-         else {
-            if (has_value()) {
-               if constexpr (std::is_nothrow_move_constructible_v<E>) {
-                  E tmp(std::move(rhs.unex));
-                  std::destroy_at(std::addressof(rhs.unex));
-#if __cpp_exceptions
-                  try {
-                     std::construct_at(std::addressof(rhs.val), std::move(this->val));
-                     std::destroy_at(std::addressof(this->val));
-                     std::construct_at(std::addressof(this->unex), std::move(tmp));
-                  }
-                  catch (...) {
-                     std::construct_at(std::addressof(rhs.unex), std::move(tmp));
-                     throw;
-                  }
-#else
-                  std::abort();
-#endif
-               }
-               else {
-                  T tmp(std::move(this->val));
-                  std::destroy_at(std::addressof(this->val));
-#if __cpp_exceptions
-                  try {
-                     std::construct_at(std::addressof(this->unex), std::move(rhs.unex));
-                     std::destroy_at(std::addressof(rhs.unex));
-                     std::construct_at(std::addressof(rhs.val), std::move(tmp));
-                  }
-                  catch (...) {
-                     std::construct_at(std::addressof(this->val), std::move(tmp));
-                     throw;
-                  }
-#else
-                  std::abort();
-#endif
-               }
-               has_val = false;
-               rhs.has_val = true;
-            }
-            else {
-               using std::swap;
-               swap(this->unex, rhs.unex);
-            }
-         }
-      }
-
-      // observers
-
-      // precondition: has_value() = true
-      constexpr auto operator->() const noexcept -> const T* { return std::addressof(this->val); }
-
-      // precondition: has_value() = true
-      constexpr auto operator->() noexcept -> T* { return std::addressof(this->val); }
-
-      // precondition: has_value() = true
-      constexpr auto operator*() const& noexcept -> const T& { return this->val; }
-
-      // precondition: has_value() = true
-      constexpr auto operator*() & noexcept -> T& { return this->val; }
-
-      // precondition: has_value() = true
-      constexpr auto operator*() const&& noexcept -> const T&& { return std::move(this->val); }
-
-      // precondition: has_value() = true
-      constexpr auto operator*() && noexcept -> T&& { return std::move(this->val); }
-
-      constexpr explicit operator bool() const noexcept { return has_val; }
-
-      [[nodiscard]] constexpr auto has_value() const noexcept -> bool { return has_val; }
-
-      constexpr auto value() const& -> const T&
-      {
-         if (has_value()) {
-            return this->val;
-         }
-         GLZ_THROW_OR_ABORT(bad_expected_access(error()));
-      }
-
-      constexpr auto value() & -> T&
-      {
-         if (has_value()) {
-            return this->val;
-         }
-         GLZ_THROW_OR_ABORT(bad_expected_access(error()));
-      }
-
-      constexpr auto value() const&& -> const T&&
-      {
-         if (has_value()) {
-            return std::move(this->val);
-         }
-         GLZ_THROW_OR_ABORT(bad_expected_access(std::move(error())));
-      }
-
-      constexpr auto value() && -> T&&
-      {
-         if (has_value()) {
-            return std::move(this->val);
-         }
-         GLZ_THROW_OR_ABORT(bad_expected_access(std::move(error())));
-      }
-
-      // precondition: has_value() = false
-      constexpr auto error() const& -> const E& { return this->unex; }
-
-      // precondition: has_value() = false
-      constexpr auto error() & -> E& { return this->unex; }
-
-      // precondition: has_value() = false
-      constexpr auto error() const&& -> const E&& { return std::move(this->unex); }
-
-      // precondition: has_value() = false
-      constexpr auto error() && -> E&& { return std::move(this->unex); }
-
-      template <class U>
-         requires std::is_copy_constructible_v<T> && std::is_convertible_v<U, T>
-      constexpr auto value_or(U&& v) const& -> T
-      {
-         return has_value() ? **this : static_cast<T>(std::forward<U>(v));
-      }
-
-      template <class U>
-         requires std::is_move_constructible_v<T> && std::is_convertible_v<U, T>
-      constexpr auto value_or(U&& v) && -> T
-      {
-         return has_value() ? std::move(**this) : static_cast<T>(std::forward<U>(v));
-      }
-
-      template <class F, class V = T&, class U = std::remove_cvref_t<std::invoke_result_t<F, V> > >
-         requires detail::is_expected<U> && std::is_same_v<typename U::error_type, E> &&
-                  std::is_copy_constructible_v<E> && std::is_copy_constructible_v<T>
-      constexpr auto and_then(F&& f) &
-      {
-         if (has_value()) {
-            return std::invoke(std::forward<F>(f), **this);
-         }
-         return U(unexpect, error());
-      }
-
-      template <class F, class V = const T&, class U = std::remove_cvref_t<std::invoke_result_t<F, V> > >
-         requires detail::is_expected<U> && std::is_same_v<typename U::error_type, E> &&
-                  std::is_copy_constructible_v<E> && std::is_copy_constructible_v<T>
-      constexpr auto and_then(F&& f) const&
-      {
-         if (has_value()) {
-            return std::invoke(std::forward<F>(f), **this);
-         }
-         return U(unexpect, error());
-      }
-
-      template <class F, class V = T&&, class U = std::remove_cvref_t<std::invoke_result_t<F, V> > >
-         requires detail::is_expected<U> && std::is_same_v<typename U::error_type, E> &&
-                  std::is_move_constructible_v<E> && std::is_move_constructible_v<T>
-      constexpr auto and_then(F&& f) &&
-      {
-         if (has_value()) {
-            return std::invoke(std::forward<F>(f), std::move(**this));
-         }
-         return U(unexpect, std::move(error()));
-      }
-
-      template <class F, class V = const T&&, class U = std::remove_cvref_t<std::invoke_result_t<F, V> > >
-         requires detail::is_expected<U> && std::is_same_v<typename U::error_type, E> &&
-                  std::is_move_constructible_v<E> && std::is_move_constructible_v<T>
-      constexpr auto and_then(F&& f) const&&
-      {
-         if (has_value()) {
-            return std::invoke(std::forward<F>(f), std::move(**this));
-         }
-         return U(unexpect, std::move(error()));
-      }
-
-      template <class F, class V = E&, class G = std::remove_cvref_t<std::invoke_result_t<F, V> > >
-         requires detail::is_expected<G> && std::is_same_v<typename G::value_type, T> &&
-                  std::is_copy_constructible_v<T> && std::is_copy_constructible_v<E>
-      constexpr auto or_else(F&& f) &
-      {
-         if (has_value()) {
-            return G(**this);
-         }
-         return std::invoke(std::forward<F>(f), error());
-      }
-
-      template <class F, class V = const E&, class G = std::remove_cvref_t<std::invoke_result_t<F, V> > >
-         requires detail::is_expected<G> && std::is_same_v<typename G::value_type, T> &&
-                  std::is_copy_constructible_v<T> && std::is_copy_constructible_v<E>
-      constexpr auto or_else(F&& f) const&
-      {
-         if (has_value()) {
-            return G(**this);
-         }
-         return std::invoke(std::forward<F>(f), error());
-      }
-
-      template <class F, class V = E&&, class G = std::remove_cvref_t<std::invoke_result_t<F, V> > >
-         requires detail::is_expected<G> && std::is_same_v<typename G::value_type, T> &&
-                  std::is_move_constructible_v<T> && std::is_move_constructible_v<E>
-      constexpr auto or_else(F&& f) &&
-      {
-         if (has_value()) {
-            return G(std::move(**this));
-         }
-         return std::invoke(std::forward<F>(f), std::move(error()));
-      }
-
-      template <class F, class V = const E&&, class G = std::remove_cvref_t<std::invoke_result_t<F, V> > >
-         requires detail::is_expected<G> && std::is_same_v<typename G::value_type, T> &&
-                  std::is_move_constructible_v<T> && std::is_move_constructible_v<E>
-      constexpr auto or_else(F&& f) const&&
-      {
-         if (has_value()) {
-            return G(std::move(**this));
-         }
-         return std::invoke(std::forward<F>(f), std::move(error()));
-      }
-
-      template <class F, class V = E&, class G = std::remove_cvref_t<std::invoke_result_t<F, V> > >
-         requires std::is_void_v<G> && std::is_copy_constructible_v<T> && std::is_copy_constructible_v<E>
-      constexpr auto or_else(F&& f) &
-      {
-         if (has_value()) {
-            return expected(*this);
-         }
-         std::invoke(std::forward<F>(f), error());
-         return expected(*this);
-      }
-
-      template <class F, class V = const E&, class G = std::remove_cvref_t<std::invoke_result_t<F, V> > >
-         requires std::is_void_v<G> && std::is_copy_constructible_v<T> && std::is_copy_constructible_v<E>
-      constexpr auto or_else(F&& f) const&
-      {
-         if (has_value()) {
-            return expected(*this);
-         }
-         std::invoke(std::forward<F>(f), error());
-         return expected(*this);
-      }
-
-      template <class F, class V = E&&, class G = std::remove_cvref_t<std::invoke_result_t<F, V> > >
-         requires std::is_void_v<G> && std::is_move_constructible_v<T> && std::is_move_constructible_v<E> &&
-                  std::is_copy_constructible_v<E>
-      constexpr auto or_else(F&& f) &&
-      {
-         if (has_value()) {
-            return expected(std::move(*this));
-         }
-         // TODO: is this copy necessary, as f can be just read argument function
-         std::invoke(std::forward<F>(f), error());
-         return expected(std::move(*this));
-      }
-
-      template <class F, class V = const E&&, class G = std::remove_cvref_t<std::invoke_result_t<F, V> > >
-         requires std::is_void_v<G> && std::is_move_constructible_v<T> && std::is_move_constructible_v<E> &&
-                  std::is_copy_constructible_v<E>
-      constexpr auto or_else(F&& f) const&&
-      {
-         if (!has_value()) {
-            return expected(std::move(*this));
-         }
-         // TODO: is this copy necessary, as f can be just read argument function
-         std::invoke(std::forward<F>(f), error());
-         return expected(std::move(*this));
-      }
-
-      template <class F, class V = T&, class U = std::remove_cvref_t<std::invoke_result_t<F, V> > >
-         requires std::is_copy_constructible_v<E> && std::is_copy_constructible_v<T>
-      constexpr auto transform(F&& f) &
-      {
-         if (has_value()) {
-            if constexpr (!std::same_as<U, void>) {
-               return expected<U, E>(std::invoke(std::forward<F>(f), **this));
-            }
-            else {
-               std::invoke(std::forward<F>(f), std::move(**this));
-               return expected<U, E>();
-            }
-         }
-         return expected<U, E>(unexpect, error());
-      }
-
-      template <class F, class V = const T&, class U = std::remove_cvref_t<std::invoke_result_t<F, V> > >
-         requires std::is_copy_constructible_v<E> && std::is_copy_constructible_v<T>
-      constexpr auto transform(F&& f) const&
-      {
-         if (has_value()) {
-            if constexpr (!std::same_as<U, void>) {
-               return expected<U, E>(std::invoke(std::forward<F>(f), **this));
-            }
-            else {
-               std::invoke(std::forward<F>(f), std::move(**this));
-               return expected<U, E>();
-            }
-         }
-         return expected<U, E>(unexpect, error());
-      }
-
-      template <class F, class V = T&&, class U = std::remove_cvref_t<std::invoke_result_t<F, V> > >
-         requires std::is_move_constructible_v<E> && std::is_move_constructible_v<T>
-      constexpr auto transform(F&& f) &&
-      {
-         if (has_value()) {
-            if constexpr (!std::same_as<U, void>) {
-               return expected<U, E>(std::invoke(std::forward<F>(f), std::move(**this)));
-            }
-            else {
-               std::invoke(std::forward<F>(f), std::move(**this));
-               return expected<U, E>();
-            }
-         }
-         return expected<U, E>(unexpect, std::move(error()));
-      }
-
-      template <class F, class V = const T&&, class U = std::remove_cvref_t<std::invoke_result_t<F, V> > >
-         requires std::is_move_constructible_v<E> && std::is_move_constructible_v<T>
-      constexpr auto transform(F&& f) const&&
-      {
-         if (has_value()) {
-            if constexpr (!std::same_as<U, void>) {
-               return expected<U, E>(std::invoke(std::forward<F>(f), std::move(**this)));
-            }
-            else {
-               std::invoke(std::forward<F>(f), std::move(**this));
-               return expected<U, E>();
-            }
-         }
-         return expected<U, E>(unexpect, std::move(error()));
-      }
-
-      template <class F, class V = E&, class G = std::remove_cvref_t<std::invoke_result_t<F, V> > >
-         requires std::is_copy_constructible_v<T> && std::is_copy_constructible_v<E>
-      constexpr auto transform_error(F&& f) &
-      {
-         if (has_value()) {
-            return expected<T, G>(**this);
-         }
-         return expected<T, G>(unexpect, std::invoke(std::forward<F>(f), error()));
-      }
-
-      template <class F, class V = const E&, class G = std::remove_cvref_t<std::invoke_result_t<F, V> > >
-         requires std::is_copy_constructible_v<T> && std::is_copy_constructible_v<E>
-      constexpr auto transform_error(F&& f) const&
-      {
-         if (has_value()) {
-            return expected<T, G>(**this);
-         }
-         return expected<T, G>(unexpect, std::invoke(std::forward<F>(f), error()));
-      }
-
-      template <class F, class V = E&&, class G = std::remove_cvref_t<std::invoke_result_t<F, V> > >
-         requires std::is_move_constructible_v<T> && std::is_move_constructible_v<E>
-      constexpr auto transform_error(F&& f) &&
-      {
-         if (has_value()) {
-            return expected<T, G>(std::move(**this));
-         }
-         return expected<T, G>(unexpect, std::invoke(std::forward<F>(f), std::move(error())));
-      }
-
-      template <class F, class V = const E&&, class G = std::remove_cvref_t<std::invoke_result_t<F, V> > >
-         requires std::is_move_constructible_v<T> && std::is_move_constructible_v<E>
-      constexpr auto transform_error(F&& f) const&&
-      {
-         if (has_value()) {
-            return expected<T, G>(std::move(**this));
-         }
-         return expected<T, G>(unexpect, std::invoke(std::forward<F>(f), std::move(error())));
-      }
-
-      // equality operators
-      template <class T2, class E2>
-         requires(!std::is_void_v<T2>) && requires(const T& t1, T2 const& t2, const E& e1, E2 const& e2) {
-            {
-               t1 == t2
-            } -> std::convertible_to<bool>;
-            {
-               e1 == e2
-            } -> std::convertible_to<bool>;
-         }
-      friend constexpr auto operator==(const expected& x, const expected<T2, E2>& y) -> bool
-      {
-         if (x.has_value() != y.has_value()) {
-            return false;
-         }
-         return x.has_value() ? (*x == *y) : (x.error() == y.error());
-      }
-
-      template <typename T2>
-         requires(!detail::is_expected<T2>)
-      friend constexpr bool operator==(const expected& x, const T2& v)
-      {
-         return x.has_value() && bool(*x == v);
-      }
-
-      template <class E2>
-         requires requires(const E& x, const unexpected<E2>& e) {
-            {
-               x == e.value()
-            } -> std::convertible_to<bool>;
-         }
-      friend constexpr auto operator==(const expected& x, const unexpected<E2>& e) -> bool
-      {
-         return !x.has_value() && bool(x.error() == e.value());
-      }
-
-      // specialized algorithms
-      friend constexpr void swap(expected& x, expected& y) noexcept(noexcept(x.swap(y))) { x.swap(y); }
-
-     private:
-      bool has_val{true};
-      union {
-         T val;
-         E unex;
-      };
-   };
-
-   template <std::destructible E>
-   class expected<void, E>
-   {
-     public:
-      using value_type = void;
-      using error_type = E;
-      using unexpected_type = unexpected<E>;
-
-      template <class U>
-      using rebind = expected<U, error_type>;
-
-      // constructors
-
-      // postcondition: has_value() = true
-      constexpr expected() noexcept {} // NOLINT
-
-      constexpr expected(const expected& rhs)
-         requires std::is_copy_constructible_v<E> && std::is_trivially_copy_constructible_v<E>
-      = default;
-
-      constexpr expected(const expected& rhs)
-         requires std::is_copy_constructible_v<E>
-         : has_val(rhs.has_value())
-      {
-         if (!rhs.has_value()) {
-            std::construct_at(std::addressof(this->unex), rhs.error());
-         }
-      }
-
-      constexpr expected(expected&&) noexcept(std::is_nothrow_move_constructible_v<E>)
-         requires std::is_move_constructible_v<E> && std::is_trivially_move_constructible_v<E>
-      = default;
-
-      constexpr expected(expected&& rhs) noexcept(std::is_nothrow_move_constructible_v<E>)
-         requires std::is_move_constructible_v<E>
-         : has_val(rhs.has_value())
-      {
-         if (!rhs.has_value()) {
-            std::construct_at(std::addressof(this->unex), std::move(rhs.error()));
-         }
-      }
-
-      template <class U, class G>
-         requires std::is_void_v<U> && std::is_constructible_v<E, const G&> &&
-                  (!std::is_constructible_v<unexpected<E>, expected<U, G>&>) &&
-                  (!std::is_constructible_v<unexpected<E>, expected<U, G> >) &&
-                  (!std::is_constructible_v<unexpected<E>, const expected<U, G>&>) &&
-                  (!std::is_constructible_v<unexpected<E>, const expected<U, G>&>)
-      constexpr explicit(!std::is_convertible_v<const G&, E>) expected(const expected<U, G>& rhs) // NOLINT
-         : has_val(rhs.has_value())
-      {
-         if (!rhs.has_value()) {
-            std::construct_at(std::addressof(this->unex), std::forward<const G&>(rhs.error()));
-         }
-      }
-
-      template <class U, class G>
-         requires std::is_void_v<U> && std::is_constructible_v<E, G> &&
-                  (!std::is_constructible_v<unexpected<E>, expected<U, G>&>) &&
-                  (!std::is_constructible_v<unexpected<E>, expected<U, G> >) &&
-                  (!std::is_constructible_v<unexpected<E>, const expected<U, G>&>) &&
-                  (!std::is_constructible_v<unexpected<E>, const expected<U, G>&>)
-      constexpr explicit(!std::is_convertible_v<const G&, E>) expected(expected<U, G>&& rhs) // NOLINT
-         : has_val(rhs.has_value())
-      {
-         if (!rhs.has_value()) {
-            std::construct_at(std::addressof(this->unex), std::forward<G>(rhs.error()));
-         }
-      }
-
-      template <class G>
-         requires std::is_constructible_v<E, const G&>
-      constexpr explicit(!std::is_convertible_v<const G&, E>) expected(const unexpected<G>& e) // NOLINT
-         : has_val(false), unex(std::forward<const G&>(e.value()))
-      {}
-
-      template <class G>
-         requires std::is_constructible_v<E, G>
-      constexpr explicit(!std::is_convertible_v<G, E>) expected(unexpected<G>&& e) // NOLINT
-         : has_val(false), unex(std::forward<G>(e.value()))
-      {}
-
-      constexpr explicit expected(std::in_place_t /*unused*/) noexcept {}
-
-      template <class... Args>
-         requires std::is_constructible_v<E, Args...>
-      constexpr explicit expected(unexpect_t /*unused*/, Args&&... args)
-         : has_val(false), unex(std::forward<Args>(args)...)
-      {}
-
-      template <class U, class... Args>
-         requires std::is_constructible_v<E, std::initializer_list<U>&, Args...>
-      constexpr explicit expected(unexpect_t /*unused*/, std::initializer_list<U> il, Args... args)
-         : has_val(false), unex(il, std::forward<Args>(args)...)
-      {}
-
-      // destructor
-      constexpr ~expected()
-      {
-         if constexpr (std::is_trivially_destructible_v<E>) {
-         }
-         else {
-            if (!has_value()) std::destroy_at(std::addressof(this->unex));
-         }
-      }
-
-      // assignment
-      constexpr auto operator=(const expected& rhs) -> expected& // NOLINT
-         requires std::is_copy_assignable_v<E> && std::is_copy_constructible_v<E>
-      {
-         if (has_value() && rhs.has_value()) {
-         }
-         else if (has_value()) {
-            std::construct_at(std::addressof(this->unex), rhs.unex);
-            has_val = false;
-         }
-         else if (rhs.has_value()) {
-            std::destroy_at(std::addressof(this->unex));
-            has_val = true;
-         }
-         else {
-            this->unex = rhs.error();
-         }
-         return *this;
-      }
-
-      constexpr auto operator=(expected&& rhs) noexcept(
-         std::is_nothrow_move_constructible_v<E>&& std::is_nothrow_move_assignable_v<E>) -> expected&
-         requires std::is_move_constructible_v<E> && std::is_move_assignable_v<E>
-      {
-         if (has_value() && rhs.has_value()) {
-         }
-         else if (has_value()) {
-            std::construct_at(std::addressof(this->unex), std::move(rhs.unex));
-            has_val = false;
-         }
-         else if (rhs.has_value()) {
-            std::destroy_at(std::addressof(this->unex));
-            has_val = true;
-         }
-         else {
-            this->unex = std::move(rhs.error());
-         }
-         return *this;
-      }
-
-      template <class G>
-         requires std::is_constructible_v<E, const G&> and std::is_assignable_v<E&, const G&>
-      constexpr auto operator=(const unexpected<G>& e) -> expected&
-      {
-         if (has_value()) {
-            std::construct_at(std::addressof(this->unex), std::forward<const G&>(e.value()));
-            has_val = false;
-         }
-         else {
-            this->unex = std::forward<const G&>(e.value());
-         }
-         return *this;
-      }
-
-      template <class G>
-         requires std::is_constructible_v<E, G> && std::is_assignable_v<E&, G>
-      constexpr auto operator=(unexpected<G>&& e) -> expected&
-      {
-         if (has_value()) {
-            std::construct_at(std::addressof(this->unex), std::forward<G>(e.value()));
-            has_val = false;
-         }
-         else {
-            this->unex = std::forward<G>(e.value());
-         }
-         return *this;
-      }
-
-      // modifiers
-      constexpr void emplace() noexcept
-      {
-         if (!has_value()) {
-            std::destroy_at(std::addressof(this->unex));
-            has_val = true;
-         }
-      }
-
-      // swap
-      constexpr void swap(expected& rhs) noexcept(
-         std::is_nothrow_move_constructible_v<E>&& std::is_nothrow_swappable_v<E>)
-         requires std::is_swappable_v<E> && std::is_move_constructible_v<E>
-      {
-         if (rhs.has_value()) {
-            if (has_value()) {
-            }
-            else {
-               rhs.swap(*this);
-            }
-         }
-         else {
-            if (has_value()) {
-               std::construct_at(std::addressof(this->unex), std::move(rhs.unex));
-               std::destroy_at(std::addressof(rhs.unex));
-               has_val = false;
-               rhs.has_val = true;
-            }
-            else {
-               using std::swap;
-               swap(this->unex, rhs.unex);
-            }
-         }
-      }
-
-      // observers
-      constexpr explicit operator bool() const noexcept { return has_val; }
-
-      [[nodiscard]] constexpr auto has_value() const noexcept -> bool { return has_val; }
-
-      // precondition: has_value() = true
-      constexpr void operator*() const noexcept {}
-
-      constexpr void value() const&
-      {
-         if (!has_value()) {
-            GLZ_THROW_OR_ABORT(bad_expected_access(error()));
-         }
-      }
-
-      constexpr void value() &&
-      {
-         if (!has_value()) {
-            GLZ_THROW_OR_ABORT(bad_expected_access(std::move(error())));
-         }
-      }
-
-      // precondition: has_value() = false
-      constexpr auto error() const& -> const E& { return this->unex; }
-
-      // precondition: has_value() = false
-      constexpr auto error() & -> E& { return this->unex; }
-
-      // precondition: has_value() = false
-      constexpr auto error() const&& -> const E&& { return std::move(this->unex); }
-
-      // precondition: has_value() = false
-      constexpr auto error() && -> E&& { return std::move(this->unex); }
-
-      // monadic
-      template <class F, class U = std::remove_cvref_t<std::invoke_result_t<F> > >
-         requires detail::is_expected<U> && std::is_same_v<typename U::error_type, E> && std::is_copy_constructible_v<E>
-      constexpr auto and_then(F&& f) &
-      {
-         if (has_value()) {
-            return std::invoke(std::forward<F>(f));
-         }
-         return U(unexpect, error());
-      }
-
-      template <class F, class U = std::remove_cvref_t<std::invoke_result_t<F> > >
-         requires detail::is_expected<U> && std::is_same_v<typename U::error_type, E> && std::is_copy_constructible_v<E>
-      constexpr auto and_then(F&& f) const&
-      {
-         if (has_value()) {
-            return std::invoke(std::forward<F>(f));
-         }
-         return U(unexpect, error());
-      }
-
-      template <class F, class U = std::remove_cvref_t<std::invoke_result_t<F> > >
-         requires detail::is_expected<U> && std::is_same_v<typename U::error_type, E> && std::is_move_constructible_v<E>
-      constexpr auto and_then(F&& f) &&
-      {
-         if (has_value()) {
-            return std::invoke(std::forward<F>(f));
-         }
-         return U(unexpect, std::move(error()));
-      }
-
-      template <class F, class U = std::remove_cvref_t<std::invoke_result_t<F> > >
-         requires detail::is_expected<U> && std::is_same_v<typename U::error_type, E> && std::is_move_constructible_v<E>
-      constexpr auto and_then(F&& f) const&&
-      {
-         if (has_value()) {
-            return std::invoke(std::forward<F>(f));
-         }
-         return U(unexpect, std::move(error()));
-      }
-
-      template <class F, class V = E&, class G = std::remove_cvref_t<std::invoke_result_t<F, V> > >
-         requires detail::is_expected<G> && std::is_same_v<typename G::value_type, void> &&
-                  std::is_copy_constructible_v<E>
-      constexpr auto or_else(F&& f) &
-      {
-         if (has_value()) {
-            return G{};
-         }
-         return std::invoke(std::forward<F>(f), error());
-      }
-
-      template <class F, class V = const E&, class G = std::remove_cvref_t<std::invoke_result_t<F, V> > >
-         requires detail::is_expected<G> && std::is_same_v<typename G::value_type, void> &&
-                  std::is_copy_constructible_v<E>
-      constexpr auto or_else(F&& f) const&
-      {
-         if (has_value()) {
-            return G{};
-         }
-         return std::invoke(std::forward<F>(f), error());
-      }
-
-      template <class F, class V = E&&, class G = std::remove_cvref_t<std::invoke_result_t<F, V> > >
-         requires detail::is_expected<G> && std::is_same_v<typename G::value_type, void> &&
-                  std::is_move_constructible_v<E>
-      constexpr auto or_else(F&& f) &&
-      {
-         if (has_value()) {
-            return G{};
-         }
-         return std::invoke(std::forward<F>(f), std::move(error()));
-      }
-
-      template <class F, class V = const E&&, class G = std::remove_cvref_t<std::invoke_result_t<F, V> > >
-         requires detail::is_expected<G> && std::is_same_v<typename G::value_type, void> &&
-                  std::is_move_constructible_v<E>
-      constexpr auto or_else(F&& f) const&&
-      {
-         if (has_value()) {
-            return G{};
-         }
-         return std::invoke(std::forward<F>(f), std::move(error()));
-      }
-
-      template <class F, class V = E&, class G = std::remove_cvref_t<std::invoke_result_t<F, V> > >
-         requires std::is_void_v<G> && std::is_copy_constructible_v<E>
-      constexpr auto or_else(F&& f) &
-      {
-         if (has_value()) {
-            return expected(*this);
-         }
-         std::invoke(std::forward<F>(f), error());
-         return expected(*this);
-      }
-
-      template <class F, class V = const E&, class G = std::remove_cvref_t<std::invoke_result_t<F, V> > >
-         requires std::is_void_v<G> && std::is_copy_constructible_v<E>
-      constexpr auto or_else(F&& f) const&
-      {
-         if (has_value()) {
-            return expected(*this);
-         }
-         std::invoke(std::forward<F>(f), error());
-         return expected(*this);
-      }
-
-      template <class F, class V = E&&, class G = std::remove_cvref_t<std::invoke_result_t<F, V> > >
-         requires std::is_void_v<G> && std::is_move_constructible_v<E> && std::is_copy_constructible_v<E>
-      constexpr auto or_else(F&& f) &&
-      {
-         if (has_value()) {
-            return expected(std::move(*this));
-         }
-         // TODO: is this copy necessary, as f can be just read argument function
-         std::invoke(std::forward<F>(f), error());
-         return expected(std::move(*this));
-      }
-
-      template <class F, class V = const E&&, class G = std::remove_cvref_t<std::invoke_result_t<F, V> > >
-         requires std::is_void_v<G> && std::is_move_constructible_v<E> && std::is_copy_constructible_v<E>
-      constexpr auto or_else(F&& f) const&&
-      {
-         if (!has_value()) {
-            return expected(std::move(*this));
-         }
-         // TODO: is this copy necessary, as f can be just read argument function
-         std::invoke(std::forward<F>(f), error());
-         return expected(std::move(*this));
-      }
-
-      template <class F, class U = std::remove_cvref_t<std::invoke_result_t<F> > >
-         requires std::is_copy_constructible_v<E>
-      constexpr auto transform(F&& f) &
-      {
-         if (has_value()) {
-            if constexpr (!std::same_as<U, void>) {
-               return expected<U, E>(std::invoke(std::forward<F>(f)));
-            }
-            else {
-               std::invoke(std::forward<F>(f));
-               return expected<U, E>();
-            }
-         }
-         return expected<U, E>(unexpect, error());
-      }
-
-      template <class F, class U = std::remove_cvref_t<std::invoke_result_t<F> > >
-         requires std::is_copy_constructible_v<E>
-      constexpr auto transform(F&& f) const&
-      {
-         if (has_value()) {
-            if constexpr (!std::same_as<U, void>) {
-               return expected<U, E>(std::invoke(std::forward<F>(f)));
-            }
-            else {
-               std::invoke(std::forward<F>(f));
-               return expected<U, E>();
-            }
-         }
-         return expected<U, E>(unexpect, error());
-      }
-
-      template <class F, class U = std::remove_cvref_t<std::invoke_result_t<F> > >
-         requires std::is_move_constructible_v<E>
-      constexpr auto transform(F&& f) &&
-      {
-         if (has_value()) {
-            if constexpr (!std::same_as<U, void>) {
-               return expected<U, E>(std::invoke(std::forward<F>(f)));
-            }
-            else {
-               std::invoke(std::forward<F>(f));
-               return expected<U, E>();
-            }
-         }
-         return expected<U, E>(unexpect, std::move(error()));
-      }
-
-      template <class F, class U = std::remove_cvref_t<std::invoke_result_t<F> > >
-         requires std::is_move_constructible_v<E>
-      constexpr auto transform(F&& f) const&&
-      {
-         if (has_value()) {
-            if constexpr (!std::same_as<U, void>) {
-               return expected<U, E>(std::invoke(std::forward<F>(f)));
-            }
-            else {
-               std::invoke(std::forward<F>(f));
-               return expected<U, E>();
-            }
-         }
-         return expected<U, E>(unexpect, std::move(error()));
-      }
-
-      template <class F, class V = E&, class G = std::remove_cvref_t<std::invoke_result_t<F, V> > >
-         requires std::is_copy_constructible_v<E>
-      constexpr auto transform_error(F&& f) &
-      {
-         if (has_value()) {
-            return expected<void, G>{};
-         }
-         return expected<void, G>(unexpect, std::invoke(std::forward<F>(f), error()));
-      }
-
-      template <class F, class V = const E&, class G = std::remove_cvref_t<std::invoke_result_t<F, V> > >
-         requires std::is_copy_constructible_v<E>
-      constexpr auto transform_error(F&& f) const&
-      {
-         if (has_value()) {
-            return expected<void, G>{};
-         }
-         return expected<void, G>(unexpect, std::invoke(std::forward<F>(f), error()));
-      }
-
-      template <class F, class V = E&&, class G = std::remove_cvref_t<std::invoke_result_t<F, V> > >
-         requires std::is_move_constructible_v<E>
-      constexpr auto transform_error(F&& f) &&
-      {
-         if (has_value()) {
-            return expected<void, G>{};
-         }
-         return expected<void, G>(unexpect, std::invoke(std::forward<F>(f), std::move(error())));
-      }
-
-      template <class F, class V = const E&&, class G = std::remove_cvref_t<std::invoke_result_t<F, V> > >
-         requires std::is_move_constructible_v<E>
-      constexpr auto transform_error(F&& f) const&&
-      {
-         if (has_value()) {
-            return expected<void, G>{};
-         }
-         return expected<void, G>(unexpect, std::invoke(std::forward<F>(f), std::move(error())));
-      }
-
-      // expected equality operators
-      template <class T2, class E2>
-         requires std::is_void_v<T2> && requires(E e, E2 e2) {
-            {
-               e == e2
-            } -> std::convertible_to<bool>;
-         }
-      friend constexpr auto operator==(const expected& x, const expected<T2, E2>& y) -> bool
-      {
-         if (x.has_value() != y.has_value()) return false;
-         return x.has_value() or bool(x.error() == y.error());
-      }
-
-      template <class E2>
-         requires requires(const expected& x, const unexpected<E2>& e) {
-            {
-               x.error() == e.value()
-            } -> std::convertible_to<bool>;
-         }
-      friend constexpr auto operator==(const expected& x, const unexpected<E2>& e) -> bool
-      {
-         return !x.has_value() && bool(x.error() == e.value());
-      }
-
-      // specialized algorithms
-      friend constexpr void swap(expected& x, expected& y) noexcept(noexcept(x.swap(y))) { x.swap(y); }
-
-     private:
-      bool has_val{true};
-      union {
-         E unex;
-      };
-   };
-
-}
-
-#endif
+}
\ No newline at end of file
diff --git a/deps/saucer/include/glaze/util/fast_float.hpp b/deps/saucer/include/glaze/util/fast_float.hpp
new file mode 100644
index 0000000..4980661
--- /dev/null
+++ b/deps/saucer/include/glaze/util/fast_float.hpp
@@ -0,0 +1,4447 @@
+// fast_float version 8.0.2, https://github.com/fastfloat/fast_float
+
+// clang-format off
+
+// fast_float by Daniel Lemire
+// fast_float by João Paulo Magalhaes
+//
+//
+// with contributions from Eugene Golushkov
+// with contributions from Maksim Kita
+// with contributions from Marcin Wojdyr
+// with contributions from Neal Richardson
+// with contributions from Tim Paine
+// with contributions from Fabio Pellacini
+// with contributions from Lénárd Szolnoki
+// with contributions from Jan Pharago
+// with contributions from Maya Warrier
+// with contributions from Taha Khokhar
+// with contributions from Anders Dalvander
+//
+//
+// Licensed under the Apache License, Version 2.0, or the
+// MIT License or the Boost License. This file may not be copied,
+// modified, or distributed except according to those terms.
+//
+// MIT License Notice
+//
+//    MIT License
+//
+//    Copyright (c) 2021 The fast_float authors
+//
+//    Permission is hereby granted, free of charge, to any
+//    person obtaining a copy of this software and associated
+//    documentation files (the "Software"), to deal in the
+//    Software without restriction, including without
+//    limitation the rights to use, copy, modify, merge,
+//    publish, distribute, sublicense, and/or sell copies of
+//    the Software, and to permit persons to whom the Software
+//    is furnished to do so, subject to the following
+//    conditions:
+//
+//    The above copyright notice and this permission notice
+//    shall be included in all copies or substantial portions
+//    of the Software.
+//
+//    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+//    ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+//    TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+//    PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+//    SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+//    CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+//    OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+//    IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+//    DEALINGS IN THE SOFTWARE.
+//
+// Apache License (Version 2.0) Notice
+//
+//    Copyright 2021 The fast_float authors
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//
+// BOOST License Notice
+//
+//    Boost Software License - Version 1.0 - August 17th, 2003
+//
+//    Permission is hereby granted, free of charge, to any person or organization
+//    obtaining a copy of the software and accompanying documentation covered by
+//    this license (the "Software") to use, reproduce, display, distribute,
+//    execute, and transmit the Software, and to prepare derivative works of the
+//    Software, and to permit third-parties to whom the Software is furnished to
+//    do so, all subject to the following:
+//
+//    The copyright notices in the Software and this entire statement, including
+//    the above license grant, this restriction and the following disclaimer,
+//    must be included in all copies of the Software, in whole or in part, and
+//    all derivative works of the Software, unless such copies or derivative
+//    works are solely in the form of machine-executable object code generated by
+//    a source language processor.
+//
+//    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//    FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+//    SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+//    FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+//    ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+//    DEALINGS IN THE SOFTWARE.
+//
+
+#ifndef GLZ_FASTFLOAT_CONSTEXPR_FEATURE_DETECT_H
+#define GLZ_FASTFLOAT_CONSTEXPR_FEATURE_DETECT_H
+
+#ifdef __has_include
+#if __has_include(<version>)
+#include <version>
+#endif
+#endif
+
+// Testing for https://wg21.link/N3652, adopted in C++14
+#if defined(__cpp_constexpr) && __cpp_constexpr >= 201304
+#define GLZ_FASTFLOAT_CONSTEXPR14 constexpr
+#else
+#define GLZ_FASTFLOAT_CONSTEXPR14
+#endif
+
+#if defined(__cpp_lib_bit_cast) && __cpp_lib_bit_cast >= 201806L
+#define GLZ_FASTFLOAT_HAS_BIT_CAST 1
+#else
+#define GLZ_FASTFLOAT_HAS_BIT_CAST 0
+#endif
+
+#if defined(__cpp_lib_is_constant_evaluated) &&                                \
+    __cpp_lib_is_constant_evaluated >= 201811L
+#define GLZ_FASTFLOAT_HAS_IS_CONSTANT_EVALUATED 1
+#else
+#define GLZ_FASTFLOAT_HAS_IS_CONSTANT_EVALUATED 0
+#endif
+
+#if defined(__cpp_if_constexpr) && __cpp_if_constexpr >= 201606L
+#define GLZ_FASTFLOAT_IF_CONSTEXPR17(x) if constexpr (x)
+#else
+#define GLZ_FASTFLOAT_IF_CONSTEXPR17(x) if (x)
+#endif
+
+// Testing for relevant C++20 constexpr library features
+#if GLZ_FASTFLOAT_HAS_IS_CONSTANT_EVALUATED && GLZ_FASTFLOAT_HAS_BIT_CAST &&           \
+    defined(__cpp_lib_constexpr_algorithms) &&                                 \
+    __cpp_lib_constexpr_algorithms >= 201806L /*For std::copy and std::fill*/
+#define GLZ_FASTFLOAT_CONSTEXPR20 constexpr
+#define GLZ_FASTFLOAT_IS_CONSTEXPR 1
+#else
+#define GLZ_FASTFLOAT_CONSTEXPR20
+#define GLZ_FASTFLOAT_IS_CONSTEXPR 0
+#endif
+
+#if __cplusplus >= 201703L || (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L)
+#define GLZ_FASTFLOAT_DETAIL_MUST_DEFINE_CONSTEXPR_VARIABLE 0
+#else
+#define GLZ_FASTFLOAT_DETAIL_MUST_DEFINE_CONSTEXPR_VARIABLE 1
+#endif
+
+#endif // GLZ_FASTFLOAT_CONSTEXPR_FEATURE_DETECT_H
+
+#ifndef GLZ_FASTFLOAT_FLOAT_COMMON_H
+#define GLZ_FASTFLOAT_FLOAT_COMMON_H
+
+#include <cfloat>
+#include <cstdint>
+#include <cassert>
+#include <cstring>
+#include <limits>
+#include <type_traits>
+#include <system_error>
+#ifdef __has_include
+#if __has_include(<stdfloat>) && (__cplusplus > 202002L || (defined(_MSVC_LANG) && (_MSVC_LANG > 202002L)))
+#include <stdfloat>
+#endif
+#endif
+
+#define GLZ_FASTFLOAT_VERSION_MAJOR 8
+#define GLZ_FASTFLOAT_VERSION_MINOR 0
+#define GLZ_FASTFLOAT_VERSION_PATCH 2
+
+#define GLZ_FASTFLOAT_STRINGIZE_IMPL(x) #x
+#define GLZ_FASTFLOAT_STRINGIZE(x) GLZ_FASTFLOAT_STRINGIZE_IMPL(x)
+
+#define GLZ_FASTFLOAT_VERSION_STR                                                  \
+  GLZ_FASTFLOAT_STRINGIZE(GLZ_FASTFLOAT_VERSION_MAJOR)                                 \
+  "." GLZ_FASTFLOAT_STRINGIZE(GLZ_FASTFLOAT_VERSION_MINOR) "." GLZ_FASTFLOAT_STRINGIZE(    \
+      GLZ_FASTFLOAT_VERSION_PATCH)
+
+#define GLZ_FASTFLOAT_VERSION                                                      \
+  (GLZ_FASTFLOAT_VERSION_MAJOR * 10000 + GLZ_FASTFLOAT_VERSION_MINOR * 100 +           \
+   GLZ_FASTFLOAT_VERSION_PATCH)
+
+namespace glz::fast_float {
+
+enum class chars_format : uint64_t;
+
+namespace detail {
+constexpr chars_format basic_json_fmt = chars_format(1 << 5);
+constexpr chars_format basic_fortran_fmt = chars_format(1 << 6);
+} // namespace detail
+
+enum class chars_format : uint64_t {
+  scientific = 1 << 0,
+  fixed = 1 << 2,
+  hex = 1 << 3,
+  no_infnan = 1 << 4,
+  // RFC 8259: https://datatracker.ietf.org/doc/html/rfc8259#section-6
+  json = uint64_t(detail::basic_json_fmt) | fixed | scientific | no_infnan,
+  // Extension of RFC 8259 where, e.g., "inf" and "nan" are allowed.
+  json_or_infnan = uint64_t(detail::basic_json_fmt) | fixed | scientific,
+  fortran = uint64_t(detail::basic_fortran_fmt) | fixed | scientific,
+  general = fixed | scientific,
+  allow_leading_plus = 1 << 7,
+  skip_white_space = 1 << 8,
+};
+
+template <typename UC> struct from_chars_result_t {
+  UC const *ptr;
+  std::errc ec;
+};
+
+using from_chars_result = from_chars_result_t<char>;
+
+template <typename UC> struct parse_options_t {
+  constexpr explicit parse_options_t(chars_format fmt = chars_format::general,
+                                     UC dot = UC('.'), int b = 10)
+      : format(fmt), decimal_point(dot), base(b) {}
+
+  /** Which number formats are accepted */
+  chars_format format;
+  /** The character used as decimal point */
+  UC decimal_point;
+  /** The base used for integers */
+  int base;
+};
+
+using parse_options = parse_options_t<char>;
+
+} // namespace glz::fast_float
+
+#if GLZ_FASTFLOAT_HAS_BIT_CAST
+#include <bit>
+#endif
+
+#if (defined(__x86_64) || defined(__x86_64__) || defined(_M_X64) ||            \
+     defined(__amd64) || defined(__aarch64__) || defined(_M_ARM64) ||          \
+     defined(__MINGW64__) || defined(__s390x__) ||                             \
+     (defined(__ppc64__) || defined(__PPC64__) || defined(__ppc64le__) ||      \
+      defined(__PPC64LE__)) ||                                                 \
+     defined(__loongarch64))
+#define GLZ_FASTFLOAT_64BIT 1
+#elif (defined(__i386) || defined(__i386__) || defined(_M_IX86) ||             \
+       defined(__arm__) || defined(_M_ARM) || defined(__ppc__) ||              \
+       defined(__MINGW32__) || defined(__EMSCRIPTEN__))
+#define GLZ_FASTFLOAT_32BIT 1
+#else
+  // Need to check incrementally, since SIZE_MAX is a size_t, avoid overflow.
+// We can never tell the register width, but the SIZE_MAX is a good
+// approximation. UINTPTR_MAX and INTPTR_MAX are optional, so avoid them for max
+// portability.
+#if SIZE_MAX == 0xffff
+#error Unknown platform (16-bit, unsupported)
+#elif SIZE_MAX == 0xffffffff
+#define GLZ_FASTFLOAT_32BIT 1
+#elif SIZE_MAX == 0xffffffffffffffff
+#define GLZ_FASTFLOAT_64BIT 1
+#else
+#error Unknown platform (not 32-bit, not 64-bit?)
+#endif
+#endif
+
+#if ((defined(_WIN32) || defined(_WIN64)) && !defined(__clang__)) ||           \
+    (defined(_M_ARM64) && !defined(__MINGW32__))
+#include <intrin.h>
+#endif
+
+#if defined(_MSC_VER) && !defined(__clang__)
+#define GLZ_FASTFLOAT_VISUAL_STUDIO 1
+#endif
+
+#if defined __BYTE_ORDER__ && defined __ORDER_BIG_ENDIAN__
+#define GLZ_FASTFLOAT_IS_BIG_ENDIAN (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
+#elif defined _WIN32
+#define GLZ_FASTFLOAT_IS_BIG_ENDIAN 0
+#else
+#if defined(__APPLE__) || defined(__FreeBSD__)
+#include <machine/endian.h>
+#elif defined(sun) || defined(__sun)
+#include <sys/byteorder.h>
+#elif defined(__MVS__)
+#include <sys/endian.h>
+#else
+#ifdef __has_include
+#if __has_include(<endian.h>)
+#include <endian.h>
+#endif //__has_include(<endian.h>)
+#endif //__has_include
+#endif
+#
+#ifndef __BYTE_ORDER__
+// safe choice
+#define GLZ_FASTFLOAT_IS_BIG_ENDIAN 0
+#endif
+#
+#ifndef __ORDER_LITTLE_ENDIAN__
+// safe choice
+#define GLZ_FASTFLOAT_IS_BIG_ENDIAN 0
+#endif
+#
+#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+#define GLZ_FASTFLOAT_IS_BIG_ENDIAN 0
+#else
+#define GLZ_FASTFLOAT_IS_BIG_ENDIAN 1
+#endif
+#endif
+
+#if defined(__SSE2__) || (defined(GLZ_FASTFLOAT_VISUAL_STUDIO) &&                  \
+                          (defined(_M_AMD64) || defined(_M_X64) ||             \
+                           (defined(_M_IX86_FP) && _M_IX86_FP == 2)))
+#define GLZ_FASTFLOAT_SSE2 1
+#endif
+
+#if defined(__aarch64__) || defined(_M_ARM64)
+#define GLZ_FASTFLOAT_NEON 1
+#endif
+
+#if defined(GLZ_FASTFLOAT_SSE2) || defined(GLZ_FASTFLOAT_NEON)
+#define GLZ_FASTFLOAT_HAS_SIMD 1
+#endif
+
+#if defined(__GNUC__)
+// disable -Wcast-align=strict (GCC only)
+#define GLZ_FASTFLOAT_SIMD_DISABLE_WARNINGS                                        \
+  _Pragma("GCC diagnostic push")                                               \
+      _Pragma("GCC diagnostic ignored \"-Wcast-align\"")
+#else
+#define GLZ_FASTFLOAT_SIMD_DISABLE_WARNINGS
+#endif
+
+#if defined(__GNUC__)
+#define GLZ_FASTFLOAT_SIMD_RESTORE_WARNINGS _Pragma("GCC diagnostic pop")
+#else
+#define GLZ_FASTFLOAT_SIMD_RESTORE_WARNINGS
+#endif
+
+#ifdef GLZ_FASTFLOAT_VISUAL_STUDIO
+#define fastfloat_really_inline __forceinline
+#else
+#define fastfloat_really_inline inline __attribute__((always_inline))
+#endif
+
+#ifndef GLZ_FASTFLOAT_ASSERT
+#define GLZ_FASTFLOAT_ASSERT(x)                                                    \
+  { ((void)(x)); }
+#endif
+
+#ifndef GLZ_FASTFLOAT_DEBUG_ASSERT
+#define GLZ_FASTFLOAT_DEBUG_ASSERT(x)                                              \
+  { ((void)(x)); }
+#endif
+
+// rust style `try!()` macro, or `?` operator
+#define GLZ_FASTFLOAT_TRY(x)                                                       \
+  {                                                                            \
+    if (!(x))                                                                  \
+      return false;                                                            \
+  }
+
+#define GLZ_FASTFLOAT_ENABLE_IF(...)                                               \
+  typename std::enable_if<(__VA_ARGS__), int>::type
+
+namespace glz::fast_float {
+
+fastfloat_really_inline constexpr bool cpp20_and_in_constexpr() {
+#if GLZ_FASTFLOAT_HAS_IS_CONSTANT_EVALUATED
+  return std::is_constant_evaluated();
+#else
+  return false;
+#endif
+}
+
+template <typename T>
+struct is_supported_float_type
+    : std::integral_constant<
+          bool, std::is_same<T, double>::value || std::is_same<T, float>::value
+#ifdef __STDCPP_FLOAT64_T__
+                    || std::is_same<T, std::float64_t>::value
+#endif
+#ifdef __STDCPP_FLOAT32_T__
+                    || std::is_same<T, std::float32_t>::value
+#endif
+#ifdef __STDCPP_FLOAT16_T__
+                    || std::is_same<T, std::float16_t>::value
+#endif
+#ifdef __STDCPP_BFLOAT16_T__
+                    || std::is_same<T, std::bfloat16_t>::value
+#endif
+          > {
+};
+
+template <typename T>
+using equiv_uint_t = typename std::conditional<
+    sizeof(T) == 1, uint8_t,
+    typename std::conditional<
+        sizeof(T) == 2, uint16_t,
+        typename std::conditional<sizeof(T) == 4, uint32_t,
+                                  uint64_t>::type>::type>::type;
+
+template <typename T> struct is_supported_integer_type : std::is_integral<T> {};
+
+template <typename UC>
+struct is_supported_char_type
+    : std::integral_constant<bool, std::is_same<UC, char>::value ||
+                                       std::is_same<UC, wchar_t>::value ||
+                                       std::is_same<UC, char16_t>::value ||
+                                       std::is_same<UC, char32_t>::value
+#ifdef __cpp_char8_t
+                                       || std::is_same<UC, char8_t>::value
+#endif
+                             > {
+};
+
+// Compares two ASCII strings in a case insensitive manner.
+template <typename UC>
+inline GLZ_FASTFLOAT_CONSTEXPR14 bool
+fastfloat_strncasecmp(UC const *actual_mixedcase, UC const *expected_lowercase,
+                      size_t length) {
+  for (size_t i = 0; i < length; ++i) {
+    UC const actual = actual_mixedcase[i];
+    if ((actual < 256 ? actual | 32 : actual) != expected_lowercase[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+
+#ifndef FLT_EVAL_METHOD
+#error "FLT_EVAL_METHOD should be defined, please include cfloat."
+#endif
+
+// a pointer and a length to a contiguous block of memory
+template <typename T> struct span {
+  T const *ptr;
+  size_t length;
+
+  constexpr span(T const *_ptr, size_t _length) : ptr(_ptr), length(_length) {}
+
+  constexpr span() : ptr(nullptr), length(0) {}
+
+  constexpr size_t len() const noexcept { return length; }
+
+  GLZ_FASTFLOAT_CONSTEXPR14 const T &operator[](size_t index) const noexcept {
+    GLZ_FASTFLOAT_DEBUG_ASSERT(index < length);
+    return ptr[index];
+  }
+};
+
+struct value128 {
+  uint64_t low;
+  uint64_t high;
+
+  constexpr value128(uint64_t _low, uint64_t _high) : low(_low), high(_high) {}
+
+  constexpr value128() : low(0), high(0) {}
+};
+
+/* Helper C++14 constexpr generic implementation of leading_zeroes */
+fastfloat_really_inline GLZ_FASTFLOAT_CONSTEXPR14 int
+leading_zeroes_generic(uint64_t input_num, int last_bit = 0) {
+  if (input_num & uint64_t(0xffffffff00000000)) {
+    input_num >>= 32;
+    last_bit |= 32;
+  }
+  if (input_num & uint64_t(0xffff0000)) {
+    input_num >>= 16;
+    last_bit |= 16;
+  }
+  if (input_num & uint64_t(0xff00)) {
+    input_num >>= 8;
+    last_bit |= 8;
+  }
+  if (input_num & uint64_t(0xf0)) {
+    input_num >>= 4;
+    last_bit |= 4;
+  }
+  if (input_num & uint64_t(0xc)) {
+    input_num >>= 2;
+    last_bit |= 2;
+  }
+  if (input_num & uint64_t(0x2)) { /* input_num >>=  1; */
+    last_bit |= 1;
+  }
+  return 63 - last_bit;
+}
+
+/* result might be undefined when input_num is zero */
+fastfloat_really_inline GLZ_FASTFLOAT_CONSTEXPR20 int
+leading_zeroes(uint64_t input_num) {
+  assert(input_num > 0);
+  if (cpp20_and_in_constexpr()) {
+    return leading_zeroes_generic(input_num);
+  }
+#ifdef GLZ_FASTFLOAT_VISUAL_STUDIO
+#if defined(_M_X64) || defined(_M_ARM64)
+  unsigned long leading_zero = 0;
+  // Search the mask data from most significant bit (MSB)
+  // to least significant bit (LSB) for a set bit (1).
+  _BitScanReverse64(&leading_zero, input_num);
+  return (int)(63 - leading_zero);
+#else
+  return leading_zeroes_generic(input_num);
+#endif
+#else
+  return __builtin_clzll(input_num);
+#endif
+}
+
+// slow emulation routine for 32-bit
+fastfloat_really_inline constexpr uint64_t emulu(uint32_t x, uint32_t y) {
+  return x * (uint64_t)y;
+}
+
+fastfloat_really_inline GLZ_FASTFLOAT_CONSTEXPR14 uint64_t
+umul128_generic(uint64_t ab, uint64_t cd, uint64_t *hi) {
+  uint64_t ad = emulu((uint32_t)(ab >> 32), (uint32_t)cd);
+  uint64_t bd = emulu((uint32_t)ab, (uint32_t)cd);
+  uint64_t adbc = ad + emulu((uint32_t)ab, (uint32_t)(cd >> 32));
+  uint64_t adbc_carry = (uint64_t)(adbc < ad);
+  uint64_t lo = bd + (adbc << 32);
+  *hi = emulu((uint32_t)(ab >> 32), (uint32_t)(cd >> 32)) + (adbc >> 32) +
+        (adbc_carry << 32) + (uint64_t)(lo < bd);
+  return lo;
+}
+
+#ifdef GLZ_FASTFLOAT_32BIT
+
+// slow emulation routine for 32-bit
+#if !defined(__MINGW64__)
+fastfloat_really_inline GLZ_FASTFLOAT_CONSTEXPR14 uint64_t _umul128(uint64_t ab,
+                                                                uint64_t cd,
+                                                                uint64_t *hi) {
+  return umul128_generic(ab, cd, hi);
+}
+#endif // !__MINGW64__
+
+#endif // GLZ_FASTFLOAT_32BIT
+
+// compute 64-bit a*b
+fastfloat_really_inline GLZ_FASTFLOAT_CONSTEXPR20 value128
+full_multiplication(uint64_t a, uint64_t b) {
+  if (cpp20_and_in_constexpr()) {
+    value128 answer;
+    answer.low = umul128_generic(a, b, &answer.high);
+    return answer;
+  }
+  value128 answer;
+#if defined(_M_ARM64) && !defined(__MINGW32__)
+  // ARM64 has native support for 64-bit multiplications, no need to emulate
+  // But MinGW on ARM64 doesn't have native support for 64-bit multiplications
+  answer.high = __umulh(a, b);
+  answer.low = a * b;
+#elif defined(GLZ_FASTFLOAT_32BIT) ||                                              \
+    (defined(_WIN64) && !defined(__clang__) && !defined(_M_ARM64))
+  answer.low = _umul128(a, b, &answer.high); // _umul128 not available on ARM64
+#elif defined(GLZ_FASTFLOAT_64BIT) && defined(__SIZEOF_INT128__)
+  __uint128_t r = ((__uint128_t)a) * b;
+  answer.low = uint64_t(r);
+  answer.high = uint64_t(r >> 64);
+#else
+  answer.low = umul128_generic(a, b, &answer.high);
+#endif
+  return answer;
+}
+
+struct adjusted_mantissa {
+  uint64_t mantissa{0};
+  int32_t power2{0}; // a negative value indicates an invalid result
+  adjusted_mantissa() = default;
+
+  constexpr bool operator==(adjusted_mantissa const &o) const {
+    return mantissa == o.mantissa && power2 == o.power2;
+  }
+
+  constexpr bool operator!=(adjusted_mantissa const &o) const {
+    return mantissa != o.mantissa || power2 != o.power2;
+  }
+};
+
+// Bias so we can get the real exponent with an invalid adjusted_mantissa.
+constexpr static int32_t invalid_am_bias = -0x8000;
+
+// used for binary_format_lookup_tables<T>::max_mantissa
+constexpr uint64_t constant_55555 = 5 * 5 * 5 * 5 * 5;
+
+template <typename T, typename U = void> struct binary_format_lookup_tables;
+
+template <typename T> struct binary_format : binary_format_lookup_tables<T> {
+  using equiv_uint = equiv_uint_t<T>;
+
+  static constexpr int mantissa_explicit_bits();
+  static constexpr int minimum_exponent();
+  static constexpr int infinite_power();
+  static constexpr int sign_index();
+  static constexpr int
+  min_exponent_fast_path(); // used when fegetround() == FE_TONEAREST
+  static constexpr int max_exponent_fast_path();
+  static constexpr int max_exponent_round_to_even();
+  static constexpr int min_exponent_round_to_even();
+  static constexpr uint64_t max_mantissa_fast_path(int64_t power);
+  static constexpr uint64_t
+  max_mantissa_fast_path(); // used when fegetround() == FE_TONEAREST
+  static constexpr int largest_power_of_ten();
+  static constexpr int smallest_power_of_ten();
+  static constexpr T exact_power_of_ten(int64_t power);
+  static constexpr size_t max_digits();
+  static constexpr equiv_uint exponent_mask();
+  static constexpr equiv_uint mantissa_mask();
+  static constexpr equiv_uint hidden_bit_mask();
+};
+
+template <typename U> struct binary_format_lookup_tables<double, U> {
+  static constexpr double powers_of_ten[] = {
+      1e0,  1e1,  1e2,  1e3,  1e4,  1e5,  1e6,  1e7,  1e8,  1e9,  1e10, 1e11,
+      1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19, 1e20, 1e21, 1e22};
+
+  // Largest integer value v so that (5**index * v) <= 1<<53.
+  // 0x20000000000000 == 1 << 53
+  static constexpr uint64_t max_mantissa[] = {
+      0x20000000000000,
+      0x20000000000000 / 5,
+      0x20000000000000 / (5 * 5),
+      0x20000000000000 / (5 * 5 * 5),
+      0x20000000000000 / (5 * 5 * 5 * 5),
+      0x20000000000000 / (constant_55555),
+      0x20000000000000 / (constant_55555 * 5),
+      0x20000000000000 / (constant_55555 * 5 * 5),
+      0x20000000000000 / (constant_55555 * 5 * 5 * 5),
+      0x20000000000000 / (constant_55555 * 5 * 5 * 5 * 5),
+      0x20000000000000 / (constant_55555 * constant_55555),
+      0x20000000000000 / (constant_55555 * constant_55555 * 5),
+      0x20000000000000 / (constant_55555 * constant_55555 * 5 * 5),
+      0x20000000000000 / (constant_55555 * constant_55555 * 5 * 5 * 5),
+      0x20000000000000 / (constant_55555 * constant_55555 * constant_55555),
+      0x20000000000000 / (constant_55555 * constant_55555 * constant_55555 * 5),
+      0x20000000000000 /
+          (constant_55555 * constant_55555 * constant_55555 * 5 * 5),
+      0x20000000000000 /
+          (constant_55555 * constant_55555 * constant_55555 * 5 * 5 * 5),
+      0x20000000000000 /
+          (constant_55555 * constant_55555 * constant_55555 * 5 * 5 * 5 * 5),
+      0x20000000000000 /
+          (constant_55555 * constant_55555 * constant_55555 * constant_55555),
+      0x20000000000000 / (constant_55555 * constant_55555 * constant_55555 *
+                          constant_55555 * 5),
+      0x20000000000000 / (constant_55555 * constant_55555 * constant_55555 *
+                          constant_55555 * 5 * 5),
+      0x20000000000000 / (constant_55555 * constant_55555 * constant_55555 *
+                          constant_55555 * 5 * 5 * 5),
+      0x20000000000000 / (constant_55555 * constant_55555 * constant_55555 *
+                          constant_55555 * 5 * 5 * 5 * 5)};
+};
+
+#if GLZ_FASTFLOAT_DETAIL_MUST_DEFINE_CONSTEXPR_VARIABLE
+
+template <typename U>
+constexpr double binary_format_lookup_tables<double, U>::powers_of_ten[];
+
+template <typename U>
+constexpr uint64_t binary_format_lookup_tables<double, U>::max_mantissa[];
+
+#endif
+
+template <typename U> struct binary_format_lookup_tables<float, U> {
+  static constexpr float powers_of_ten[] = {1e0f, 1e1f, 1e2f, 1e3f, 1e4f, 1e5f,
+                                            1e6f, 1e7f, 1e8f, 1e9f, 1e10f};
+
+  // Largest integer value v so that (5**index * v) <= 1<<24.
+  // 0x1000000 == 1<<24
+  static constexpr uint64_t max_mantissa[] = {
+      0x1000000,
+      0x1000000 / 5,
+      0x1000000 / (5 * 5),
+      0x1000000 / (5 * 5 * 5),
+      0x1000000 / (5 * 5 * 5 * 5),
+      0x1000000 / (constant_55555),
+      0x1000000 / (constant_55555 * 5),
+      0x1000000 / (constant_55555 * 5 * 5),
+      0x1000000 / (constant_55555 * 5 * 5 * 5),
+      0x1000000 / (constant_55555 * 5 * 5 * 5 * 5),
+      0x1000000 / (constant_55555 * constant_55555),
+      0x1000000 / (constant_55555 * constant_55555 * 5)};
+};
+
+#if GLZ_FASTFLOAT_DETAIL_MUST_DEFINE_CONSTEXPR_VARIABLE
+
+template <typename U>
+constexpr float binary_format_lookup_tables<float, U>::powers_of_ten[];
+
+template <typename U>
+constexpr uint64_t binary_format_lookup_tables<float, U>::max_mantissa[];
+
+#endif
+
+template <>
+inline constexpr int binary_format<double>::min_exponent_fast_path() {
+#if (FLT_EVAL_METHOD != 1) && (FLT_EVAL_METHOD != 0)
+  return 0;
+#else
+  return -22;
+#endif
+}
+
+template <>
+inline constexpr int binary_format<float>::min_exponent_fast_path() {
+#if (FLT_EVAL_METHOD != 1) && (FLT_EVAL_METHOD != 0)
+  return 0;
+#else
+  return -10;
+#endif
+}
+
+template <>
+inline constexpr int binary_format<double>::mantissa_explicit_bits() {
+  return 52;
+}
+
+template <>
+inline constexpr int binary_format<float>::mantissa_explicit_bits() {
+  return 23;
+}
+
+template <>
+inline constexpr int binary_format<double>::max_exponent_round_to_even() {
+  return 23;
+}
+
+template <>
+inline constexpr int binary_format<float>::max_exponent_round_to_even() {
+  return 10;
+}
+
+template <>
+inline constexpr int binary_format<double>::min_exponent_round_to_even() {
+  return -4;
+}
+
+template <>
+inline constexpr int binary_format<float>::min_exponent_round_to_even() {
+  return -17;
+}
+
+template <> inline constexpr int binary_format<double>::minimum_exponent() {
+  return -1023;
+}
+
+template <> inline constexpr int binary_format<float>::minimum_exponent() {
+  return -127;
+}
+
+template <> inline constexpr int binary_format<double>::infinite_power() {
+  return 0x7FF;
+}
+
+template <> inline constexpr int binary_format<float>::infinite_power() {
+  return 0xFF;
+}
+
+template <> inline constexpr int binary_format<double>::sign_index() {
+  return 63;
+}
+
+template <> inline constexpr int binary_format<float>::sign_index() {
+  return 31;
+}
+
+template <>
+inline constexpr int binary_format<double>::max_exponent_fast_path() {
+  return 22;
+}
+
+template <>
+inline constexpr int binary_format<float>::max_exponent_fast_path() {
+  return 10;
+}
+
+template <>
+inline constexpr uint64_t binary_format<double>::max_mantissa_fast_path() {
+  return uint64_t(2) << mantissa_explicit_bits();
+}
+
+template <>
+inline constexpr uint64_t binary_format<float>::max_mantissa_fast_path() {
+  return uint64_t(2) << mantissa_explicit_bits();
+}
+
+// credit: Jakub Jelínek
+#ifdef __STDCPP_FLOAT16_T__
+template <typename U> struct binary_format_lookup_tables<std::float16_t, U> {
+  static constexpr std::float16_t powers_of_ten[] = {1e0f16, 1e1f16, 1e2f16,
+                                                     1e3f16, 1e4f16};
+
+  // Largest integer value v so that (5**index * v) <= 1<<11.
+  // 0x800 == 1<<11
+  static constexpr uint64_t max_mantissa[] = {0x800,
+                                              0x800 / 5,
+                                              0x800 / (5 * 5),
+                                              0x800 / (5 * 5 * 5),
+                                              0x800 / (5 * 5 * 5 * 5),
+                                              0x800 / (constant_55555)};
+};
+
+#if GLZ_FASTFLOAT_DETAIL_MUST_DEFINE_CONSTEXPR_VARIABLE
+
+template <typename U>
+constexpr std::float16_t
+    binary_format_lookup_tables<std::float16_t, U>::powers_of_ten[];
+
+template <typename U>
+constexpr uint64_t
+    binary_format_lookup_tables<std::float16_t, U>::max_mantissa[];
+
+#endif
+
+template <>
+inline constexpr std::float16_t
+binary_format<std::float16_t>::exact_power_of_ten(int64_t power) {
+  // Work around clang bug https://godbolt.org/z/zedh7rrhc
+  return (void)powers_of_ten[0], powers_of_ten[power];
+}
+
+template <>
+inline constexpr binary_format<std::float16_t>::equiv_uint
+binary_format<std::float16_t>::exponent_mask() {
+  return 0x7C00;
+}
+
+template <>
+inline constexpr binary_format<std::float16_t>::equiv_uint
+binary_format<std::float16_t>::mantissa_mask() {
+  return 0x03FF;
+}
+
+template <>
+inline constexpr binary_format<std::float16_t>::equiv_uint
+binary_format<std::float16_t>::hidden_bit_mask() {
+  return 0x0400;
+}
+
+template <>
+inline constexpr int binary_format<std::float16_t>::max_exponent_fast_path() {
+  return 4;
+}
+
+template <>
+inline constexpr int binary_format<std::float16_t>::mantissa_explicit_bits() {
+  return 10;
+}
+
+template <>
+inline constexpr uint64_t
+binary_format<std::float16_t>::max_mantissa_fast_path() {
+  return uint64_t(2) << mantissa_explicit_bits();
+}
+
+template <>
+inline constexpr uint64_t
+binary_format<std::float16_t>::max_mantissa_fast_path(int64_t power) {
+  // caller is responsible to ensure that
+  // power >= 0 && power <= 4
+  //
+  // Work around clang bug https://godbolt.org/z/zedh7rrhc
+  return (void)max_mantissa[0], max_mantissa[power];
+}
+
+template <>
+inline constexpr int binary_format<std::float16_t>::min_exponent_fast_path() {
+  return 0;
+}
+
+template <>
+inline constexpr int
+binary_format<std::float16_t>::max_exponent_round_to_even() {
+  return 5;
+}
+
+template <>
+inline constexpr int
+binary_format<std::float16_t>::min_exponent_round_to_even() {
+  return -22;
+}
+
+template <>
+inline constexpr int binary_format<std::float16_t>::minimum_exponent() {
+  return -15;
+}
+
+template <>
+inline constexpr int binary_format<std::float16_t>::infinite_power() {
+  return 0x1F;
+}
+
+template <> inline constexpr int binary_format<std::float16_t>::sign_index() {
+  return 15;
+}
+
+template <>
+inline constexpr int binary_format<std::float16_t>::largest_power_of_ten() {
+  return 4;
+}
+
+template <>
+inline constexpr int binary_format<std::float16_t>::smallest_power_of_ten() {
+  return -27;
+}
+
+template <>
+inline constexpr size_t binary_format<std::float16_t>::max_digits() {
+  return 22;
+}
+#endif // __STDCPP_FLOAT16_T__
+
+// credit: Jakub Jelínek
+#ifdef __STDCPP_BFLOAT16_T__
+template <typename U> struct binary_format_lookup_tables<std::bfloat16_t, U> {
+  static constexpr std::bfloat16_t powers_of_ten[] = {1e0bf16, 1e1bf16, 1e2bf16,
+                                                      1e3bf16};
+
+  // Largest integer value v so that (5**index * v) <= 1<<8.
+  // 0x100 == 1<<8
+  static constexpr uint64_t max_mantissa[] = {0x100, 0x100 / 5, 0x100 / (5 * 5),
+                                              0x100 / (5 * 5 * 5),
+                                              0x100 / (5 * 5 * 5 * 5)};
+};
+
+#if GLZ_FASTFLOAT_DETAIL_MUST_DEFINE_CONSTEXPR_VARIABLE
+
+template <typename U>
+constexpr std::bfloat16_t
+    binary_format_lookup_tables<std::bfloat16_t, U>::powers_of_ten[];
+
+template <typename U>
+constexpr uint64_t
+    binary_format_lookup_tables<std::bfloat16_t, U>::max_mantissa[];
+
+#endif
+
+template <>
+inline constexpr std::bfloat16_t
+binary_format<std::bfloat16_t>::exact_power_of_ten(int64_t power) {
+  // Work around clang bug https://godbolt.org/z/zedh7rrhc
+  return (void)powers_of_ten[0], powers_of_ten[power];
+}
+
+template <>
+inline constexpr int binary_format<std::bfloat16_t>::max_exponent_fast_path() {
+  return 3;
+}
+
+template <>
+inline constexpr binary_format<std::bfloat16_t>::equiv_uint
+binary_format<std::bfloat16_t>::exponent_mask() {
+  return 0x7F80;
+}
+
+template <>
+inline constexpr binary_format<std::bfloat16_t>::equiv_uint
+binary_format<std::bfloat16_t>::mantissa_mask() {
+  return 0x007F;
+}
+
+template <>
+inline constexpr binary_format<std::bfloat16_t>::equiv_uint
+binary_format<std::bfloat16_t>::hidden_bit_mask() {
+  return 0x0080;
+}
+
+template <>
+inline constexpr int binary_format<std::bfloat16_t>::mantissa_explicit_bits() {
+  return 7;
+}
+
+template <>
+inline constexpr uint64_t
+binary_format<std::bfloat16_t>::max_mantissa_fast_path() {
+  return uint64_t(2) << mantissa_explicit_bits();
+}
+
+template <>
+inline constexpr uint64_t
+binary_format<std::bfloat16_t>::max_mantissa_fast_path(int64_t power) {
+  // caller is responsible to ensure that
+  // power >= 0 && power <= 3
+  //
+  // Work around clang bug https://godbolt.org/z/zedh7rrhc
+  return (void)max_mantissa[0], max_mantissa[power];
+}
+
+template <>
+inline constexpr int binary_format<std::bfloat16_t>::min_exponent_fast_path() {
+  return 0;
+}
+
+template <>
+inline constexpr int
+binary_format<std::bfloat16_t>::max_exponent_round_to_even() {
+  return 3;
+}
+
+template <>
+inline constexpr int
+binary_format<std::bfloat16_t>::min_exponent_round_to_even() {
+  return -24;
+}
+
+template <>
+inline constexpr int binary_format<std::bfloat16_t>::minimum_exponent() {
+  return -127;
+}
+
+template <>
+inline constexpr int binary_format<std::bfloat16_t>::infinite_power() {
+  return 0xFF;
+}
+
+template <> inline constexpr int binary_format<std::bfloat16_t>::sign_index() {
+  return 15;
+}
+
+template <>
+inline constexpr int binary_format<std::bfloat16_t>::largest_power_of_ten() {
+  return 38;
+}
+
+template <>
+inline constexpr int binary_format<std::bfloat16_t>::smallest_power_of_ten() {
+  return -60;
+}
+
+template <>
+inline constexpr size_t binary_format<std::bfloat16_t>::max_digits() {
+  return 98;
+}
+#endif // __STDCPP_BFLOAT16_T__
+
+template <>
+inline constexpr uint64_t
+binary_format<double>::max_mantissa_fast_path(int64_t power) {
+  // caller is responsible to ensure that
+  // power >= 0 && power <= 22
+  //
+  // Work around clang bug https://godbolt.org/z/zedh7rrhc
+  return (void)max_mantissa[0], max_mantissa[power];
+}
+
+template <>
+inline constexpr uint64_t
+binary_format<float>::max_mantissa_fast_path(int64_t power) {
+  // caller is responsible to ensure that
+  // power >= 0 && power <= 10
+  //
+  // Work around clang bug https://godbolt.org/z/zedh7rrhc
+  return (void)max_mantissa[0], max_mantissa[power];
+}
+
+template <>
+inline constexpr double
+binary_format<double>::exact_power_of_ten(int64_t power) {
+  // Work around clang bug https://godbolt.org/z/zedh7rrhc
+  return (void)powers_of_ten[0], powers_of_ten[power];
+}
+
+template <>
+inline constexpr float binary_format<float>::exact_power_of_ten(int64_t power) {
+  // Work around clang bug https://godbolt.org/z/zedh7rrhc
+  return (void)powers_of_ten[0], powers_of_ten[power];
+}
+
+template <> inline constexpr int binary_format<double>::largest_power_of_ten() {
+  return 308;
+}
+
+template <> inline constexpr int binary_format<float>::largest_power_of_ten() {
+  return 38;
+}
+
+template <>
+inline constexpr int binary_format<double>::smallest_power_of_ten() {
+  return -342;
+}
+
+template <> inline constexpr int binary_format<float>::smallest_power_of_ten() {
+  return -64;
+}
+
+template <> inline constexpr size_t binary_format<double>::max_digits() {
+  return 769;
+}
+
+template <> inline constexpr size_t binary_format<float>::max_digits() {
+  return 114;
+}
+
+template <>
+inline constexpr binary_format<float>::equiv_uint
+binary_format<float>::exponent_mask() {
+  return 0x7F800000;
+}
+
+template <>
+inline constexpr binary_format<double>::equiv_uint
+binary_format<double>::exponent_mask() {
+  return 0x7FF0000000000000;
+}
+
+template <>
+inline constexpr binary_format<float>::equiv_uint
+binary_format<float>::mantissa_mask() {
+  return 0x007FFFFF;
+}
+
+template <>
+inline constexpr binary_format<double>::equiv_uint
+binary_format<double>::mantissa_mask() {
+  return 0x000FFFFFFFFFFFFF;
+}
+
+template <>
+inline constexpr binary_format<float>::equiv_uint
+binary_format<float>::hidden_bit_mask() {
+  return 0x00800000;
+}
+
+template <>
+inline constexpr binary_format<double>::equiv_uint
+binary_format<double>::hidden_bit_mask() {
+  return 0x0010000000000000;
+}
+
+template <typename T>
+fastfloat_really_inline GLZ_FASTFLOAT_CONSTEXPR20 void
+to_float(bool negative, adjusted_mantissa am, T &value) {
+  using equiv_uint = equiv_uint_t<T>;
+  equiv_uint word = equiv_uint(am.mantissa);
+  word = equiv_uint(word | equiv_uint(am.power2)
+                               << binary_format<T>::mantissa_explicit_bits());
+  word =
+      equiv_uint(word | equiv_uint(negative) << binary_format<T>::sign_index());
+#if GLZ_FASTFLOAT_HAS_BIT_CAST
+  value = std::bit_cast<T>(word);
+#else
+  ::memcpy(&value, &word, sizeof(T));
+#endif
+}
+
+template <typename = void> struct space_lut {
+  static constexpr bool value[] = {
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+};
+
+#if GLZ_FASTFLOAT_DETAIL_MUST_DEFINE_CONSTEXPR_VARIABLE
+
+template <typename T> constexpr bool space_lut<T>::value[];
+
+#endif
+
+template <typename UC> constexpr bool is_space(UC c) {
+  return c < 256 && space_lut<>::value[uint8_t(c)];
+}
+
+template <typename UC> static constexpr uint64_t int_cmp_zeros() {
+  static_assert((sizeof(UC) == 1) || (sizeof(UC) == 2) || (sizeof(UC) == 4),
+                "Unsupported character size");
+  return (sizeof(UC) == 1) ? 0x3030303030303030
+         : (sizeof(UC) == 2)
+             ? (uint64_t(UC('0')) << 48 | uint64_t(UC('0')) << 32 |
+                uint64_t(UC('0')) << 16 | UC('0'))
+             : (uint64_t(UC('0')) << 32 | UC('0'));
+}
+
+template <typename UC> static constexpr int int_cmp_len() {
+  return sizeof(uint64_t) / sizeof(UC);
+}
+
+template <typename UC> constexpr UC const *str_const_nan();
+
+template <> constexpr char const *str_const_nan<char>() { return "nan"; }
+
+template <> constexpr wchar_t const *str_const_nan<wchar_t>() { return L"nan"; }
+
+template <> constexpr char16_t const *str_const_nan<char16_t>() {
+  return u"nan";
+}
+
+template <> constexpr char32_t const *str_const_nan<char32_t>() {
+  return U"nan";
+}
+
+#ifdef __cpp_char8_t
+template <> constexpr char8_t const *str_const_nan<char8_t>() {
+  return u8"nan";
+}
+#endif
+
+template <typename UC> constexpr UC const *str_const_inf();
+
+template <> constexpr char const *str_const_inf<char>() { return "infinity"; }
+
+template <> constexpr wchar_t const *str_const_inf<wchar_t>() {
+  return L"infinity";
+}
+
+template <> constexpr char16_t const *str_const_inf<char16_t>() {
+  return u"infinity";
+}
+
+template <> constexpr char32_t const *str_const_inf<char32_t>() {
+  return U"infinity";
+}
+
+#ifdef __cpp_char8_t
+template <> constexpr char8_t const *str_const_inf<char8_t>() {
+  return u8"infinity";
+}
+#endif
+
+template <typename = void> struct int_luts {
+  static constexpr uint8_t chdigit[] = {
+      255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+      255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+      255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+      255, 255, 255, 0,   1,   2,   3,   4,   5,   6,   7,   8,   9,   255, 255,
+      255, 255, 255, 255, 255, 10,  11,  12,  13,  14,  15,  16,  17,  18,  19,
+      20,  21,  22,  23,  24,  25,  26,  27,  28,  29,  30,  31,  32,  33,  34,
+      35,  255, 255, 255, 255, 255, 255, 10,  11,  12,  13,  14,  15,  16,  17,
+      18,  19,  20,  21,  22,  23,  24,  25,  26,  27,  28,  29,  30,  31,  32,
+      33,  34,  35,  255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+      255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+      255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+      255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+      255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+      255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+      255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+      255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+      255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+      255};
+
+  static constexpr size_t maxdigits_u64[] = {
+      64, 41, 32, 28, 25, 23, 22, 21, 20, 19, 18, 18, 17, 17, 16, 16, 16, 16,
+      15, 15, 15, 15, 14, 14, 14, 14, 14, 14, 14, 13, 13, 13, 13, 13, 13};
+
+  static constexpr uint64_t min_safe_u64[] = {
+      9223372036854775808ull,  12157665459056928801ull, 4611686018427387904,
+      7450580596923828125,     4738381338321616896,     3909821048582988049,
+      9223372036854775808ull,  12157665459056928801ull, 10000000000000000000ull,
+      5559917313492231481,     2218611106740436992,     8650415919381337933,
+      2177953337809371136,     6568408355712890625,     1152921504606846976,
+      2862423051509815793,     6746640616477458432,     15181127029874798299ull,
+      1638400000000000000,     3243919932521508681,     6221821273427820544,
+      11592836324538749809ull, 876488338465357824,      1490116119384765625,
+      2481152873203736576,     4052555153018976267,     6502111422497947648,
+      10260628712958602189ull, 15943230000000000000ull, 787662783788549761,
+      1152921504606846976,     1667889514952984961,     2386420683693101056,
+      3379220508056640625,     4738381338321616896};
+};
+
+#if GLZ_FASTFLOAT_DETAIL_MUST_DEFINE_CONSTEXPR_VARIABLE
+
+template <typename T> constexpr uint8_t int_luts<T>::chdigit[];
+
+template <typename T> constexpr size_t int_luts<T>::maxdigits_u64[];
+
+template <typename T> constexpr uint64_t int_luts<T>::min_safe_u64[];
+
+#endif
+
+template <typename UC>
+fastfloat_really_inline constexpr uint8_t ch_to_digit(UC c) {
+  return int_luts<>::chdigit[static_cast<unsigned char>(c)];
+}
+
+fastfloat_really_inline constexpr size_t max_digits_u64(int base) {
+  return int_luts<>::maxdigits_u64[base - 2];
+}
+
+// If a u64 is exactly max_digits_u64() in length, this is
+// the value below which it has definitely overflowed.
+fastfloat_really_inline constexpr uint64_t min_safe_u64(int base) {
+  return int_luts<>::min_safe_u64[base - 2];
+}
+
+static_assert(std::is_same<equiv_uint_t<double>, uint64_t>::value,
+              "equiv_uint should be uint64_t for double");
+static_assert(std::numeric_limits<double>::is_iec559,
+              "double must fulfill the requirements of IEC 559 (IEEE 754)");
+
+static_assert(std::is_same<equiv_uint_t<float>, uint32_t>::value,
+              "equiv_uint should be uint32_t for float");
+static_assert(std::numeric_limits<float>::is_iec559,
+              "float must fulfill the requirements of IEC 559 (IEEE 754)");
+
+#ifdef __STDCPP_FLOAT64_T__
+static_assert(std::is_same<equiv_uint_t<std::float64_t>, uint64_t>::value,
+              "equiv_uint should be uint64_t for std::float64_t");
+static_assert(
+    std::numeric_limits<std::float64_t>::is_iec559,
+    "std::float64_t must fulfill the requirements of IEC 559 (IEEE 754)");
+#endif // __STDCPP_FLOAT64_T__
+
+#ifdef __STDCPP_FLOAT32_T__
+static_assert(std::is_same<equiv_uint_t<std::float32_t>, uint32_t>::value,
+              "equiv_uint should be uint32_t for std::float32_t");
+static_assert(
+    std::numeric_limits<std::float32_t>::is_iec559,
+    "std::float32_t must fulfill the requirements of IEC 559 (IEEE 754)");
+#endif // __STDCPP_FLOAT32_T__
+
+#ifdef __STDCPP_FLOAT16_T__
+static_assert(
+    std::is_same<binary_format<std::float16_t>::equiv_uint, uint16_t>::value,
+    "equiv_uint should be uint16_t for std::float16_t");
+static_assert(
+    std::numeric_limits<std::float16_t>::is_iec559,
+    "std::float16_t must fulfill the requirements of IEC 559 (IEEE 754)");
+#endif // __STDCPP_FLOAT16_T__
+
+#ifdef __STDCPP_BFLOAT16_T__
+static_assert(
+    std::is_same<binary_format<std::bfloat16_t>::equiv_uint, uint16_t>::value,
+    "equiv_uint should be uint16_t for std::bfloat16_t");
+static_assert(
+    std::numeric_limits<std::bfloat16_t>::is_iec559,
+    "std::bfloat16_t must fulfill the requirements of IEC 559 (IEEE 754)");
+#endif // __STDCPP_BFLOAT16_T__
+
+constexpr chars_format operator~(chars_format rhs) noexcept {
+  using int_type = std::underlying_type<chars_format>::type;
+  return static_cast<chars_format>(~static_cast<int_type>(rhs));
+}
+
+constexpr chars_format operator&(chars_format lhs, chars_format rhs) noexcept {
+  using int_type = std::underlying_type<chars_format>::type;
+  return static_cast<chars_format>(static_cast<int_type>(lhs) &
+                                   static_cast<int_type>(rhs));
+}
+
+constexpr chars_format operator|(chars_format lhs, chars_format rhs) noexcept {
+  using int_type = std::underlying_type<chars_format>::type;
+  return static_cast<chars_format>(static_cast<int_type>(lhs) |
+                                   static_cast<int_type>(rhs));
+}
+
+constexpr chars_format operator^(chars_format lhs, chars_format rhs) noexcept {
+  using int_type = std::underlying_type<chars_format>::type;
+  return static_cast<chars_format>(static_cast<int_type>(lhs) ^
+                                   static_cast<int_type>(rhs));
+}
+
+fastfloat_really_inline GLZ_FASTFLOAT_CONSTEXPR14 chars_format &
+operator&=(chars_format &lhs, chars_format rhs) noexcept {
+  return lhs = (lhs & rhs);
+}
+
+fastfloat_really_inline GLZ_FASTFLOAT_CONSTEXPR14 chars_format &
+operator|=(chars_format &lhs, chars_format rhs) noexcept {
+  return lhs = (lhs | rhs);
+}
+
+fastfloat_really_inline GLZ_FASTFLOAT_CONSTEXPR14 chars_format &
+operator^=(chars_format &lhs, chars_format rhs) noexcept {
+  return lhs = (lhs ^ rhs);
+}
+
+namespace detail {
+// adjust for deprecated feature macros
+constexpr chars_format adjust_for_feature_macros(chars_format fmt) {
+  return fmt
+#ifdef GLZ_FASTFLOAT_ALLOWS_LEADING_PLUS
+         | chars_format::allow_leading_plus
+#endif
+#ifdef GLZ_FASTFLOAT_SKIP_WHITE_SPACE
+         | chars_format::skip_white_space
+#endif
+      ;
+}
+} // namespace detail
+
+} // namespace glz::fast_float
+
+#endif
+
+
+#ifndef GLZ_FASTFLOAT_FAST_FLOAT_H
+#define GLZ_FASTFLOAT_FAST_FLOAT_H
+
+
+namespace glz::fast_float {
+/**
+ * This function parses the character sequence [first,last) for a number. It
+ * parses floating-point numbers expecting a locale-indepent format equivalent
+ * to what is used by std::strtod in the default ("C") locale. The resulting
+ * floating-point value is the closest floating-point values (using either float
+ * or double), using the "round to even" convention for values that would
+ * otherwise fall right in-between two values. That is, we provide exact parsing
+ * according to the IEEE standard.
+ *
+ * Given a successful parse, the pointer (`ptr`) in the returned value is set to
+ * point right after the parsed number, and the `value` referenced is set to the
+ * parsed value. In case of error, the returned `ec` contains a representative
+ * error, otherwise the default (`std::errc()`) value is stored.
+ *
+ * The implementation does not throw and does not allocate memory (e.g., with
+ * `new` or `malloc`).
+ *
+ * Like the C++17 standard, the `fast_float::from_chars` functions take an
+ * optional last argument of the type `fast_float::chars_format`. It is a bitset
+ * value: we check whether `fmt & fast_float::chars_format::fixed` and `fmt &
+ * fast_float::chars_format::scientific` are set to determine whether we allow
+ * the fixed point and scientific notation respectively. The default is
+ * `fast_float::chars_format::general` which allows both `fixed` and
+ * `scientific`.
+ */
+template <typename T, typename UC = char,
+          typename = GLZ_FASTFLOAT_ENABLE_IF(is_supported_float_type<T>::value)>
+GLZ_FASTFLOAT_CONSTEXPR20 from_chars_result_t<UC>
+from_chars(UC const *first, UC const *last, T &value,
+           chars_format fmt = chars_format::general) noexcept;
+
+/**
+ * Like from_chars, but accepts an `options` argument to govern number parsing.
+ * Both for floating-point types and integer types.
+ */
+template <typename T, typename UC = char>
+GLZ_FASTFLOAT_CONSTEXPR20 from_chars_result_t<UC>
+from_chars_advanced(UC const *first, UC const *last, T &value,
+                    parse_options_t<UC> options) noexcept;
+
+/**
+ * from_chars for integer types.
+ */
+template <typename T, typename UC = char,
+          typename = GLZ_FASTFLOAT_ENABLE_IF(is_supported_integer_type<T>::value)>
+GLZ_FASTFLOAT_CONSTEXPR20 from_chars_result_t<UC>
+from_chars(UC const *first, UC const *last, T &value, int base = 10) noexcept;
+
+} // namespace glz::fast_float
+
+#endif // GLZ_FASTFLOAT_FAST_FLOAT_H
+
+#ifndef GLZ_FASTFLOAT_ASCII_NUMBER_H
+#define GLZ_FASTFLOAT_ASCII_NUMBER_H
+
+#include <cctype>
+#include <cstdint>
+#include <cstring>
+#include <iterator>
+#include <limits>
+#include <type_traits>
+
+
+#ifdef GLZ_FASTFLOAT_SSE2
+#include <emmintrin.h>
+#endif
+
+#ifdef GLZ_FASTFLOAT_NEON
+#include <arm_neon.h>
+#endif
+
+namespace glz::fast_float {
+
+template <typename UC> fastfloat_really_inline constexpr bool has_simd_opt() {
+#ifdef GLZ_FASTFLOAT_HAS_SIMD
+  return std::is_same<UC, char16_t>::value;
+#else
+  return false;
+#endif
+}
+
+// Next function can be micro-optimized, but compilers are entirely
+// able to optimize it well.
+template <typename UC>
+fastfloat_really_inline constexpr bool is_integer(UC c) noexcept {
+  return !(c > UC('9') || c < UC('0'));
+}
+
+fastfloat_really_inline constexpr uint64_t byteswap(uint64_t val) {
+  return (val & 0xFF00000000000000) >> 56 | (val & 0x00FF000000000000) >> 40 |
+         (val & 0x0000FF0000000000) >> 24 | (val & 0x000000FF00000000) >> 8 |
+         (val & 0x00000000FF000000) << 8 | (val & 0x0000000000FF0000) << 24 |
+         (val & 0x000000000000FF00) << 40 | (val & 0x00000000000000FF) << 56;
+}
+
+// Read 8 UC into a u64. Truncates UC if not char.
+template <typename UC>
+fastfloat_really_inline GLZ_FASTFLOAT_CONSTEXPR20 uint64_t
+read8_to_u64(UC const *chars) {
+  if (cpp20_and_in_constexpr() || !std::is_same<UC, char>::value) {
+    uint64_t val = 0;
+    for (int i = 0; i < 8; ++i) {
+      val |= uint64_t(uint8_t(*chars)) << (i * 8);
+      ++chars;
+    }
+    return val;
+  }
+  uint64_t val;
+  ::memcpy(&val, chars, sizeof(uint64_t));
+#if GLZ_FASTFLOAT_IS_BIG_ENDIAN == 1
+  // Need to read as-if the number was in little-endian order.
+  val = byteswap(val);
+#endif
+  return val;
+}
+
+#ifdef GLZ_FASTFLOAT_SSE2
+
+fastfloat_really_inline uint64_t simd_read8_to_u64(__m128i const data) {
+  GLZ_FASTFLOAT_SIMD_DISABLE_WARNINGS
+  __m128i const packed = _mm_packus_epi16(data, data);
+#ifdef GLZ_FASTFLOAT_64BIT
+  return uint64_t(_mm_cvtsi128_si64(packed));
+#else
+  uint64_t value;
+  // Visual Studio + older versions of GCC don't support _mm_storeu_si64
+  _mm_storel_epi64(reinterpret_cast<__m128i *>(&value), packed);
+  return value;
+#endif
+  GLZ_FASTFLOAT_SIMD_RESTORE_WARNINGS
+}
+
+fastfloat_really_inline uint64_t simd_read8_to_u64(char16_t const *chars) {
+  GLZ_FASTFLOAT_SIMD_DISABLE_WARNINGS
+  return simd_read8_to_u64(
+      _mm_loadu_si128(reinterpret_cast<__m128i const *>(chars)));
+  GLZ_FASTFLOAT_SIMD_RESTORE_WARNINGS
+}
+
+#elif defined(GLZ_FASTFLOAT_NEON)
+
+fastfloat_really_inline uint64_t simd_read8_to_u64(uint16x8_t const data) {
+  GLZ_FASTFLOAT_SIMD_DISABLE_WARNINGS
+  uint8x8_t utf8_packed = vmovn_u16(data);
+  return vget_lane_u64(vreinterpret_u64_u8(utf8_packed), 0);
+  GLZ_FASTFLOAT_SIMD_RESTORE_WARNINGS
+}
+
+fastfloat_really_inline uint64_t simd_read8_to_u64(char16_t const *chars) {
+  GLZ_FASTFLOAT_SIMD_DISABLE_WARNINGS
+  return simd_read8_to_u64(
+      vld1q_u16(reinterpret_cast<uint16_t const *>(chars)));
+  GLZ_FASTFLOAT_SIMD_RESTORE_WARNINGS
+}
+
+#endif // GLZ_FASTFLOAT_SSE2
+
+// MSVC SFINAE is broken pre-VS2017
+#if defined(_MSC_VER) && _MSC_VER <= 1900
+template <typename UC>
+#else
+template <typename UC, GLZ_FASTFLOAT_ENABLE_IF(!has_simd_opt<UC>()) = 0>
+#endif
+// dummy for compile
+uint64_t simd_read8_to_u64(UC const *) {
+  return 0;
+}
+
+// credit  @aqrit
+fastfloat_really_inline GLZ_FASTFLOAT_CONSTEXPR14 uint32_t
+parse_eight_digits_unrolled(uint64_t val) {
+  uint64_t const mask = 0x000000FF000000FF;
+  uint64_t const mul1 = 0x000F424000000064; // 100 + (1000000ULL << 32)
+  uint64_t const mul2 = 0x0000271000000001; // 1 + (10000ULL << 32)
+  val -= 0x3030303030303030;
+  val = (val * 10) + (val >> 8); // val = (val * 2561) >> 8;
+  val = (((val & mask) * mul1) + (((val >> 16) & mask) * mul2)) >> 32;
+  return uint32_t(val);
+}
+
+// Call this if chars are definitely 8 digits.
+template <typename UC>
+fastfloat_really_inline GLZ_FASTFLOAT_CONSTEXPR20 uint32_t
+parse_eight_digits_unrolled(UC const *chars) noexcept {
+  if (cpp20_and_in_constexpr() || !has_simd_opt<UC>()) {
+    return parse_eight_digits_unrolled(read8_to_u64(chars)); // truncation okay
+  }
+  return parse_eight_digits_unrolled(simd_read8_to_u64(chars));
+}
+
+// credit @aqrit
+fastfloat_really_inline constexpr bool
+is_made_of_eight_digits_fast(uint64_t val) noexcept {
+  return !((((val + 0x4646464646464646) | (val - 0x3030303030303030)) &
+            0x8080808080808080));
+}
+
+#ifdef GLZ_FASTFLOAT_HAS_SIMD
+
+// Call this if chars might not be 8 digits.
+// Using this style (instead of is_made_of_eight_digits_fast() then
+// parse_eight_digits_unrolled()) ensures we don't load SIMD registers twice.
+fastfloat_really_inline GLZ_FASTFLOAT_CONSTEXPR20 bool
+simd_parse_if_eight_digits_unrolled(char16_t const *chars,
+                                    uint64_t &i) noexcept {
+  if (cpp20_and_in_constexpr()) {
+    return false;
+  }
+#ifdef GLZ_FASTFLOAT_SSE2
+  GLZ_FASTFLOAT_SIMD_DISABLE_WARNINGS
+  __m128i const data =
+      _mm_loadu_si128(reinterpret_cast<__m128i const *>(chars));
+
+  // (x - '0') <= 9
+  // http://0x80.pl/articles/simd-parsing-int-sequences.html
+  __m128i const t0 = _mm_add_epi16(data, _mm_set1_epi16(32720));
+  __m128i const t1 = _mm_cmpgt_epi16(t0, _mm_set1_epi16(-32759));
+
+  if (_mm_movemask_epi8(t1) == 0) {
+    i = i * 100000000 + parse_eight_digits_unrolled(simd_read8_to_u64(data));
+    return true;
+  } else
+    return false;
+  GLZ_FASTFLOAT_SIMD_RESTORE_WARNINGS
+#elif defined(GLZ_FASTFLOAT_NEON)
+  GLZ_FASTFLOAT_SIMD_DISABLE_WARNINGS
+  uint16x8_t const data = vld1q_u16(reinterpret_cast<uint16_t const *>(chars));
+
+  // (x - '0') <= 9
+  // http://0x80.pl/articles/simd-parsing-int-sequences.html
+  uint16x8_t const t0 = vsubq_u16(data, vmovq_n_u16('0'));
+  uint16x8_t const mask = vcltq_u16(t0, vmovq_n_u16('9' - '0' + 1));
+
+  if (vminvq_u16(mask) == 0xFFFF) {
+    i = i * 100000000 + parse_eight_digits_unrolled(simd_read8_to_u64(data));
+    return true;
+  } else
+    return false;
+  GLZ_FASTFLOAT_SIMD_RESTORE_WARNINGS
+#else
+  (void)chars;
+  (void)i;
+  return false;
+#endif // GLZ_FASTFLOAT_SSE2
+}
+
+#endif // GLZ_FASTFLOAT_HAS_SIMD
+
+// MSVC SFINAE is broken pre-VS2017
+#if defined(_MSC_VER) && _MSC_VER <= 1900
+template <typename UC>
+#else
+template <typename UC, GLZ_FASTFLOAT_ENABLE_IF(!has_simd_opt<UC>()) = 0>
+#endif
+// dummy for compile
+bool simd_parse_if_eight_digits_unrolled(UC const *, uint64_t &) {
+  return 0;
+}
+
+template <typename UC, GLZ_FASTFLOAT_ENABLE_IF(!std::is_same<UC, char>::value) = 0>
+fastfloat_really_inline GLZ_FASTFLOAT_CONSTEXPR20 void
+loop_parse_if_eight_digits(UC const *&p, UC const *const pend, uint64_t &i) {
+  if (!has_simd_opt<UC>()) {
+    return;
+  }
+  while ((std::distance(p, pend) >= 8) &&
+         simd_parse_if_eight_digits_unrolled(
+             p, i)) { // in rare cases, this will overflow, but that's ok
+    p += 8;
+  }
+}
+
+fastfloat_really_inline GLZ_FASTFLOAT_CONSTEXPR20 void
+loop_parse_if_eight_digits(char const *&p, char const *const pend,
+                           uint64_t &i) {
+  // optimizes better than parse_if_eight_digits_unrolled() for UC = char.
+  while ((std::distance(p, pend) >= 8) &&
+         is_made_of_eight_digits_fast(read8_to_u64(p))) {
+    i = i * 100000000 +
+        parse_eight_digits_unrolled(read8_to_u64(
+            p)); // in rare cases, this will overflow, but that's ok
+    p += 8;
+  }
+}
+
+enum class parse_error {
+  no_error,
+  // [JSON-only] The minus sign must be followed by an integer.
+  missing_integer_after_sign,
+  // A sign must be followed by an integer or dot.
+  missing_integer_or_dot_after_sign,
+  // [JSON-only] The integer part must not have leading zeros.
+  leading_zeros_in_integer_part,
+  // [JSON-only] The integer part must have at least one digit.
+  no_digits_in_integer_part,
+  // [JSON-only] If there is a decimal point, there must be digits in the
+  // fractional part.
+  no_digits_in_fractional_part,
+  // The mantissa must have at least one digit.
+  no_digits_in_mantissa,
+  // Scientific notation requires an exponential part.
+  missing_exponential_part,
+};
+
+template <typename UC> struct parsed_number_string_t {
+  int64_t exponent{0};
+  uint64_t mantissa{0};
+  UC const *lastmatch{nullptr};
+  bool negative{false};
+  bool valid{false};
+  bool too_many_digits{false};
+  // contains the range of the significant digits
+  span<UC const> integer{};  // non-nullable
+  span<UC const> fraction{}; // nullable
+  parse_error error{parse_error::no_error};
+};
+
+using byte_span = span<char const>;
+using parsed_number_string = parsed_number_string_t<char>;
+
+template <typename UC>
+fastfloat_really_inline GLZ_FASTFLOAT_CONSTEXPR20 parsed_number_string_t<UC>
+report_parse_error(UC const *p, parse_error error) {
+  parsed_number_string_t<UC> answer;
+  answer.valid = false;
+  answer.lastmatch = p;
+  answer.error = error;
+  return answer;
+}
+
+// Assuming that you use no more than 19 digits, this will
+// parse an ASCII string.
+template <bool basic_json_fmt, typename UC>
+fastfloat_really_inline GLZ_FASTFLOAT_CONSTEXPR20 parsed_number_string_t<UC>
+parse_number_string(UC const *p, UC const *pend,
+                    parse_options_t<UC> options) noexcept {
+  chars_format const fmt = detail::adjust_for_feature_macros(options.format);
+  UC const decimal_point = options.decimal_point;
+
+  parsed_number_string_t<UC> answer;
+  answer.valid = false;
+  answer.too_many_digits = false;
+  // assume p < pend, so dereference without checks;
+  answer.negative = (*p == UC('-'));
+  // C++17 20.19.3.(7.1) explicitly forbids '+' sign here
+  if ((*p == UC('-')) || (uint64_t(fmt & chars_format::allow_leading_plus) &&
+                          !basic_json_fmt && *p == UC('+'))) {
+    ++p;
+    if (p == pend) {
+      return report_parse_error<UC>(
+          p, parse_error::missing_integer_or_dot_after_sign);
+    }
+    GLZ_FASTFLOAT_IF_CONSTEXPR17(basic_json_fmt) {
+      if (!is_integer(*p)) { // a sign must be followed by an integer
+        return report_parse_error<UC>(p,
+                                      parse_error::missing_integer_after_sign);
+      }
+    }
+    else {
+      if (!is_integer(*p) &&
+          (*p !=
+           decimal_point)) { // a sign must be followed by an integer or the dot
+        return report_parse_error<UC>(
+            p, parse_error::missing_integer_or_dot_after_sign);
+      }
+    }
+  }
+  UC const *const start_digits = p;
+
+  uint64_t i = 0; // an unsigned int avoids signed overflows (which are bad)
+
+  while ((p != pend) && is_integer(*p)) {
+    // a multiplication by 10 is cheaper than an arbitrary integer
+    // multiplication
+    i = 10 * i +
+        uint64_t(*p -
+                 UC('0')); // might overflow, we will handle the overflow later
+    ++p;
+  }
+  UC const *const end_of_integer_part = p;
+  int64_t digit_count = int64_t(end_of_integer_part - start_digits);
+  answer.integer = span<UC const>(start_digits, size_t(digit_count));
+  GLZ_FASTFLOAT_IF_CONSTEXPR17(basic_json_fmt) {
+    // at least 1 digit in integer part, without leading zeros
+    if (digit_count == 0) {
+      return report_parse_error<UC>(p, parse_error::no_digits_in_integer_part);
+    }
+    if ((start_digits[0] == UC('0') && digit_count > 1)) {
+      return report_parse_error<UC>(start_digits,
+                                    parse_error::leading_zeros_in_integer_part);
+    }
+  }
+
+  int64_t exponent = 0;
+  bool const has_decimal_point = (p != pend) && (*p == decimal_point);
+  if (has_decimal_point) {
+    ++p;
+    UC const *before = p;
+    // can occur at most twice without overflowing, but let it occur more, since
+    // for integers with many digits, digit parsing is the primary bottleneck.
+    loop_parse_if_eight_digits(p, pend, i);
+
+    while ((p != pend) && is_integer(*p)) {
+      uint8_t digit = uint8_t(*p - UC('0'));
+      ++p;
+      i = i * 10 + digit; // in rare cases, this will overflow, but that's ok
+    }
+    exponent = before - p;
+    answer.fraction = span<UC const>(before, size_t(p - before));
+    digit_count -= exponent;
+  }
+  GLZ_FASTFLOAT_IF_CONSTEXPR17(basic_json_fmt) {
+    // at least 1 digit in fractional part
+    if (has_decimal_point && exponent == 0) {
+      return report_parse_error<UC>(p,
+                                    parse_error::no_digits_in_fractional_part);
+    }
+  }
+  else if (digit_count == 0) { // we must have encountered at least one integer!
+    return report_parse_error<UC>(p, parse_error::no_digits_in_mantissa);
+  }
+  int64_t exp_number = 0; // explicit exponential part
+  if ((uint64_t(fmt & chars_format::scientific) && (p != pend) &&
+       ((UC('e') == *p) || (UC('E') == *p))) ||
+      (uint64_t(fmt & detail::basic_fortran_fmt) && (p != pend) &&
+       ((UC('+') == *p) || (UC('-') == *p) || (UC('d') == *p) ||
+        (UC('D') == *p)))) {
+    UC const *location_of_e = p;
+    if ((UC('e') == *p) || (UC('E') == *p) || (UC('d') == *p) ||
+        (UC('D') == *p)) {
+      ++p;
+    }
+    bool neg_exp = false;
+    if ((p != pend) && (UC('-') == *p)) {
+      neg_exp = true;
+      ++p;
+    } else if ((p != pend) &&
+               (UC('+') ==
+                *p)) { // '+' on exponent is allowed by C++17 20.19.3.(7.1)
+      ++p;
+    }
+    if ((p == pend) || !is_integer(*p)) {
+      if (!uint64_t(fmt & chars_format::fixed)) {
+        // The exponential part is invalid for scientific notation, so it must
+        // be a trailing token for fixed notation. However, fixed notation is
+        // disabled, so report a scientific notation error.
+        return report_parse_error<UC>(p, parse_error::missing_exponential_part);
+      }
+      // Otherwise, we will be ignoring the 'e'.
+      p = location_of_e;
+    } else {
+      while ((p != pend) && is_integer(*p)) {
+        uint8_t digit = uint8_t(*p - UC('0'));
+        if (exp_number < 0x10000000) {
+          exp_number = 10 * exp_number + digit;
+        }
+        ++p;
+      }
+      if (neg_exp) {
+        exp_number = -exp_number;
+      }
+      exponent += exp_number;
+    }
+  } else {
+    // If it scientific and not fixed, we have to bail out.
+    if (uint64_t(fmt & chars_format::scientific) &&
+        !uint64_t(fmt & chars_format::fixed)) {
+      return report_parse_error<UC>(p, parse_error::missing_exponential_part);
+    }
+  }
+  answer.lastmatch = p;
+  answer.valid = true;
+
+  // If we frequently had to deal with long strings of digits,
+  // we could extend our code by using a 128-bit integer instead
+  // of a 64-bit integer. However, this is uncommon.
+  //
+  // We can deal with up to 19 digits.
+  if (digit_count > 19) { // this is uncommon
+    // It is possible that the integer had an overflow.
+    // We have to handle the case where we have 0.0000somenumber.
+    // We need to be mindful of the case where we only have zeroes...
+    // E.g., 0.000000000...000.
+    UC const *start = start_digits;
+    while ((start != pend) && (*start == UC('0') || *start == decimal_point)) {
+      if (*start == UC('0')) {
+        digit_count--;
+      }
+      start++;
+    }
+
+    if (digit_count > 19) {
+      answer.too_many_digits = true;
+      // Let us start again, this time, avoiding overflows.
+      // We don't need to check if is_integer, since we use the
+      // pre-tokenized spans from above.
+      i = 0;
+      p = answer.integer.ptr;
+      UC const *int_end = p + answer.integer.len();
+      uint64_t const minimal_nineteen_digit_integer{1000000000000000000};
+      while ((i < minimal_nineteen_digit_integer) && (p != int_end)) {
+        i = i * 10 + uint64_t(*p - UC('0'));
+        ++p;
+      }
+      if (i >= minimal_nineteen_digit_integer) { // We have a big integers
+        exponent = end_of_integer_part - p + exp_number;
+      } else { // We have a value with a fractional component.
+        p = answer.fraction.ptr;
+        UC const *frac_end = p + answer.fraction.len();
+        while ((i < minimal_nineteen_digit_integer) && (p != frac_end)) {
+          i = i * 10 + uint64_t(*p - UC('0'));
+          ++p;
+        }
+        exponent = answer.fraction.ptr - p + exp_number;
+      }
+      // We have now corrected both exponent and i, to a truncated value
+    }
+  }
+  answer.exponent = exponent;
+  answer.mantissa = i;
+  return answer;
+}
+
+template <typename T, typename UC>
+fastfloat_really_inline GLZ_FASTFLOAT_CONSTEXPR20 from_chars_result_t<UC>
+parse_int_string(UC const *p, UC const *pend, T &value,
+                 parse_options_t<UC> options) {
+  chars_format const fmt = detail::adjust_for_feature_macros(options.format);
+  int const base = options.base;
+
+  from_chars_result_t<UC> answer;
+
+  UC const *const first = p;
+
+  bool const negative = (*p == UC('-'));
+#ifdef GLZ_FASTFLOAT_VISUAL_STUDIO
+#pragma warning(push)
+#pragma warning(disable : 4127)
+#endif
+  if (!std::is_signed<T>::value && negative) {
+#ifdef GLZ_FASTFLOAT_VISUAL_STUDIO
+#pragma warning(pop)
+#endif
+    answer.ec = std::errc::invalid_argument;
+    answer.ptr = first;
+    return answer;
+  }
+  if ((*p == UC('-')) ||
+      (uint64_t(fmt & chars_format::allow_leading_plus) && (*p == UC('+')))) {
+    ++p;
+  }
+
+  UC const *const start_num = p;
+
+  while (p != pend && *p == UC('0')) {
+    ++p;
+  }
+
+  bool const has_leading_zeros = p > start_num;
+
+  UC const *const start_digits = p;
+
+  uint64_t i = 0;
+  if (base == 10) {
+    loop_parse_if_eight_digits(p, pend, i); // use SIMD if possible
+  }
+  while (p != pend) {
+    uint8_t digit = ch_to_digit(*p);
+    if (digit >= base) {
+      break;
+    }
+    i = uint64_t(base) * i + digit; // might overflow, check this later
+    p++;
+  }
+
+  size_t digit_count = size_t(p - start_digits);
+
+  if (digit_count == 0) {
+    if (has_leading_zeros) {
+      value = 0;
+      answer.ec = std::errc();
+      answer.ptr = p;
+    } else {
+      answer.ec = std::errc::invalid_argument;
+      answer.ptr = first;
+    }
+    return answer;
+  }
+
+  answer.ptr = p;
+
+  // check u64 overflow
+  size_t max_digits = max_digits_u64(base);
+  if (digit_count > max_digits) {
+    answer.ec = std::errc::result_out_of_range;
+    return answer;
+  }
+  // this check can be eliminated for all other types, but they will all require
+  // a max_digits(base) equivalent
+  if (digit_count == max_digits && i < min_safe_u64(base)) {
+    answer.ec = std::errc::result_out_of_range;
+    return answer;
+  }
+
+  // check other types overflow
+  if (!std::is_same<T, uint64_t>::value) {
+    if (i > uint64_t(std::numeric_limits<T>::max()) + uint64_t(negative)) {
+      answer.ec = std::errc::result_out_of_range;
+      return answer;
+    }
+  }
+
+  if (negative) {
+#ifdef GLZ_FASTFLOAT_VISUAL_STUDIO
+#pragma warning(push)
+#pragma warning(disable : 4146)
+#endif
+    // this weird workaround is required because:
+    // - converting unsigned to signed when its value is greater than signed max
+    // is UB pre-C++23.
+    // - reinterpret_casting (~i + 1) would work, but it is not constexpr
+    // this is always optimized into a neg instruction (note: T is an integer
+    // type)
+    value = T(-std::numeric_limits<T>::max() -
+              T(i - uint64_t(std::numeric_limits<T>::max())));
+#ifdef GLZ_FASTFLOAT_VISUAL_STUDIO
+#pragma warning(pop)
+#endif
+  } else {
+    value = T(i);
+  }
+
+  answer.ec = std::errc();
+  return answer;
+}
+
+} // namespace glz::fast_float
+
+#endif
+
+#ifndef GLZ_FASTFLOAT_FAST_TABLE_H
+#define GLZ_FASTFLOAT_FAST_TABLE_H
+
+#include <cstdint>
+
+namespace glz::fast_float {
+
+/**
+ * When mapping numbers from decimal to binary,
+ * we go from w * 10^q to m * 2^p but we have
+ * 10^q = 5^q * 2^q, so effectively
+ * we are trying to match
+ * w * 2^q * 5^q to m * 2^p. Thus the powers of two
+ * are not a concern since they can be represented
+ * exactly using the binary notation, only the powers of five
+ * affect the binary significand.
+ */
+
+/**
+ * The smallest non-zero float (binary64) is 2^-1074.
+ * We take as input numbers of the form w x 10^q where w < 2^64.
+ * We have that w * 10^-343  <  2^(64-344) 5^-343 < 2^-1076.
+ * However, we have that
+ * (2^64-1) * 10^-342 =  (2^64-1) * 2^-342 * 5^-342 > 2^-1074.
+ * Thus it is possible for a number of the form w * 10^-342 where
+ * w is a 64-bit value to be a non-zero floating-point number.
+ *********
+ * Any number of form w * 10^309 where w>= 1 is going to be
+ * infinite in binary64 so we never need to worry about powers
+ * of 5 greater than 308.
+ */
+template <class unused = void> struct powers_template {
+
+  constexpr static int smallest_power_of_five =
+      binary_format<double>::smallest_power_of_ten();
+  constexpr static int largest_power_of_five =
+      binary_format<double>::largest_power_of_ten();
+  constexpr static int number_of_entries =
+      2 * (largest_power_of_five - smallest_power_of_five + 1);
+  // Powers of five from 5^-342 all the way to 5^308 rounded toward one.
+  constexpr static uint64_t power_of_five_128[number_of_entries] = {
+      0xeef453d6923bd65a, 0x113faa2906a13b3f,
+      0x9558b4661b6565f8, 0x4ac7ca59a424c507,
+      0xbaaee17fa23ebf76, 0x5d79bcf00d2df649,
+      0xe95a99df8ace6f53, 0xf4d82c2c107973dc,
+      0x91d8a02bb6c10594, 0x79071b9b8a4be869,
+      0xb64ec836a47146f9, 0x9748e2826cdee284,
+      0xe3e27a444d8d98b7, 0xfd1b1b2308169b25,
+      0x8e6d8c6ab0787f72, 0xfe30f0f5e50e20f7,
+      0xb208ef855c969f4f, 0xbdbd2d335e51a935,
+      0xde8b2b66b3bc4723, 0xad2c788035e61382,
+      0x8b16fb203055ac76, 0x4c3bcb5021afcc31,
+      0xaddcb9e83c6b1793, 0xdf4abe242a1bbf3d,
+      0xd953e8624b85dd78, 0xd71d6dad34a2af0d,
+      0x87d4713d6f33aa6b, 0x8672648c40e5ad68,
+      0xa9c98d8ccb009506, 0x680efdaf511f18c2,
+      0xd43bf0effdc0ba48, 0x212bd1b2566def2,
+      0x84a57695fe98746d, 0x14bb630f7604b57,
+      0xa5ced43b7e3e9188, 0x419ea3bd35385e2d,
+      0xcf42894a5dce35ea, 0x52064cac828675b9,
+      0x818995ce7aa0e1b2, 0x7343efebd1940993,
+      0xa1ebfb4219491a1f, 0x1014ebe6c5f90bf8,
+      0xca66fa129f9b60a6, 0xd41a26e077774ef6,
+      0xfd00b897478238d0, 0x8920b098955522b4,
+      0x9e20735e8cb16382, 0x55b46e5f5d5535b0,
+      0xc5a890362fddbc62, 0xeb2189f734aa831d,
+      0xf712b443bbd52b7b, 0xa5e9ec7501d523e4,
+      0x9a6bb0aa55653b2d, 0x47b233c92125366e,
+      0xc1069cd4eabe89f8, 0x999ec0bb696e840a,
+      0xf148440a256e2c76, 0xc00670ea43ca250d,
+      0x96cd2a865764dbca, 0x380406926a5e5728,
+      0xbc807527ed3e12bc, 0xc605083704f5ecf2,
+      0xeba09271e88d976b, 0xf7864a44c633682e,
+      0x93445b8731587ea3, 0x7ab3ee6afbe0211d,
+      0xb8157268fdae9e4c, 0x5960ea05bad82964,
+      0xe61acf033d1a45df, 0x6fb92487298e33bd,
+      0x8fd0c16206306bab, 0xa5d3b6d479f8e056,
+      0xb3c4f1ba87bc8696, 0x8f48a4899877186c,
+      0xe0b62e2929aba83c, 0x331acdabfe94de87,
+      0x8c71dcd9ba0b4925, 0x9ff0c08b7f1d0b14,
+      0xaf8e5410288e1b6f, 0x7ecf0ae5ee44dd9,
+      0xdb71e91432b1a24a, 0xc9e82cd9f69d6150,
+      0x892731ac9faf056e, 0xbe311c083a225cd2,
+      0xab70fe17c79ac6ca, 0x6dbd630a48aaf406,
+      0xd64d3d9db981787d, 0x92cbbccdad5b108,
+      0x85f0468293f0eb4e, 0x25bbf56008c58ea5,
+      0xa76c582338ed2621, 0xaf2af2b80af6f24e,
+      0xd1476e2c07286faa, 0x1af5af660db4aee1,
+      0x82cca4db847945ca, 0x50d98d9fc890ed4d,
+      0xa37fce126597973c, 0xe50ff107bab528a0,
+      0xcc5fc196fefd7d0c, 0x1e53ed49a96272c8,
+      0xff77b1fcbebcdc4f, 0x25e8e89c13bb0f7a,
+      0x9faacf3df73609b1, 0x77b191618c54e9ac,
+      0xc795830d75038c1d, 0xd59df5b9ef6a2417,
+      0xf97ae3d0d2446f25, 0x4b0573286b44ad1d,
+      0x9becce62836ac577, 0x4ee367f9430aec32,
+      0xc2e801fb244576d5, 0x229c41f793cda73f,
+      0xf3a20279ed56d48a, 0x6b43527578c1110f,
+      0x9845418c345644d6, 0x830a13896b78aaa9,
+      0xbe5691ef416bd60c, 0x23cc986bc656d553,
+      0xedec366b11c6cb8f, 0x2cbfbe86b7ec8aa8,
+      0x94b3a202eb1c3f39, 0x7bf7d71432f3d6a9,
+      0xb9e08a83a5e34f07, 0xdaf5ccd93fb0cc53,
+      0xe858ad248f5c22c9, 0xd1b3400f8f9cff68,
+      0x91376c36d99995be, 0x23100809b9c21fa1,
+      0xb58547448ffffb2d, 0xabd40a0c2832a78a,
+      0xe2e69915b3fff9f9, 0x16c90c8f323f516c,
+      0x8dd01fad907ffc3b, 0xae3da7d97f6792e3,
+      0xb1442798f49ffb4a, 0x99cd11cfdf41779c,
+      0xdd95317f31c7fa1d, 0x40405643d711d583,
+      0x8a7d3eef7f1cfc52, 0x482835ea666b2572,
+      0xad1c8eab5ee43b66, 0xda3243650005eecf,
+      0xd863b256369d4a40, 0x90bed43e40076a82,
+      0x873e4f75e2224e68, 0x5a7744a6e804a291,
+      0xa90de3535aaae202, 0x711515d0a205cb36,
+      0xd3515c2831559a83, 0xd5a5b44ca873e03,
+      0x8412d9991ed58091, 0xe858790afe9486c2,
+      0xa5178fff668ae0b6, 0x626e974dbe39a872,
+      0xce5d73ff402d98e3, 0xfb0a3d212dc8128f,
+      0x80fa687f881c7f8e, 0x7ce66634bc9d0b99,
+      0xa139029f6a239f72, 0x1c1fffc1ebc44e80,
+      0xc987434744ac874e, 0xa327ffb266b56220,
+      0xfbe9141915d7a922, 0x4bf1ff9f0062baa8,
+      0x9d71ac8fada6c9b5, 0x6f773fc3603db4a9,
+      0xc4ce17b399107c22, 0xcb550fb4384d21d3,
+      0xf6019da07f549b2b, 0x7e2a53a146606a48,
+      0x99c102844f94e0fb, 0x2eda7444cbfc426d,
+      0xc0314325637a1939, 0xfa911155fefb5308,
+      0xf03d93eebc589f88, 0x793555ab7eba27ca,
+      0x96267c7535b763b5, 0x4bc1558b2f3458de,
+      0xbbb01b9283253ca2, 0x9eb1aaedfb016f16,
+      0xea9c227723ee8bcb, 0x465e15a979c1cadc,
+      0x92a1958a7675175f, 0xbfacd89ec191ec9,
+      0xb749faed14125d36, 0xcef980ec671f667b,
+      0xe51c79a85916f484, 0x82b7e12780e7401a,
+      0x8f31cc0937ae58d2, 0xd1b2ecb8b0908810,
+      0xb2fe3f0b8599ef07, 0x861fa7e6dcb4aa15,
+      0xdfbdcece67006ac9, 0x67a791e093e1d49a,
+      0x8bd6a141006042bd, 0xe0c8bb2c5c6d24e0,
+      0xaecc49914078536d, 0x58fae9f773886e18,
+      0xda7f5bf590966848, 0xaf39a475506a899e,
+      0x888f99797a5e012d, 0x6d8406c952429603,
+      0xaab37fd7d8f58178, 0xc8e5087ba6d33b83,
+      0xd5605fcdcf32e1d6, 0xfb1e4a9a90880a64,
+      0x855c3be0a17fcd26, 0x5cf2eea09a55067f,
+      0xa6b34ad8c9dfc06f, 0xf42faa48c0ea481e,
+      0xd0601d8efc57b08b, 0xf13b94daf124da26,
+      0x823c12795db6ce57, 0x76c53d08d6b70858,
+      0xa2cb1717b52481ed, 0x54768c4b0c64ca6e,
+      0xcb7ddcdda26da268, 0xa9942f5dcf7dfd09,
+      0xfe5d54150b090b02, 0xd3f93b35435d7c4c,
+      0x9efa548d26e5a6e1, 0xc47bc5014a1a6daf,
+      0xc6b8e9b0709f109a, 0x359ab6419ca1091b,
+      0xf867241c8cc6d4c0, 0xc30163d203c94b62,
+      0x9b407691d7fc44f8, 0x79e0de63425dcf1d,
+      0xc21094364dfb5636, 0x985915fc12f542e4,
+      0xf294b943e17a2bc4, 0x3e6f5b7b17b2939d,
+      0x979cf3ca6cec5b5a, 0xa705992ceecf9c42,
+      0xbd8430bd08277231, 0x50c6ff782a838353,
+      0xece53cec4a314ebd, 0xa4f8bf5635246428,
+      0x940f4613ae5ed136, 0x871b7795e136be99,
+      0xb913179899f68584, 0x28e2557b59846e3f,
+      0xe757dd7ec07426e5, 0x331aeada2fe589cf,
+      0x9096ea6f3848984f, 0x3ff0d2c85def7621,
+      0xb4bca50b065abe63, 0xfed077a756b53a9,
+      0xe1ebce4dc7f16dfb, 0xd3e8495912c62894,
+      0x8d3360f09cf6e4bd, 0x64712dd7abbbd95c,
+      0xb080392cc4349dec, 0xbd8d794d96aacfb3,
+      0xdca04777f541c567, 0xecf0d7a0fc5583a0,
+      0x89e42caaf9491b60, 0xf41686c49db57244,
+      0xac5d37d5b79b6239, 0x311c2875c522ced5,
+      0xd77485cb25823ac7, 0x7d633293366b828b,
+      0x86a8d39ef77164bc, 0xae5dff9c02033197,
+      0xa8530886b54dbdeb, 0xd9f57f830283fdfc,
+      0xd267caa862a12d66, 0xd072df63c324fd7b,
+      0x8380dea93da4bc60, 0x4247cb9e59f71e6d,
+      0xa46116538d0deb78, 0x52d9be85f074e608,
+      0xcd795be870516656, 0x67902e276c921f8b,
+      0x806bd9714632dff6, 0xba1cd8a3db53b6,
+      0xa086cfcd97bf97f3, 0x80e8a40eccd228a4,
+      0xc8a883c0fdaf7df0, 0x6122cd128006b2cd,
+      0xfad2a4b13d1b5d6c, 0x796b805720085f81,
+      0x9cc3a6eec6311a63, 0xcbe3303674053bb0,
+      0xc3f490aa77bd60fc, 0xbedbfc4411068a9c,
+      0xf4f1b4d515acb93b, 0xee92fb5515482d44,
+      0x991711052d8bf3c5, 0x751bdd152d4d1c4a,
+      0xbf5cd54678eef0b6, 0xd262d45a78a0635d,
+      0xef340a98172aace4, 0x86fb897116c87c34,
+      0x9580869f0e7aac0e, 0xd45d35e6ae3d4da0,
+      0xbae0a846d2195712, 0x8974836059cca109,
+      0xe998d258869facd7, 0x2bd1a438703fc94b,
+      0x91ff83775423cc06, 0x7b6306a34627ddcf,
+      0xb67f6455292cbf08, 0x1a3bc84c17b1d542,
+      0xe41f3d6a7377eeca, 0x20caba5f1d9e4a93,
+      0x8e938662882af53e, 0x547eb47b7282ee9c,
+      0xb23867fb2a35b28d, 0xe99e619a4f23aa43,
+      0xdec681f9f4c31f31, 0x6405fa00e2ec94d4,
+      0x8b3c113c38f9f37e, 0xde83bc408dd3dd04,
+      0xae0b158b4738705e, 0x9624ab50b148d445,
+      0xd98ddaee19068c76, 0x3badd624dd9b0957,
+      0x87f8a8d4cfa417c9, 0xe54ca5d70a80e5d6,
+      0xa9f6d30a038d1dbc, 0x5e9fcf4ccd211f4c,
+      0xd47487cc8470652b, 0x7647c3200069671f,
+      0x84c8d4dfd2c63f3b, 0x29ecd9f40041e073,
+      0xa5fb0a17c777cf09, 0xf468107100525890,
+      0xcf79cc9db955c2cc, 0x7182148d4066eeb4,
+      0x81ac1fe293d599bf, 0xc6f14cd848405530,
+      0xa21727db38cb002f, 0xb8ada00e5a506a7c,
+      0xca9cf1d206fdc03b, 0xa6d90811f0e4851c,
+      0xfd442e4688bd304a, 0x908f4a166d1da663,
+      0x9e4a9cec15763e2e, 0x9a598e4e043287fe,
+      0xc5dd44271ad3cdba, 0x40eff1e1853f29fd,
+      0xf7549530e188c128, 0xd12bee59e68ef47c,
+      0x9a94dd3e8cf578b9, 0x82bb74f8301958ce,
+      0xc13a148e3032d6e7, 0xe36a52363c1faf01,
+      0xf18899b1bc3f8ca1, 0xdc44e6c3cb279ac1,
+      0x96f5600f15a7b7e5, 0x29ab103a5ef8c0b9,
+      0xbcb2b812db11a5de, 0x7415d448f6b6f0e7,
+      0xebdf661791d60f56, 0x111b495b3464ad21,
+      0x936b9fcebb25c995, 0xcab10dd900beec34,
+      0xb84687c269ef3bfb, 0x3d5d514f40eea742,
+      0xe65829b3046b0afa, 0xcb4a5a3112a5112,
+      0x8ff71a0fe2c2e6dc, 0x47f0e785eaba72ab,
+      0xb3f4e093db73a093, 0x59ed216765690f56,
+      0xe0f218b8d25088b8, 0x306869c13ec3532c,
+      0x8c974f7383725573, 0x1e414218c73a13fb,
+      0xafbd2350644eeacf, 0xe5d1929ef90898fa,
+      0xdbac6c247d62a583, 0xdf45f746b74abf39,
+      0x894bc396ce5da772, 0x6b8bba8c328eb783,
+      0xab9eb47c81f5114f, 0x66ea92f3f326564,
+      0xd686619ba27255a2, 0xc80a537b0efefebd,
+      0x8613fd0145877585, 0xbd06742ce95f5f36,
+      0xa798fc4196e952e7, 0x2c48113823b73704,
+      0xd17f3b51fca3a7a0, 0xf75a15862ca504c5,
+      0x82ef85133de648c4, 0x9a984d73dbe722fb,
+      0xa3ab66580d5fdaf5, 0xc13e60d0d2e0ebba,
+      0xcc963fee10b7d1b3, 0x318df905079926a8,
+      0xffbbcfe994e5c61f, 0xfdf17746497f7052,
+      0x9fd561f1fd0f9bd3, 0xfeb6ea8bedefa633,
+      0xc7caba6e7c5382c8, 0xfe64a52ee96b8fc0,
+      0xf9bd690a1b68637b, 0x3dfdce7aa3c673b0,
+      0x9c1661a651213e2d, 0x6bea10ca65c084e,
+      0xc31bfa0fe5698db8, 0x486e494fcff30a62,
+      0xf3e2f893dec3f126, 0x5a89dba3c3efccfa,
+      0x986ddb5c6b3a76b7, 0xf89629465a75e01c,
+      0xbe89523386091465, 0xf6bbb397f1135823,
+      0xee2ba6c0678b597f, 0x746aa07ded582e2c,
+      0x94db483840b717ef, 0xa8c2a44eb4571cdc,
+      0xba121a4650e4ddeb, 0x92f34d62616ce413,
+      0xe896a0d7e51e1566, 0x77b020baf9c81d17,
+      0x915e2486ef32cd60, 0xace1474dc1d122e,
+      0xb5b5ada8aaff80b8, 0xd819992132456ba,
+      0xe3231912d5bf60e6, 0x10e1fff697ed6c69,
+      0x8df5efabc5979c8f, 0xca8d3ffa1ef463c1,
+      0xb1736b96b6fd83b3, 0xbd308ff8a6b17cb2,
+      0xddd0467c64bce4a0, 0xac7cb3f6d05ddbde,
+      0x8aa22c0dbef60ee4, 0x6bcdf07a423aa96b,
+      0xad4ab7112eb3929d, 0x86c16c98d2c953c6,
+      0xd89d64d57a607744, 0xe871c7bf077ba8b7,
+      0x87625f056c7c4a8b, 0x11471cd764ad4972,
+      0xa93af6c6c79b5d2d, 0xd598e40d3dd89bcf,
+      0xd389b47879823479, 0x4aff1d108d4ec2c3,
+      0x843610cb4bf160cb, 0xcedf722a585139ba,
+      0xa54394fe1eedb8fe, 0xc2974eb4ee658828,
+      0xce947a3da6a9273e, 0x733d226229feea32,
+      0x811ccc668829b887, 0x806357d5a3f525f,
+      0xa163ff802a3426a8, 0xca07c2dcb0cf26f7,
+      0xc9bcff6034c13052, 0xfc89b393dd02f0b5,
+      0xfc2c3f3841f17c67, 0xbbac2078d443ace2,
+      0x9d9ba7832936edc0, 0xd54b944b84aa4c0d,
+      0xc5029163f384a931, 0xa9e795e65d4df11,
+      0xf64335bcf065d37d, 0x4d4617b5ff4a16d5,
+      0x99ea0196163fa42e, 0x504bced1bf8e4e45,
+      0xc06481fb9bcf8d39, 0xe45ec2862f71e1d6,
+      0xf07da27a82c37088, 0x5d767327bb4e5a4c,
+      0x964e858c91ba2655, 0x3a6a07f8d510f86f,
+      0xbbe226efb628afea, 0x890489f70a55368b,
+      0xeadab0aba3b2dbe5, 0x2b45ac74ccea842e,
+      0x92c8ae6b464fc96f, 0x3b0b8bc90012929d,
+      0xb77ada0617e3bbcb, 0x9ce6ebb40173744,
+      0xe55990879ddcaabd, 0xcc420a6a101d0515,
+      0x8f57fa54c2a9eab6, 0x9fa946824a12232d,
+      0xb32df8e9f3546564, 0x47939822dc96abf9,
+      0xdff9772470297ebd, 0x59787e2b93bc56f7,
+      0x8bfbea76c619ef36, 0x57eb4edb3c55b65a,
+      0xaefae51477a06b03, 0xede622920b6b23f1,
+      0xdab99e59958885c4, 0xe95fab368e45eced,
+      0x88b402f7fd75539b, 0x11dbcb0218ebb414,
+      0xaae103b5fcd2a881, 0xd652bdc29f26a119,
+      0xd59944a37c0752a2, 0x4be76d3346f0495f,
+      0x857fcae62d8493a5, 0x6f70a4400c562ddb,
+      0xa6dfbd9fb8e5b88e, 0xcb4ccd500f6bb952,
+      0xd097ad07a71f26b2, 0x7e2000a41346a7a7,
+      0x825ecc24c873782f, 0x8ed400668c0c28c8,
+      0xa2f67f2dfa90563b, 0x728900802f0f32fa,
+      0xcbb41ef979346bca, 0x4f2b40a03ad2ffb9,
+      0xfea126b7d78186bc, 0xe2f610c84987bfa8,
+      0x9f24b832e6b0f436, 0xdd9ca7d2df4d7c9,
+      0xc6ede63fa05d3143, 0x91503d1c79720dbb,
+      0xf8a95fcf88747d94, 0x75a44c6397ce912a,
+      0x9b69dbe1b548ce7c, 0xc986afbe3ee11aba,
+      0xc24452da229b021b, 0xfbe85badce996168,
+      0xf2d56790ab41c2a2, 0xfae27299423fb9c3,
+      0x97c560ba6b0919a5, 0xdccd879fc967d41a,
+      0xbdb6b8e905cb600f, 0x5400e987bbc1c920,
+      0xed246723473e3813, 0x290123e9aab23b68,
+      0x9436c0760c86e30b, 0xf9a0b6720aaf6521,
+      0xb94470938fa89bce, 0xf808e40e8d5b3e69,
+      0xe7958cb87392c2c2, 0xb60b1d1230b20e04,
+      0x90bd77f3483bb9b9, 0xb1c6f22b5e6f48c2,
+      0xb4ecd5f01a4aa828, 0x1e38aeb6360b1af3,
+      0xe2280b6c20dd5232, 0x25c6da63c38de1b0,
+      0x8d590723948a535f, 0x579c487e5a38ad0e,
+      0xb0af48ec79ace837, 0x2d835a9df0c6d851,
+      0xdcdb1b2798182244, 0xf8e431456cf88e65,
+      0x8a08f0f8bf0f156b, 0x1b8e9ecb641b58ff,
+      0xac8b2d36eed2dac5, 0xe272467e3d222f3f,
+      0xd7adf884aa879177, 0x5b0ed81dcc6abb0f,
+      0x86ccbb52ea94baea, 0x98e947129fc2b4e9,
+      0xa87fea27a539e9a5, 0x3f2398d747b36224,
+      0xd29fe4b18e88640e, 0x8eec7f0d19a03aad,
+      0x83a3eeeef9153e89, 0x1953cf68300424ac,
+      0xa48ceaaab75a8e2b, 0x5fa8c3423c052dd7,
+      0xcdb02555653131b6, 0x3792f412cb06794d,
+      0x808e17555f3ebf11, 0xe2bbd88bbee40bd0,
+      0xa0b19d2ab70e6ed6, 0x5b6aceaeae9d0ec4,
+      0xc8de047564d20a8b, 0xf245825a5a445275,
+      0xfb158592be068d2e, 0xeed6e2f0f0d56712,
+      0x9ced737bb6c4183d, 0x55464dd69685606b,
+      0xc428d05aa4751e4c, 0xaa97e14c3c26b886,
+      0xf53304714d9265df, 0xd53dd99f4b3066a8,
+      0x993fe2c6d07b7fab, 0xe546a8038efe4029,
+      0xbf8fdb78849a5f96, 0xde98520472bdd033,
+      0xef73d256a5c0f77c, 0x963e66858f6d4440,
+      0x95a8637627989aad, 0xdde7001379a44aa8,
+      0xbb127c53b17ec159, 0x5560c018580d5d52,
+      0xe9d71b689dde71af, 0xaab8f01e6e10b4a6,
+      0x9226712162ab070d, 0xcab3961304ca70e8,
+      0xb6b00d69bb55c8d1, 0x3d607b97c5fd0d22,
+      0xe45c10c42a2b3b05, 0x8cb89a7db77c506a,
+      0x8eb98a7a9a5b04e3, 0x77f3608e92adb242,
+      0xb267ed1940f1c61c, 0x55f038b237591ed3,
+      0xdf01e85f912e37a3, 0x6b6c46dec52f6688,
+      0x8b61313bbabce2c6, 0x2323ac4b3b3da015,
+      0xae397d8aa96c1b77, 0xabec975e0a0d081a,
+      0xd9c7dced53c72255, 0x96e7bd358c904a21,
+      0x881cea14545c7575, 0x7e50d64177da2e54,
+      0xaa242499697392d2, 0xdde50bd1d5d0b9e9,
+      0xd4ad2dbfc3d07787, 0x955e4ec64b44e864,
+      0x84ec3c97da624ab4, 0xbd5af13bef0b113e,
+      0xa6274bbdd0fadd61, 0xecb1ad8aeacdd58e,
+      0xcfb11ead453994ba, 0x67de18eda5814af2,
+      0x81ceb32c4b43fcf4, 0x80eacf948770ced7,
+      0xa2425ff75e14fc31, 0xa1258379a94d028d,
+      0xcad2f7f5359a3b3e, 0x96ee45813a04330,
+      0xfd87b5f28300ca0d, 0x8bca9d6e188853fc,
+      0x9e74d1b791e07e48, 0x775ea264cf55347e,
+      0xc612062576589dda, 0x95364afe032a819e,
+      0xf79687aed3eec551, 0x3a83ddbd83f52205,
+      0x9abe14cd44753b52, 0xc4926a9672793543,
+      0xc16d9a0095928a27, 0x75b7053c0f178294,
+      0xf1c90080baf72cb1, 0x5324c68b12dd6339,
+      0x971da05074da7bee, 0xd3f6fc16ebca5e04,
+      0xbce5086492111aea, 0x88f4bb1ca6bcf585,
+      0xec1e4a7db69561a5, 0x2b31e9e3d06c32e6,
+      0x9392ee8e921d5d07, 0x3aff322e62439fd0,
+      0xb877aa3236a4b449, 0x9befeb9fad487c3,
+      0xe69594bec44de15b, 0x4c2ebe687989a9b4,
+      0x901d7cf73ab0acd9, 0xf9d37014bf60a11,
+      0xb424dc35095cd80f, 0x538484c19ef38c95,
+      0xe12e13424bb40e13, 0x2865a5f206b06fba,
+      0x8cbccc096f5088cb, 0xf93f87b7442e45d4,
+      0xafebff0bcb24aafe, 0xf78f69a51539d749,
+      0xdbe6fecebdedd5be, 0xb573440e5a884d1c,
+      0x89705f4136b4a597, 0x31680a88f8953031,
+      0xabcc77118461cefc, 0xfdc20d2b36ba7c3e,
+      0xd6bf94d5e57a42bc, 0x3d32907604691b4d,
+      0x8637bd05af6c69b5, 0xa63f9a49c2c1b110,
+      0xa7c5ac471b478423, 0xfcf80dc33721d54,
+      0xd1b71758e219652b, 0xd3c36113404ea4a9,
+      0x83126e978d4fdf3b, 0x645a1cac083126ea,
+      0xa3d70a3d70a3d70a, 0x3d70a3d70a3d70a4,
+      0xcccccccccccccccc, 0xcccccccccccccccd,
+      0x8000000000000000, 0x0,
+      0xa000000000000000, 0x0,
+      0xc800000000000000, 0x0,
+      0xfa00000000000000, 0x0,
+      0x9c40000000000000, 0x0,
+      0xc350000000000000, 0x0,
+      0xf424000000000000, 0x0,
+      0x9896800000000000, 0x0,
+      0xbebc200000000000, 0x0,
+      0xee6b280000000000, 0x0,
+      0x9502f90000000000, 0x0,
+      0xba43b74000000000, 0x0,
+      0xe8d4a51000000000, 0x0,
+      0x9184e72a00000000, 0x0,
+      0xb5e620f480000000, 0x0,
+      0xe35fa931a0000000, 0x0,
+      0x8e1bc9bf04000000, 0x0,
+      0xb1a2bc2ec5000000, 0x0,
+      0xde0b6b3a76400000, 0x0,
+      0x8ac7230489e80000, 0x0,
+      0xad78ebc5ac620000, 0x0,
+      0xd8d726b7177a8000, 0x0,
+      0x878678326eac9000, 0x0,
+      0xa968163f0a57b400, 0x0,
+      0xd3c21bcecceda100, 0x0,
+      0x84595161401484a0, 0x0,
+      0xa56fa5b99019a5c8, 0x0,
+      0xcecb8f27f4200f3a, 0x0,
+      0x813f3978f8940984, 0x4000000000000000,
+      0xa18f07d736b90be5, 0x5000000000000000,
+      0xc9f2c9cd04674ede, 0xa400000000000000,
+      0xfc6f7c4045812296, 0x4d00000000000000,
+      0x9dc5ada82b70b59d, 0xf020000000000000,
+      0xc5371912364ce305, 0x6c28000000000000,
+      0xf684df56c3e01bc6, 0xc732000000000000,
+      0x9a130b963a6c115c, 0x3c7f400000000000,
+      0xc097ce7bc90715b3, 0x4b9f100000000000,
+      0xf0bdc21abb48db20, 0x1e86d40000000000,
+      0x96769950b50d88f4, 0x1314448000000000,
+      0xbc143fa4e250eb31, 0x17d955a000000000,
+      0xeb194f8e1ae525fd, 0x5dcfab0800000000,
+      0x92efd1b8d0cf37be, 0x5aa1cae500000000,
+      0xb7abc627050305ad, 0xf14a3d9e40000000,
+      0xe596b7b0c643c719, 0x6d9ccd05d0000000,
+      0x8f7e32ce7bea5c6f, 0xe4820023a2000000,
+      0xb35dbf821ae4f38b, 0xdda2802c8a800000,
+      0xe0352f62a19e306e, 0xd50b2037ad200000,
+      0x8c213d9da502de45, 0x4526f422cc340000,
+      0xaf298d050e4395d6, 0x9670b12b7f410000,
+      0xdaf3f04651d47b4c, 0x3c0cdd765f114000,
+      0x88d8762bf324cd0f, 0xa5880a69fb6ac800,
+      0xab0e93b6efee0053, 0x8eea0d047a457a00,
+      0xd5d238a4abe98068, 0x72a4904598d6d880,
+      0x85a36366eb71f041, 0x47a6da2b7f864750,
+      0xa70c3c40a64e6c51, 0x999090b65f67d924,
+      0xd0cf4b50cfe20765, 0xfff4b4e3f741cf6d,
+      0x82818f1281ed449f, 0xbff8f10e7a8921a4,
+      0xa321f2d7226895c7, 0xaff72d52192b6a0d,
+      0xcbea6f8ceb02bb39, 0x9bf4f8a69f764490,
+      0xfee50b7025c36a08, 0x2f236d04753d5b4,
+      0x9f4f2726179a2245, 0x1d762422c946590,
+      0xc722f0ef9d80aad6, 0x424d3ad2b7b97ef5,
+      0xf8ebad2b84e0d58b, 0xd2e0898765a7deb2,
+      0x9b934c3b330c8577, 0x63cc55f49f88eb2f,
+      0xc2781f49ffcfa6d5, 0x3cbf6b71c76b25fb,
+      0xf316271c7fc3908a, 0x8bef464e3945ef7a,
+      0x97edd871cfda3a56, 0x97758bf0e3cbb5ac,
+      0xbde94e8e43d0c8ec, 0x3d52eeed1cbea317,
+      0xed63a231d4c4fb27, 0x4ca7aaa863ee4bdd,
+      0x945e455f24fb1cf8, 0x8fe8caa93e74ef6a,
+      0xb975d6b6ee39e436, 0xb3e2fd538e122b44,
+      0xe7d34c64a9c85d44, 0x60dbbca87196b616,
+      0x90e40fbeea1d3a4a, 0xbc8955e946fe31cd,
+      0xb51d13aea4a488dd, 0x6babab6398bdbe41,
+      0xe264589a4dcdab14, 0xc696963c7eed2dd1,
+      0x8d7eb76070a08aec, 0xfc1e1de5cf543ca2,
+      0xb0de65388cc8ada8, 0x3b25a55f43294bcb,
+      0xdd15fe86affad912, 0x49ef0eb713f39ebe,
+      0x8a2dbf142dfcc7ab, 0x6e3569326c784337,
+      0xacb92ed9397bf996, 0x49c2c37f07965404,
+      0xd7e77a8f87daf7fb, 0xdc33745ec97be906,
+      0x86f0ac99b4e8dafd, 0x69a028bb3ded71a3,
+      0xa8acd7c0222311bc, 0xc40832ea0d68ce0c,
+      0xd2d80db02aabd62b, 0xf50a3fa490c30190,
+      0x83c7088e1aab65db, 0x792667c6da79e0fa,
+      0xa4b8cab1a1563f52, 0x577001b891185938,
+      0xcde6fd5e09abcf26, 0xed4c0226b55e6f86,
+      0x80b05e5ac60b6178, 0x544f8158315b05b4,
+      0xa0dc75f1778e39d6, 0x696361ae3db1c721,
+      0xc913936dd571c84c, 0x3bc3a19cd1e38e9,
+      0xfb5878494ace3a5f, 0x4ab48a04065c723,
+      0x9d174b2dcec0e47b, 0x62eb0d64283f9c76,
+      0xc45d1df942711d9a, 0x3ba5d0bd324f8394,
+      0xf5746577930d6500, 0xca8f44ec7ee36479,
+      0x9968bf6abbe85f20, 0x7e998b13cf4e1ecb,
+      0xbfc2ef456ae276e8, 0x9e3fedd8c321a67e,
+      0xefb3ab16c59b14a2, 0xc5cfe94ef3ea101e,
+      0x95d04aee3b80ece5, 0xbba1f1d158724a12,
+      0xbb445da9ca61281f, 0x2a8a6e45ae8edc97,
+      0xea1575143cf97226, 0xf52d09d71a3293bd,
+      0x924d692ca61be758, 0x593c2626705f9c56,
+      0xb6e0c377cfa2e12e, 0x6f8b2fb00c77836c,
+      0xe498f455c38b997a, 0xb6dfb9c0f956447,
+      0x8edf98b59a373fec, 0x4724bd4189bd5eac,
+      0xb2977ee300c50fe7, 0x58edec91ec2cb657,
+      0xdf3d5e9bc0f653e1, 0x2f2967b66737e3ed,
+      0x8b865b215899f46c, 0xbd79e0d20082ee74,
+      0xae67f1e9aec07187, 0xecd8590680a3aa11,
+      0xda01ee641a708de9, 0xe80e6f4820cc9495,
+      0x884134fe908658b2, 0x3109058d147fdcdd,
+      0xaa51823e34a7eede, 0xbd4b46f0599fd415,
+      0xd4e5e2cdc1d1ea96, 0x6c9e18ac7007c91a,
+      0x850fadc09923329e, 0x3e2cf6bc604ddb0,
+      0xa6539930bf6bff45, 0x84db8346b786151c,
+      0xcfe87f7cef46ff16, 0xe612641865679a63,
+      0x81f14fae158c5f6e, 0x4fcb7e8f3f60c07e,
+      0xa26da3999aef7749, 0xe3be5e330f38f09d,
+      0xcb090c8001ab551c, 0x5cadf5bfd3072cc5,
+      0xfdcb4fa002162a63, 0x73d9732fc7c8f7f6,
+      0x9e9f11c4014dda7e, 0x2867e7fddcdd9afa,
+      0xc646d63501a1511d, 0xb281e1fd541501b8,
+      0xf7d88bc24209a565, 0x1f225a7ca91a4226,
+      0x9ae757596946075f, 0x3375788de9b06958,
+      0xc1a12d2fc3978937, 0x52d6b1641c83ae,
+      0xf209787bb47d6b84, 0xc0678c5dbd23a49a,
+      0x9745eb4d50ce6332, 0xf840b7ba963646e0,
+      0xbd176620a501fbff, 0xb650e5a93bc3d898,
+      0xec5d3fa8ce427aff, 0xa3e51f138ab4cebe,
+      0x93ba47c980e98cdf, 0xc66f336c36b10137,
+      0xb8a8d9bbe123f017, 0xb80b0047445d4184,
+      0xe6d3102ad96cec1d, 0xa60dc059157491e5,
+      0x9043ea1ac7e41392, 0x87c89837ad68db2f,
+      0xb454e4a179dd1877, 0x29babe4598c311fb,
+      0xe16a1dc9d8545e94, 0xf4296dd6fef3d67a,
+      0x8ce2529e2734bb1d, 0x1899e4a65f58660c,
+      0xb01ae745b101e9e4, 0x5ec05dcff72e7f8f,
+      0xdc21a1171d42645d, 0x76707543f4fa1f73,
+      0x899504ae72497eba, 0x6a06494a791c53a8,
+      0xabfa45da0edbde69, 0x487db9d17636892,
+      0xd6f8d7509292d603, 0x45a9d2845d3c42b6,
+      0x865b86925b9bc5c2, 0xb8a2392ba45a9b2,
+      0xa7f26836f282b732, 0x8e6cac7768d7141e,
+      0xd1ef0244af2364ff, 0x3207d795430cd926,
+      0x8335616aed761f1f, 0x7f44e6bd49e807b8,
+      0xa402b9c5a8d3a6e7, 0x5f16206c9c6209a6,
+      0xcd036837130890a1, 0x36dba887c37a8c0f,
+      0x802221226be55a64, 0xc2494954da2c9789,
+      0xa02aa96b06deb0fd, 0xf2db9baa10b7bd6c,
+      0xc83553c5c8965d3d, 0x6f92829494e5acc7,
+      0xfa42a8b73abbf48c, 0xcb772339ba1f17f9,
+      0x9c69a97284b578d7, 0xff2a760414536efb,
+      0xc38413cf25e2d70d, 0xfef5138519684aba,
+      0xf46518c2ef5b8cd1, 0x7eb258665fc25d69,
+      0x98bf2f79d5993802, 0xef2f773ffbd97a61,
+      0xbeeefb584aff8603, 0xaafb550ffacfd8fa,
+      0xeeaaba2e5dbf6784, 0x95ba2a53f983cf38,
+      0x952ab45cfa97a0b2, 0xdd945a747bf26183,
+      0xba756174393d88df, 0x94f971119aeef9e4,
+      0xe912b9d1478ceb17, 0x7a37cd5601aab85d,
+      0x91abb422ccb812ee, 0xac62e055c10ab33a,
+      0xb616a12b7fe617aa, 0x577b986b314d6009,
+      0xe39c49765fdf9d94, 0xed5a7e85fda0b80b,
+      0x8e41ade9fbebc27d, 0x14588f13be847307,
+      0xb1d219647ae6b31c, 0x596eb2d8ae258fc8,
+      0xde469fbd99a05fe3, 0x6fca5f8ed9aef3bb,
+      0x8aec23d680043bee, 0x25de7bb9480d5854,
+      0xada72ccc20054ae9, 0xaf561aa79a10ae6a,
+      0xd910f7ff28069da4, 0x1b2ba1518094da04,
+      0x87aa9aff79042286, 0x90fb44d2f05d0842,
+      0xa99541bf57452b28, 0x353a1607ac744a53,
+      0xd3fa922f2d1675f2, 0x42889b8997915ce8,
+      0x847c9b5d7c2e09b7, 0x69956135febada11,
+      0xa59bc234db398c25, 0x43fab9837e699095,
+      0xcf02b2c21207ef2e, 0x94f967e45e03f4bb,
+      0x8161afb94b44f57d, 0x1d1be0eebac278f5,
+      0xa1ba1ba79e1632dc, 0x6462d92a69731732,
+      0xca28a291859bbf93, 0x7d7b8f7503cfdcfe,
+      0xfcb2cb35e702af78, 0x5cda735244c3d43e,
+      0x9defbf01b061adab, 0x3a0888136afa64a7,
+      0xc56baec21c7a1916, 0x88aaa1845b8fdd0,
+      0xf6c69a72a3989f5b, 0x8aad549e57273d45,
+      0x9a3c2087a63f6399, 0x36ac54e2f678864b,
+      0xc0cb28a98fcf3c7f, 0x84576a1bb416a7dd,
+      0xf0fdf2d3f3c30b9f, 0x656d44a2a11c51d5,
+      0x969eb7c47859e743, 0x9f644ae5a4b1b325,
+      0xbc4665b596706114, 0x873d5d9f0dde1fee,
+      0xeb57ff22fc0c7959, 0xa90cb506d155a7ea,
+      0x9316ff75dd87cbd8, 0x9a7f12442d588f2,
+      0xb7dcbf5354e9bece, 0xc11ed6d538aeb2f,
+      0xe5d3ef282a242e81, 0x8f1668c8a86da5fa,
+      0x8fa475791a569d10, 0xf96e017d694487bc,
+      0xb38d92d760ec4455, 0x37c981dcc395a9ac,
+      0xe070f78d3927556a, 0x85bbe253f47b1417,
+      0x8c469ab843b89562, 0x93956d7478ccec8e,
+      0xaf58416654a6babb, 0x387ac8d1970027b2,
+      0xdb2e51bfe9d0696a, 0x6997b05fcc0319e,
+      0x88fcf317f22241e2, 0x441fece3bdf81f03,
+      0xab3c2fddeeaad25a, 0xd527e81cad7626c3,
+      0xd60b3bd56a5586f1, 0x8a71e223d8d3b074,
+      0x85c7056562757456, 0xf6872d5667844e49,
+      0xa738c6bebb12d16c, 0xb428f8ac016561db,
+      0xd106f86e69d785c7, 0xe13336d701beba52,
+      0x82a45b450226b39c, 0xecc0024661173473,
+      0xa34d721642b06084, 0x27f002d7f95d0190,
+      0xcc20ce9bd35c78a5, 0x31ec038df7b441f4,
+      0xff290242c83396ce, 0x7e67047175a15271,
+      0x9f79a169bd203e41, 0xf0062c6e984d386,
+      0xc75809c42c684dd1, 0x52c07b78a3e60868,
+      0xf92e0c3537826145, 0xa7709a56ccdf8a82,
+      0x9bbcc7a142b17ccb, 0x88a66076400bb691,
+      0xc2abf989935ddbfe, 0x6acff893d00ea435,
+      0xf356f7ebf83552fe, 0x583f6b8c4124d43,
+      0x98165af37b2153de, 0xc3727a337a8b704a,
+      0xbe1bf1b059e9a8d6, 0x744f18c0592e4c5c,
+      0xeda2ee1c7064130c, 0x1162def06f79df73,
+      0x9485d4d1c63e8be7, 0x8addcb5645ac2ba8,
+      0xb9a74a0637ce2ee1, 0x6d953e2bd7173692,
+      0xe8111c87c5c1ba99, 0xc8fa8db6ccdd0437,
+      0x910ab1d4db9914a0, 0x1d9c9892400a22a2,
+      0xb54d5e4a127f59c8, 0x2503beb6d00cab4b,
+      0xe2a0b5dc971f303a, 0x2e44ae64840fd61d,
+      0x8da471a9de737e24, 0x5ceaecfed289e5d2,
+      0xb10d8e1456105dad, 0x7425a83e872c5f47,
+      0xdd50f1996b947518, 0xd12f124e28f77719,
+      0x8a5296ffe33cc92f, 0x82bd6b70d99aaa6f,
+      0xace73cbfdc0bfb7b, 0x636cc64d1001550b,
+      0xd8210befd30efa5a, 0x3c47f7e05401aa4e,
+      0x8714a775e3e95c78, 0x65acfaec34810a71,
+      0xa8d9d1535ce3b396, 0x7f1839a741a14d0d,
+      0xd31045a8341ca07c, 0x1ede48111209a050,
+      0x83ea2b892091e44d, 0x934aed0aab460432,
+      0xa4e4b66b68b65d60, 0xf81da84d5617853f,
+      0xce1de40642e3f4b9, 0x36251260ab9d668e,
+      0x80d2ae83e9ce78f3, 0xc1d72b7c6b426019,
+      0xa1075a24e4421730, 0xb24cf65b8612f81f,
+      0xc94930ae1d529cfc, 0xdee033f26797b627,
+      0xfb9b7cd9a4a7443c, 0x169840ef017da3b1,
+      0x9d412e0806e88aa5, 0x8e1f289560ee864e,
+      0xc491798a08a2ad4e, 0xf1a6f2bab92a27e2,
+      0xf5b5d7ec8acb58a2, 0xae10af696774b1db,
+      0x9991a6f3d6bf1765, 0xacca6da1e0a8ef29,
+      0xbff610b0cc6edd3f, 0x17fd090a58d32af3,
+      0xeff394dcff8a948e, 0xddfc4b4cef07f5b0,
+      0x95f83d0a1fb69cd9, 0x4abdaf101564f98e,
+      0xbb764c4ca7a4440f, 0x9d6d1ad41abe37f1,
+      0xea53df5fd18d5513, 0x84c86189216dc5ed,
+      0x92746b9be2f8552c, 0x32fd3cf5b4e49bb4,
+      0xb7118682dbb66a77, 0x3fbc8c33221dc2a1,
+      0xe4d5e82392a40515, 0xfabaf3feaa5334a,
+      0x8f05b1163ba6832d, 0x29cb4d87f2a7400e,
+      0xb2c71d5bca9023f8, 0x743e20e9ef511012,
+      0xdf78e4b2bd342cf6, 0x914da9246b255416,
+      0x8bab8eefb6409c1a, 0x1ad089b6c2f7548e,
+      0xae9672aba3d0c320, 0xa184ac2473b529b1,
+      0xda3c0f568cc4f3e8, 0xc9e5d72d90a2741e,
+      0x8865899617fb1871, 0x7e2fa67c7a658892,
+      0xaa7eebfb9df9de8d, 0xddbb901b98feeab7,
+      0xd51ea6fa85785631, 0x552a74227f3ea565,
+      0x8533285c936b35de, 0xd53a88958f87275f,
+      0xa67ff273b8460356, 0x8a892abaf368f137,
+      0xd01fef10a657842c, 0x2d2b7569b0432d85,
+      0x8213f56a67f6b29b, 0x9c3b29620e29fc73,
+      0xa298f2c501f45f42, 0x8349f3ba91b47b8f,
+      0xcb3f2f7642717713, 0x241c70a936219a73,
+      0xfe0efb53d30dd4d7, 0xed238cd383aa0110,
+      0x9ec95d1463e8a506, 0xf4363804324a40aa,
+      0xc67bb4597ce2ce48, 0xb143c6053edcd0d5,
+      0xf81aa16fdc1b81da, 0xdd94b7868e94050a,
+      0x9b10a4e5e9913128, 0xca7cf2b4191c8326,
+      0xc1d4ce1f63f57d72, 0xfd1c2f611f63a3f0,
+      0xf24a01a73cf2dccf, 0xbc633b39673c8cec,
+      0x976e41088617ca01, 0xd5be0503e085d813,
+      0xbd49d14aa79dbc82, 0x4b2d8644d8a74e18,
+      0xec9c459d51852ba2, 0xddf8e7d60ed1219e,
+      0x93e1ab8252f33b45, 0xcabb90e5c942b503,
+      0xb8da1662e7b00a17, 0x3d6a751f3b936243,
+      0xe7109bfba19c0c9d, 0xcc512670a783ad4,
+      0x906a617d450187e2, 0x27fb2b80668b24c5,
+      0xb484f9dc9641e9da, 0xb1f9f660802dedf6,
+      0xe1a63853bbd26451, 0x5e7873f8a0396973,
+      0x8d07e33455637eb2, 0xdb0b487b6423e1e8,
+      0xb049dc016abc5e5f, 0x91ce1a9a3d2cda62,
+      0xdc5c5301c56b75f7, 0x7641a140cc7810fb,
+      0x89b9b3e11b6329ba, 0xa9e904c87fcb0a9d,
+      0xac2820d9623bf429, 0x546345fa9fbdcd44,
+      0xd732290fbacaf133, 0xa97c177947ad4095,
+      0x867f59a9d4bed6c0, 0x49ed8eabcccc485d,
+      0xa81f301449ee8c70, 0x5c68f256bfff5a74,
+      0xd226fc195c6a2f8c, 0x73832eec6fff3111,
+      0x83585d8fd9c25db7, 0xc831fd53c5ff7eab,
+      0xa42e74f3d032f525, 0xba3e7ca8b77f5e55,
+      0xcd3a1230c43fb26f, 0x28ce1bd2e55f35eb,
+      0x80444b5e7aa7cf85, 0x7980d163cf5b81b3,
+      0xa0555e361951c366, 0xd7e105bcc332621f,
+      0xc86ab5c39fa63440, 0x8dd9472bf3fefaa7,
+      0xfa856334878fc150, 0xb14f98f6f0feb951,
+      0x9c935e00d4b9d8d2, 0x6ed1bf9a569f33d3,
+      0xc3b8358109e84f07, 0xa862f80ec4700c8,
+      0xf4a642e14c6262c8, 0xcd27bb612758c0fa,
+      0x98e7e9cccfbd7dbd, 0x8038d51cb897789c,
+      0xbf21e44003acdd2c, 0xe0470a63e6bd56c3,
+      0xeeea5d5004981478, 0x1858ccfce06cac74,
+      0x95527a5202df0ccb, 0xf37801e0c43ebc8,
+      0xbaa718e68396cffd, 0xd30560258f54e6ba,
+      0xe950df20247c83fd, 0x47c6b82ef32a2069,
+      0x91d28b7416cdd27e, 0x4cdc331d57fa5441,
+      0xb6472e511c81471d, 0xe0133fe4adf8e952,
+      0xe3d8f9e563a198e5, 0x58180fddd97723a6,
+      0x8e679c2f5e44ff8f, 0x570f09eaa7ea7648,
+  };
+};
+
+#if GLZ_FASTFLOAT_DETAIL_MUST_DEFINE_CONSTEXPR_VARIABLE
+
+template <class unused>
+constexpr uint64_t
+    powers_template<unused>::power_of_five_128[number_of_entries];
+
+#endif
+
+using powers = powers_template<>;
+
+} // namespace glz::fast_float
+
+#endif
+
+#ifndef GLZ_FASTFLOAT_DECIMAL_TO_BINARY_H
+#define GLZ_FASTFLOAT_DECIMAL_TO_BINARY_H
+
+#include <cfloat>
+#include <cinttypes>
+#include <cmath>
+#include <cstdint>
+#include <cstdlib>
+#include <cstring>
+
+namespace glz::fast_float {
+
+// This will compute or rather approximate w * 5**q and return a pair of 64-bit
+// words approximating the result, with the "high" part corresponding to the
+// most significant bits and the low part corresponding to the least significant
+// bits.
+//
+template <int bit_precision>
+fastfloat_really_inline GLZ_FASTFLOAT_CONSTEXPR20 value128
+compute_product_approximation(int64_t q, uint64_t w) {
+  int const index = 2 * int(q - powers::smallest_power_of_five);
+  // For small values of q, e.g., q in [0,27], the answer is always exact
+  // because The line value128 firstproduct = full_multiplication(w,
+  // power_of_five_128[index]); gives the exact answer.
+  value128 firstproduct =
+      full_multiplication(w, powers::power_of_five_128[index]);
+  static_assert((bit_precision >= 0) && (bit_precision <= 64),
+                " precision should  be in (0,64]");
+  constexpr uint64_t precision_mask =
+      (bit_precision < 64) ? (uint64_t(0xFFFFFFFFFFFFFFFF) >> bit_precision)
+                           : uint64_t(0xFFFFFFFFFFFFFFFF);
+  if ((firstproduct.high & precision_mask) ==
+      precision_mask) { // could further guard with  (lower + w < lower)
+    // regarding the second product, we only need secondproduct.high, but our
+    // expectation is that the compiler will optimize this extra work away if
+    // needed.
+    value128 secondproduct =
+        full_multiplication(w, powers::power_of_five_128[index + 1]);
+    firstproduct.low += secondproduct.high;
+    if (secondproduct.high > firstproduct.low) {
+      firstproduct.high++;
+    }
+  }
+  return firstproduct;
+}
+
+namespace detail {
+/**
+ * For q in (0,350), we have that
+ *  f = (((152170 + 65536) * q ) >> 16);
+ * is equal to
+ *   floor(p) + q
+ * where
+ *   p = log(5**q)/log(2) = q * log(5)/log(2)
+ *
+ * For negative values of q in (-400,0), we have that
+ *  f = (((152170 + 65536) * q ) >> 16);
+ * is equal to
+ *   -ceil(p) + q
+ * where
+ *   p = log(5**-q)/log(2) = -q * log(5)/log(2)
+ */
+constexpr fastfloat_really_inline int32_t power(int32_t q) noexcept {
+  return (((152170 + 65536) * q) >> 16) + 63;
+}
+} // namespace detail
+
+// create an adjusted mantissa, biased by the invalid power2
+// for significant digits already multiplied by 10 ** q.
+template <typename binary>
+fastfloat_really_inline GLZ_FASTFLOAT_CONSTEXPR14 adjusted_mantissa
+compute_error_scaled(int64_t q, uint64_t w, int lz) noexcept {
+  int hilz = int(w >> 63) ^ 1;
+  adjusted_mantissa answer;
+  answer.mantissa = w << hilz;
+  int bias = binary::mantissa_explicit_bits() - binary::minimum_exponent();
+  answer.power2 = int32_t(detail::power(int32_t(q)) + bias - hilz - lz - 62 +
+                          invalid_am_bias);
+  return answer;
+}
+
+// w * 10 ** q, without rounding the representation up.
+// the power2 in the exponent will be adjusted by invalid_am_bias.
+template <typename binary>
+fastfloat_really_inline GLZ_FASTFLOAT_CONSTEXPR20 adjusted_mantissa
+compute_error(int64_t q, uint64_t w) noexcept {
+  int lz = leading_zeroes(w);
+  w <<= lz;
+  value128 product =
+      compute_product_approximation<binary::mantissa_explicit_bits() + 3>(q, w);
+  return compute_error_scaled<binary>(q, product.high, lz);
+}
+
+// Computers w * 10 ** q.
+// The returned value should be a valid number that simply needs to be
+// packed. However, in some very rare cases, the computation will fail. In such
+// cases, we return an adjusted_mantissa with a negative power of 2: the caller
+// should recompute in such cases.
+template <typename binary>
+fastfloat_really_inline GLZ_FASTFLOAT_CONSTEXPR20 adjusted_mantissa
+compute_float(int64_t q, uint64_t w) noexcept {
+  adjusted_mantissa answer;
+  if ((w == 0) || (q < binary::smallest_power_of_ten())) {
+    answer.power2 = 0;
+    answer.mantissa = 0;
+    // result should be zero
+    return answer;
+  }
+  if (q > binary::largest_power_of_ten()) {
+    // we want to get infinity:
+    answer.power2 = binary::infinite_power();
+    answer.mantissa = 0;
+    return answer;
+  }
+  // At this point in time q is in [powers::smallest_power_of_five,
+  // powers::largest_power_of_five].
+
+  // We want the most significant bit of i to be 1. Shift if needed.
+  int lz = leading_zeroes(w);
+  w <<= lz;
+
+  // The required precision is binary::mantissa_explicit_bits() + 3 because
+  // 1. We need the implicit bit
+  // 2. We need an extra bit for rounding purposes
+  // 3. We might lose a bit due to the "upperbit" routine (result too small,
+  // requiring a shift)
+
+  value128 product =
+      compute_product_approximation<binary::mantissa_explicit_bits() + 3>(q, w);
+  // The computed 'product' is always sufficient.
+  // Mathematical proof:
+  // Noble Mushtak and Daniel Lemire, Fast Number Parsing Without Fallback (to
+  // appear) See script/mushtak_lemire.py
+
+  // The "compute_product_approximation" function can be slightly slower than a
+  // branchless approach: value128 product = compute_product(q, w); but in
+  // practice, we can win big with the compute_product_approximation if its
+  // additional branch is easily predicted. Which is best is data specific.
+  int upperbit = int(product.high >> 63);
+  int shift = upperbit + 64 - binary::mantissa_explicit_bits() - 3;
+
+  answer.mantissa = product.high >> shift;
+
+  answer.power2 = int32_t(detail::power(int32_t(q)) + upperbit - lz -
+                          binary::minimum_exponent());
+  if (answer.power2 <= 0) { // we have a subnormal?
+    // Here have that answer.power2 <= 0 so -answer.power2 >= 0
+    if (-answer.power2 + 1 >=
+        64) { // if we have more than 64 bits below the minimum exponent, you
+              // have a zero for sure.
+      answer.power2 = 0;
+      answer.mantissa = 0;
+      // result should be zero
+      return answer;
+    }
+    // next line is safe because -answer.power2 + 1 < 64
+    answer.mantissa >>= -answer.power2 + 1;
+    // Thankfully, we can't have both "round-to-even" and subnormals because
+    // "round-to-even" only occurs for powers close to 0 in the 32-bit and
+    // and 64-bit case (with no more than 19 digits).
+    answer.mantissa += (answer.mantissa & 1); // round up
+    answer.mantissa >>= 1;
+    // There is a weird scenario where we don't have a subnormal but just.
+    // Suppose we start with 2.2250738585072013e-308, we end up
+    // with 0x3fffffffffffff x 2^-1023-53 which is technically subnormal
+    // whereas 0x40000000000000 x 2^-1023-53  is normal. Now, we need to round
+    // up 0x3fffffffffffff x 2^-1023-53  and once we do, we are no longer
+    // subnormal, but we can only know this after rounding.
+    // So we only declare a subnormal if we are smaller than the threshold.
+    answer.power2 =
+        (answer.mantissa < (uint64_t(1) << binary::mantissa_explicit_bits()))
+            ? 0
+            : 1;
+    return answer;
+  }
+
+  // usually, we round *up*, but if we fall right in between and and we have an
+  // even basis, we need to round down
+  // We are only concerned with the cases where 5**q fits in single 64-bit word.
+  if ((product.low <= 1) && (q >= binary::min_exponent_round_to_even()) &&
+      (q <= binary::max_exponent_round_to_even()) &&
+      ((answer.mantissa & 3) == 1)) { // we may fall between two floats!
+    // To be in-between two floats we need that in doing
+    //   answer.mantissa = product.high >> (upperbit + 64 -
+    //   binary::mantissa_explicit_bits() - 3);
+    // ... we dropped out only zeroes. But if this happened, then we can go
+    // back!!!
+    if ((answer.mantissa << shift) == product.high) {
+      answer.mantissa &= ~uint64_t(1); // flip it so that we do not round up
+    }
+  }
+
+  answer.mantissa += (answer.mantissa & 1); // round up
+  answer.mantissa >>= 1;
+  if (answer.mantissa >= (uint64_t(2) << binary::mantissa_explicit_bits())) {
+    answer.mantissa = (uint64_t(1) << binary::mantissa_explicit_bits());
+    answer.power2++; // undo previous addition
+  }
+
+  answer.mantissa &= ~(uint64_t(1) << binary::mantissa_explicit_bits());
+  if (answer.power2 >= binary::infinite_power()) { // infinity
+    answer.power2 = binary::infinite_power();
+    answer.mantissa = 0;
+  }
+  return answer;
+}
+
+} // namespace glz::fast_float
+
+#endif
+
+#ifndef GLZ_FASTFLOAT_BIGINT_H
+#define GLZ_FASTFLOAT_BIGINT_H
+
+#include <algorithm>
+#include <climits>
+#include <cstdint>
+#include <cstring>
+
+
+namespace glz::fast_float {
+
+// the limb width: we want efficient multiplication of double the bits in
+// limb, or for 64-bit limbs, at least 64-bit multiplication where we can
+// extract the high and low parts efficiently. this is every 64-bit
+// architecture except for sparc, which emulates 128-bit multiplication.
+// we might have platforms where `CHAR_BIT` is not 8, so let's avoid
+// doing `8 * sizeof(limb)`.
+#if defined(GLZ_FASTFLOAT_64BIT) && !defined(__sparc)
+#define GLZ_FASTFLOAT_64BIT_LIMB 1
+typedef uint64_t limb;
+constexpr size_t limb_bits = 64;
+#else
+#define GLZ_FASTFLOAT_32BIT_LIMB
+typedef uint32_t limb;
+constexpr size_t limb_bits = 32;
+#endif
+
+typedef span<limb> limb_span;
+
+// number of bits in a bigint. this needs to be at least the number
+// of bits required to store the largest bigint, which is
+// `log2(10**(digits + max_exp))`, or `log2(10**(767 + 342))`, or
+// ~3600 bits, so we round to 4000.
+constexpr size_t bigint_bits = 4000;
+constexpr size_t bigint_limbs = bigint_bits / limb_bits;
+
+// vector-like type that is allocated on the stack. the entire
+// buffer is pre-allocated, and only the length changes.
+template <uint16_t size> struct stackvec {
+  limb data[size];
+  // we never need more than 150 limbs
+  uint16_t length{0};
+
+  stackvec() = default;
+  stackvec(stackvec const &) = delete;
+  stackvec &operator=(stackvec const &) = delete;
+  stackvec(stackvec &&) = delete;
+  stackvec &operator=(stackvec &&other) = delete;
+
+  // create stack vector from existing limb span.
+  GLZ_FASTFLOAT_CONSTEXPR20 stackvec(limb_span s) {
+    GLZ_FASTFLOAT_ASSERT(try_extend(s));
+  }
+
+  GLZ_FASTFLOAT_CONSTEXPR14 limb &operator[](size_t index) noexcept {
+    GLZ_FASTFLOAT_DEBUG_ASSERT(index < length);
+    return data[index];
+  }
+
+  GLZ_FASTFLOAT_CONSTEXPR14 const limb &operator[](size_t index) const noexcept {
+    GLZ_FASTFLOAT_DEBUG_ASSERT(index < length);
+    return data[index];
+  }
+
+  // index from the end of the container
+  GLZ_FASTFLOAT_CONSTEXPR14 const limb &rindex(size_t index) const noexcept {
+    GLZ_FASTFLOAT_DEBUG_ASSERT(index < length);
+    size_t rindex = length - index - 1;
+    return data[rindex];
+  }
+
+  // set the length, without bounds checking.
+  GLZ_FASTFLOAT_CONSTEXPR14 void set_len(size_t len) noexcept {
+    length = uint16_t(len);
+  }
+
+  constexpr size_t len() const noexcept { return length; }
+
+  constexpr bool is_empty() const noexcept { return length == 0; }
+
+  constexpr size_t capacity() const noexcept { return size; }
+
+  // append item to vector, without bounds checking
+  GLZ_FASTFLOAT_CONSTEXPR14 void push_unchecked(limb value) noexcept {
+    data[length] = value;
+    length++;
+  }
+
+  // append item to vector, returning if item was added
+  GLZ_FASTFLOAT_CONSTEXPR14 bool try_push(limb value) noexcept {
+    if (len() < capacity()) {
+      push_unchecked(value);
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  // add items to the vector, from a span, without bounds checking
+  GLZ_FASTFLOAT_CONSTEXPR20 void extend_unchecked(limb_span s) noexcept {
+    limb *ptr = data + length;
+    std::copy_n(s.ptr, s.len(), ptr);
+    set_len(len() + s.len());
+  }
+
+  // try to add items to the vector, returning if items were added
+  GLZ_FASTFLOAT_CONSTEXPR20 bool try_extend(limb_span s) noexcept {
+    if (len() + s.len() <= capacity()) {
+      extend_unchecked(s);
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  // resize the vector, without bounds checking
+  // if the new size is longer than the vector, assign value to each
+  // appended item.
+  GLZ_FASTFLOAT_CONSTEXPR20
+  void resize_unchecked(size_t new_len, limb value) noexcept {
+    if (new_len > len()) {
+      size_t count = new_len - len();
+      limb *first = data + len();
+      limb *last = first + count;
+      ::std::fill(first, last, value);
+      set_len(new_len);
+    } else {
+      set_len(new_len);
+    }
+  }
+
+  // try to resize the vector, returning if the vector was resized.
+  GLZ_FASTFLOAT_CONSTEXPR20 bool try_resize(size_t new_len, limb value) noexcept {
+    if (new_len > capacity()) {
+      return false;
+    } else {
+      resize_unchecked(new_len, value);
+      return true;
+    }
+  }
+
+  // check if any limbs are non-zero after the given index.
+  // this needs to be done in reverse order, since the index
+  // is relative to the most significant limbs.
+  GLZ_FASTFLOAT_CONSTEXPR14 bool nonzero(size_t index) const noexcept {
+    while (index < len()) {
+      if (rindex(index) != 0) {
+        return true;
+      }
+      index++;
+    }
+    return false;
+  }
+
+  // normalize the big integer, so most-significant zero limbs are removed.
+  GLZ_FASTFLOAT_CONSTEXPR14 void normalize() noexcept {
+    while (len() > 0 && rindex(0) == 0) {
+      length--;
+    }
+  }
+};
+
+fastfloat_really_inline GLZ_FASTFLOAT_CONSTEXPR14 uint64_t
+empty_hi64(bool &truncated) noexcept {
+  truncated = false;
+  return 0;
+}
+
+fastfloat_really_inline GLZ_FASTFLOAT_CONSTEXPR20 uint64_t
+uint64_hi64(uint64_t r0, bool &truncated) noexcept {
+  truncated = false;
+  int shl = leading_zeroes(r0);
+  return r0 << shl;
+}
+
+fastfloat_really_inline GLZ_FASTFLOAT_CONSTEXPR20 uint64_t
+uint64_hi64(uint64_t r0, uint64_t r1, bool &truncated) noexcept {
+  int shl = leading_zeroes(r0);
+  if (shl == 0) {
+    truncated = r1 != 0;
+    return r0;
+  } else {
+    int shr = 64 - shl;
+    truncated = (r1 << shl) != 0;
+    return (r0 << shl) | (r1 >> shr);
+  }
+}
+
+fastfloat_really_inline GLZ_FASTFLOAT_CONSTEXPR20 uint64_t
+uint32_hi64(uint32_t r0, bool &truncated) noexcept {
+  return uint64_hi64(r0, truncated);
+}
+
+fastfloat_really_inline GLZ_FASTFLOAT_CONSTEXPR20 uint64_t
+uint32_hi64(uint32_t r0, uint32_t r1, bool &truncated) noexcept {
+  uint64_t x0 = r0;
+  uint64_t x1 = r1;
+  return uint64_hi64((x0 << 32) | x1, truncated);
+}
+
+fastfloat_really_inline GLZ_FASTFLOAT_CONSTEXPR20 uint64_t
+uint32_hi64(uint32_t r0, uint32_t r1, uint32_t r2, bool &truncated) noexcept {
+  uint64_t x0 = r0;
+  uint64_t x1 = r1;
+  uint64_t x2 = r2;
+  return uint64_hi64(x0, (x1 << 32) | x2, truncated);
+}
+
+// add two small integers, checking for overflow.
+// we want an efficient operation. for msvc, where
+// we don't have built-in intrinsics, this is still
+// pretty fast.
+fastfloat_really_inline GLZ_FASTFLOAT_CONSTEXPR20 limb
+scalar_add(limb x, limb y, bool &overflow) noexcept {
+  limb z;
+// gcc and clang
+#if defined(__has_builtin)
+#if __has_builtin(__builtin_add_overflow)
+  if (!cpp20_and_in_constexpr()) {
+    overflow = __builtin_add_overflow(x, y, &z);
+    return z;
+  }
+#endif
+#endif
+
+  // generic, this still optimizes correctly on MSVC.
+  z = x + y;
+  overflow = z < x;
+  return z;
+}
+
+// multiply two small integers, getting both the high and low bits.
+fastfloat_really_inline GLZ_FASTFLOAT_CONSTEXPR20 limb
+scalar_mul(limb x, limb y, limb &carry) noexcept {
+#ifdef GLZ_FASTFLOAT_64BIT_LIMB
+#if defined(__SIZEOF_INT128__)
+  // GCC and clang both define it as an extension.
+  __uint128_t z = __uint128_t(x) * __uint128_t(y) + __uint128_t(carry);
+  carry = limb(z >> limb_bits);
+  return limb(z);
+#else
+  // fallback, no native 128-bit integer multiplication with carry.
+  // on msvc, this optimizes identically, somehow.
+  value128 z = full_multiplication(x, y);
+  bool overflow;
+  z.low = scalar_add(z.low, carry, overflow);
+  z.high += uint64_t(overflow); // cannot overflow
+  carry = z.high;
+  return z.low;
+#endif
+#else
+  uint64_t z = uint64_t(x) * uint64_t(y) + uint64_t(carry);
+  carry = limb(z >> limb_bits);
+  return limb(z);
+#endif
+}
+
+// add scalar value to bigint starting from offset.
+// used in grade school multiplication
+template <uint16_t size>
+inline GLZ_FASTFLOAT_CONSTEXPR20 bool small_add_from(stackvec<size> &vec, limb y,
+                                                 size_t start) noexcept {
+  size_t index = start;
+  limb carry = y;
+  bool overflow;
+  while (carry != 0 && index < vec.len()) {
+    vec[index] = scalar_add(vec[index], carry, overflow);
+    carry = limb(overflow);
+    index += 1;
+  }
+  if (carry != 0) {
+    GLZ_FASTFLOAT_TRY(vec.try_push(carry));
+  }
+  return true;
+}
+
+// add scalar value to bigint.
+template <uint16_t size>
+fastfloat_really_inline GLZ_FASTFLOAT_CONSTEXPR20 bool
+small_add(stackvec<size> &vec, limb y) noexcept {
+  return small_add_from(vec, y, 0);
+}
+
+// multiply bigint by scalar value.
+template <uint16_t size>
+inline GLZ_FASTFLOAT_CONSTEXPR20 bool small_mul(stackvec<size> &vec,
+                                            limb y) noexcept {
+  limb carry = 0;
+  for (size_t index = 0; index < vec.len(); index++) {
+    vec[index] = scalar_mul(vec[index], y, carry);
+  }
+  if (carry != 0) {
+    GLZ_FASTFLOAT_TRY(vec.try_push(carry));
+  }
+  return true;
+}
+
+// add bigint to bigint starting from index.
+// used in grade school multiplication
+template <uint16_t size>
+GLZ_FASTFLOAT_CONSTEXPR20 bool large_add_from(stackvec<size> &x, limb_span y,
+                                          size_t start) noexcept {
+  // the effective x buffer is from `xstart..x.len()`, so exit early
+  // if we can't get that current range.
+  if (x.len() < start || y.len() > x.len() - start) {
+    GLZ_FASTFLOAT_TRY(x.try_resize(y.len() + start, 0));
+  }
+
+  bool carry = false;
+  for (size_t index = 0; index < y.len(); index++) {
+    limb xi = x[index + start];
+    limb yi = y[index];
+    bool c1 = false;
+    bool c2 = false;
+    xi = scalar_add(xi, yi, c1);
+    if (carry) {
+      xi = scalar_add(xi, 1, c2);
+    }
+    x[index + start] = xi;
+    carry = c1 | c2;
+  }
+
+  // handle overflow
+  if (carry) {
+    GLZ_FASTFLOAT_TRY(small_add_from(x, 1, y.len() + start));
+  }
+  return true;
+}
+
+// add bigint to bigint.
+template <uint16_t size>
+fastfloat_really_inline GLZ_FASTFLOAT_CONSTEXPR20 bool
+large_add_from(stackvec<size> &x, limb_span y) noexcept {
+  return large_add_from(x, y, 0);
+}
+
+// grade-school multiplication algorithm
+template <uint16_t size>
+GLZ_FASTFLOAT_CONSTEXPR20 bool long_mul(stackvec<size> &x, limb_span y) noexcept {
+  limb_span xs = limb_span(x.data, x.len());
+  stackvec<size> z(xs);
+  limb_span zs = limb_span(z.data, z.len());
+
+  if (y.len() != 0) {
+    limb y0 = y[0];
+    GLZ_FASTFLOAT_TRY(small_mul(x, y0));
+    for (size_t index = 1; index < y.len(); index++) {
+      limb yi = y[index];
+      stackvec<size> zi;
+      if (yi != 0) {
+        // re-use the same buffer throughout
+        zi.set_len(0);
+        GLZ_FASTFLOAT_TRY(zi.try_extend(zs));
+        GLZ_FASTFLOAT_TRY(small_mul(zi, yi));
+        limb_span zis = limb_span(zi.data, zi.len());
+        GLZ_FASTFLOAT_TRY(large_add_from(x, zis, index));
+      }
+    }
+  }
+
+  x.normalize();
+  return true;
+}
+
+// grade-school multiplication algorithm
+template <uint16_t size>
+GLZ_FASTFLOAT_CONSTEXPR20 bool large_mul(stackvec<size> &x, limb_span y) noexcept {
+  if (y.len() == 1) {
+    GLZ_FASTFLOAT_TRY(small_mul(x, y[0]));
+  } else {
+    GLZ_FASTFLOAT_TRY(long_mul(x, y));
+  }
+  return true;
+}
+
+template <typename = void> struct pow5_tables {
+  static constexpr uint32_t large_step = 135;
+  static constexpr uint64_t small_power_of_5[] = {
+      1UL,
+      5UL,
+      25UL,
+      125UL,
+      625UL,
+      3125UL,
+      15625UL,
+      78125UL,
+      390625UL,
+      1953125UL,
+      9765625UL,
+      48828125UL,
+      244140625UL,
+      1220703125UL,
+      6103515625UL,
+      30517578125UL,
+      152587890625UL,
+      762939453125UL,
+      3814697265625UL,
+      19073486328125UL,
+      95367431640625UL,
+      476837158203125UL,
+      2384185791015625UL,
+      11920928955078125UL,
+      59604644775390625UL,
+      298023223876953125UL,
+      1490116119384765625UL,
+      7450580596923828125UL,
+  };
+#ifdef GLZ_FASTFLOAT_64BIT_LIMB
+  constexpr static limb large_power_of_5[] = {
+      1414648277510068013UL, 9180637584431281687UL, 4539964771860779200UL,
+      10482974169319127550UL, 198276706040285095UL};
+#else
+  constexpr static limb large_power_of_5[] = {
+      4279965485U, 329373468U,  4020270615U, 2137533757U, 4287402176U,
+      1057042919U, 1071430142U, 2440757623U, 381945767U,  46164893U};
+#endif
+};
+
+#if GLZ_FASTFLOAT_DETAIL_MUST_DEFINE_CONSTEXPR_VARIABLE
+
+template <typename T> constexpr uint32_t pow5_tables<T>::large_step;
+
+template <typename T> constexpr uint64_t pow5_tables<T>::small_power_of_5[];
+
+template <typename T> constexpr limb pow5_tables<T>::large_power_of_5[];
+
+#endif
+
+// big integer type. implements a small subset of big integer
+// arithmetic, using simple algorithms since asymptotically
+// faster algorithms are slower for a small number of limbs.
+// all operations assume the big-integer is normalized.
+struct bigint : pow5_tables<> {
+  // storage of the limbs, in little-endian order.
+  stackvec<bigint_limbs> vec;
+
+  GLZ_FASTFLOAT_CONSTEXPR20 bigint() : vec() {}
+
+  bigint(bigint const &) = delete;
+  bigint &operator=(bigint const &) = delete;
+  bigint(bigint &&) = delete;
+  bigint &operator=(bigint &&other) = delete;
+
+  GLZ_FASTFLOAT_CONSTEXPR20 bigint(uint64_t value) : vec() {
+#ifdef GLZ_FASTFLOAT_64BIT_LIMB
+    vec.push_unchecked(value);
+#else
+    vec.push_unchecked(uint32_t(value));
+    vec.push_unchecked(uint32_t(value >> 32));
+#endif
+    vec.normalize();
+  }
+
+  // get the high 64 bits from the vector, and if bits were truncated.
+  // this is to get the significant digits for the float.
+  GLZ_FASTFLOAT_CONSTEXPR20 uint64_t hi64(bool &truncated) const noexcept {
+#ifdef GLZ_FASTFLOAT_64BIT_LIMB
+    if (vec.len() == 0) {
+      return empty_hi64(truncated);
+    } else if (vec.len() == 1) {
+      return uint64_hi64(vec.rindex(0), truncated);
+    } else {
+      uint64_t result = uint64_hi64(vec.rindex(0), vec.rindex(1), truncated);
+      truncated |= vec.nonzero(2);
+      return result;
+    }
+#else
+    if (vec.len() == 0) {
+      return empty_hi64(truncated);
+    } else if (vec.len() == 1) {
+      return uint32_hi64(vec.rindex(0), truncated);
+    } else if (vec.len() == 2) {
+      return uint32_hi64(vec.rindex(0), vec.rindex(1), truncated);
+    } else {
+      uint64_t result =
+          uint32_hi64(vec.rindex(0), vec.rindex(1), vec.rindex(2), truncated);
+      truncated |= vec.nonzero(3);
+      return result;
+    }
+#endif
+  }
+
+  // compare two big integers, returning the large value.
+  // assumes both are normalized. if the return value is
+  // negative, other is larger, if the return value is
+  // positive, this is larger, otherwise they are equal.
+  // the limbs are stored in little-endian order, so we
+  // must compare the limbs in ever order.
+  GLZ_FASTFLOAT_CONSTEXPR20 int compare(bigint const &other) const noexcept {
+    if (vec.len() > other.vec.len()) {
+      return 1;
+    } else if (vec.len() < other.vec.len()) {
+      return -1;
+    } else {
+      for (size_t index = vec.len(); index > 0; index--) {
+        limb xi = vec[index - 1];
+        limb yi = other.vec[index - 1];
+        if (xi > yi) {
+          return 1;
+        } else if (xi < yi) {
+          return -1;
+        }
+      }
+      return 0;
+    }
+  }
+
+  // shift left each limb n bits, carrying over to the new limb
+  // returns true if we were able to shift all the digits.
+  GLZ_FASTFLOAT_CONSTEXPR20 bool shl_bits(size_t n) noexcept {
+    // Internally, for each item, we shift left by n, and add the previous
+    // right shifted limb-bits.
+    // For example, we transform (for u8) shifted left 2, to:
+    //      b10100100 b01000010
+    //      b10 b10010001 b00001000
+    GLZ_FASTFLOAT_DEBUG_ASSERT(n != 0);
+    GLZ_FASTFLOAT_DEBUG_ASSERT(n < sizeof(limb) * 8);
+
+    size_t shl = n;
+    size_t shr = limb_bits - shl;
+    limb prev = 0;
+    for (size_t index = 0; index < vec.len(); index++) {
+      limb xi = vec[index];
+      vec[index] = (xi << shl) | (prev >> shr);
+      prev = xi;
+    }
+
+    limb carry = prev >> shr;
+    if (carry != 0) {
+      return vec.try_push(carry);
+    }
+    return true;
+  }
+
+  // move the limbs left by `n` limbs.
+  GLZ_FASTFLOAT_CONSTEXPR20 bool shl_limbs(size_t n) noexcept {
+    GLZ_FASTFLOAT_DEBUG_ASSERT(n != 0);
+    if (n + vec.len() > vec.capacity()) {
+      return false;
+    } else if (!vec.is_empty()) {
+      // move limbs
+      limb *dst = vec.data + n;
+      limb const *src = vec.data;
+      std::copy_backward(src, src + vec.len(), dst + vec.len());
+      // fill in empty limbs
+      limb *first = vec.data;
+      limb *last = first + n;
+      ::std::fill(first, last, 0);
+      vec.set_len(n + vec.len());
+      return true;
+    } else {
+      return true;
+    }
+  }
+
+  // move the limbs left by `n` bits.
+  GLZ_FASTFLOAT_CONSTEXPR20 bool shl(size_t n) noexcept {
+    size_t rem = n % limb_bits;
+    size_t div = n / limb_bits;
+    if (rem != 0) {
+      GLZ_FASTFLOAT_TRY(shl_bits(rem));
+    }
+    if (div != 0) {
+      GLZ_FASTFLOAT_TRY(shl_limbs(div));
+    }
+    return true;
+  }
+
+  // get the number of leading zeros in the bigint.
+  GLZ_FASTFLOAT_CONSTEXPR20 int ctlz() const noexcept {
+    if (vec.is_empty()) {
+      return 0;
+    } else {
+#ifdef GLZ_FASTFLOAT_64BIT_LIMB
+      return leading_zeroes(vec.rindex(0));
+#else
+      // no use defining a specialized leading_zeroes for a 32-bit type.
+      uint64_t r0 = vec.rindex(0);
+      return leading_zeroes(r0 << 32);
+#endif
+    }
+  }
+
+  // get the number of bits in the bigint.
+  GLZ_FASTFLOAT_CONSTEXPR20 int bit_length() const noexcept {
+    int lz = ctlz();
+    return int(limb_bits * vec.len()) - lz;
+  }
+
+  GLZ_FASTFLOAT_CONSTEXPR20 bool mul(limb y) noexcept { return small_mul(vec, y); }
+
+  GLZ_FASTFLOAT_CONSTEXPR20 bool add(limb y) noexcept { return small_add(vec, y); }
+
+  // multiply as if by 2 raised to a power.
+  GLZ_FASTFLOAT_CONSTEXPR20 bool pow2(uint32_t exp) noexcept { return shl(exp); }
+
+  // multiply as if by 5 raised to a power.
+  GLZ_FASTFLOAT_CONSTEXPR20 bool pow5(uint32_t exp) noexcept {
+    // multiply by a power of 5
+    size_t large_length = sizeof(large_power_of_5) / sizeof(limb);
+    limb_span large = limb_span(large_power_of_5, large_length);
+    while (exp >= large_step) {
+      GLZ_FASTFLOAT_TRY(large_mul(vec, large));
+      exp -= large_step;
+    }
+#ifdef GLZ_FASTFLOAT_64BIT_LIMB
+    uint32_t small_step = 27;
+    limb max_native = 7450580596923828125UL;
+#else
+    uint32_t small_step = 13;
+    limb max_native = 1220703125U;
+#endif
+    while (exp >= small_step) {
+      GLZ_FASTFLOAT_TRY(small_mul(vec, max_native));
+      exp -= small_step;
+    }
+    if (exp != 0) {
+      // Work around clang bug https://godbolt.org/z/zedh7rrhc
+      // This is similar to https://github.com/llvm/llvm-project/issues/47746,
+      // except the workaround described there don't work here
+      GLZ_FASTFLOAT_TRY(small_mul(
+          vec, limb(((void)small_power_of_5[0], small_power_of_5[exp]))));
+    }
+
+    return true;
+  }
+
+  // multiply as if by 10 raised to a power.
+  GLZ_FASTFLOAT_CONSTEXPR20 bool pow10(uint32_t exp) noexcept {
+    GLZ_FASTFLOAT_TRY(pow5(exp));
+    return pow2(exp);
+  }
+};
+
+} // namespace glz::fast_float
+
+#endif
+
+#ifndef GLZ_FASTFLOAT_DIGIT_COMPARISON_H
+#define GLZ_FASTFLOAT_DIGIT_COMPARISON_H
+
+#include <algorithm>
+#include <cstdint>
+#include <cstring>
+#include <iterator>
+
+
+namespace glz::fast_float {
+
+// 1e0 to 1e19
+constexpr static uint64_t powers_of_ten_uint64[] = {1UL,
+                                                    10UL,
+                                                    100UL,
+                                                    1000UL,
+                                                    10000UL,
+                                                    100000UL,
+                                                    1000000UL,
+                                                    10000000UL,
+                                                    100000000UL,
+                                                    1000000000UL,
+                                                    10000000000UL,
+                                                    100000000000UL,
+                                                    1000000000000UL,
+                                                    10000000000000UL,
+                                                    100000000000000UL,
+                                                    1000000000000000UL,
+                                                    10000000000000000UL,
+                                                    100000000000000000UL,
+                                                    1000000000000000000UL,
+                                                    10000000000000000000UL};
+
+// calculate the exponent, in scientific notation, of the number.
+// this algorithm is not even close to optimized, but it has no practical
+// effect on performance: in order to have a faster algorithm, we'd need
+// to slow down performance for faster algorithms, and this is still fast.
+template <typename UC>
+fastfloat_really_inline GLZ_FASTFLOAT_CONSTEXPR14 int32_t
+scientific_exponent(parsed_number_string_t<UC> &num) noexcept {
+  uint64_t mantissa = num.mantissa;
+  int32_t exponent = int32_t(num.exponent);
+  while (mantissa >= 10000) {
+    mantissa /= 10000;
+    exponent += 4;
+  }
+  while (mantissa >= 100) {
+    mantissa /= 100;
+    exponent += 2;
+  }
+  while (mantissa >= 10) {
+    mantissa /= 10;
+    exponent += 1;
+  }
+  return exponent;
+}
+
+// this converts a native floating-point number to an extended-precision float.
+template <typename T>
+fastfloat_really_inline GLZ_FASTFLOAT_CONSTEXPR20 adjusted_mantissa
+to_extended(T value) noexcept {
+  using equiv_uint = equiv_uint_t<T>;
+  constexpr equiv_uint exponent_mask = binary_format<T>::exponent_mask();
+  constexpr equiv_uint mantissa_mask = binary_format<T>::mantissa_mask();
+  constexpr equiv_uint hidden_bit_mask = binary_format<T>::hidden_bit_mask();
+
+  adjusted_mantissa am;
+  int32_t bias = binary_format<T>::mantissa_explicit_bits() -
+                 binary_format<T>::minimum_exponent();
+  equiv_uint bits;
+#if GLZ_FASTFLOAT_HAS_BIT_CAST
+  bits = std::bit_cast<equiv_uint>(value);
+#else
+  ::memcpy(&bits, &value, sizeof(T));
+#endif
+  if ((bits & exponent_mask) == 0) {
+    // denormal
+    am.power2 = 1 - bias;
+    am.mantissa = bits & mantissa_mask;
+  } else {
+    // normal
+    am.power2 = int32_t((bits & exponent_mask) >>
+                        binary_format<T>::mantissa_explicit_bits());
+    am.power2 -= bias;
+    am.mantissa = (bits & mantissa_mask) | hidden_bit_mask;
+  }
+
+  return am;
+}
+
+// get the extended precision value of the halfway point between b and b+u.
+// we are given a native float that represents b, so we need to adjust it
+// halfway between b and b+u.
+template <typename T>
+fastfloat_really_inline GLZ_FASTFLOAT_CONSTEXPR20 adjusted_mantissa
+to_extended_halfway(T value) noexcept {
+  adjusted_mantissa am = to_extended(value);
+  am.mantissa <<= 1;
+  am.mantissa += 1;
+  am.power2 -= 1;
+  return am;
+}
+
+// round an extended-precision float to the nearest machine float.
+template <typename T, typename callback>
+fastfloat_really_inline GLZ_FASTFLOAT_CONSTEXPR14 void round(adjusted_mantissa &am,
+                                                         callback cb) noexcept {
+  int32_t mantissa_shift = 64 - binary_format<T>::mantissa_explicit_bits() - 1;
+  if (-am.power2 >= mantissa_shift) {
+    // have a denormal float
+    int32_t shift = -am.power2 + 1;
+    cb(am, std::min<int32_t>(shift, 64));
+    // check for round-up: if rounding-nearest carried us to the hidden bit.
+    am.power2 = (am.mantissa <
+                 (uint64_t(1) << binary_format<T>::mantissa_explicit_bits()))
+                    ? 0
+                    : 1;
+    return;
+  }
+
+  // have a normal float, use the default shift.
+  cb(am, mantissa_shift);
+
+  // check for carry
+  if (am.mantissa >=
+      (uint64_t(2) << binary_format<T>::mantissa_explicit_bits())) {
+    am.mantissa = (uint64_t(1) << binary_format<T>::mantissa_explicit_bits());
+    am.power2++;
+  }
+
+  // check for infinite: we could have carried to an infinite power
+  am.mantissa &= ~(uint64_t(1) << binary_format<T>::mantissa_explicit_bits());
+  if (am.power2 >= binary_format<T>::infinite_power()) {
+    am.power2 = binary_format<T>::infinite_power();
+    am.mantissa = 0;
+  }
+}
+
+template <typename callback>
+fastfloat_really_inline GLZ_FASTFLOAT_CONSTEXPR14 void
+round_nearest_tie_even(adjusted_mantissa &am, int32_t shift,
+                       callback cb) noexcept {
+  uint64_t const mask = (shift == 64) ? UINT64_MAX : (uint64_t(1) << shift) - 1;
+  uint64_t const halfway = (shift == 0) ? 0 : uint64_t(1) << (shift - 1);
+  uint64_t truncated_bits = am.mantissa & mask;
+  bool is_above = truncated_bits > halfway;
+  bool is_halfway = truncated_bits == halfway;
+
+  // shift digits into position
+  if (shift == 64) {
+    am.mantissa = 0;
+  } else {
+    am.mantissa >>= shift;
+  }
+  am.power2 += shift;
+
+  bool is_odd = (am.mantissa & 1) == 1;
+  am.mantissa += uint64_t(cb(is_odd, is_halfway, is_above));
+}
+
+fastfloat_really_inline GLZ_FASTFLOAT_CONSTEXPR14 void
+round_down(adjusted_mantissa &am, int32_t shift) noexcept {
+  if (shift == 64) {
+    am.mantissa = 0;
+  } else {
+    am.mantissa >>= shift;
+  }
+  am.power2 += shift;
+}
+
+template <typename UC>
+fastfloat_really_inline GLZ_FASTFLOAT_CONSTEXPR20 void
+skip_zeros(UC const *&first, UC const *last) noexcept {
+  uint64_t val;
+  while (!cpp20_and_in_constexpr() &&
+         std::distance(first, last) >= int_cmp_len<UC>()) {
+    ::memcpy(&val, first, sizeof(uint64_t));
+    if (val != int_cmp_zeros<UC>()) {
+      break;
+    }
+    first += int_cmp_len<UC>();
+  }
+  while (first != last) {
+    if (*first != UC('0')) {
+      break;
+    }
+    first++;
+  }
+}
+
+// determine if any non-zero digits were truncated.
+// all characters must be valid digits.
+template <typename UC>
+fastfloat_really_inline GLZ_FASTFLOAT_CONSTEXPR20 bool
+is_truncated(UC const *first, UC const *last) noexcept {
+  // do 8-bit optimizations, can just compare to 8 literal 0s.
+  uint64_t val;
+  while (!cpp20_and_in_constexpr() &&
+         std::distance(first, last) >= int_cmp_len<UC>()) {
+    ::memcpy(&val, first, sizeof(uint64_t));
+    if (val != int_cmp_zeros<UC>()) {
+      return true;
+    }
+    first += int_cmp_len<UC>();
+  }
+  while (first != last) {
+    if (*first != UC('0')) {
+      return true;
+    }
+    ++first;
+  }
+  return false;
+}
+
+template <typename UC>
+fastfloat_really_inline GLZ_FASTFLOAT_CONSTEXPR20 bool
+is_truncated(span<UC const> s) noexcept {
+  return is_truncated(s.ptr, s.ptr + s.len());
+}
+
+template <typename UC>
+fastfloat_really_inline GLZ_FASTFLOAT_CONSTEXPR20 void
+parse_eight_digits(UC const *&p, limb &value, size_t &counter,
+                   size_t &count) noexcept {
+  value = value * 100000000 + parse_eight_digits_unrolled(p);
+  p += 8;
+  counter += 8;
+  count += 8;
+}
+
+template <typename UC>
+fastfloat_really_inline GLZ_FASTFLOAT_CONSTEXPR14 void
+parse_one_digit(UC const *&p, limb &value, size_t &counter,
+                size_t &count) noexcept {
+  value = value * 10 + limb(*p - UC('0'));
+  p++;
+  counter++;
+  count++;
+}
+
+fastfloat_really_inline GLZ_FASTFLOAT_CONSTEXPR20 void
+add_native(bigint &big, limb power, limb value) noexcept {
+  big.mul(power);
+  big.add(value);
+}
+
+fastfloat_really_inline GLZ_FASTFLOAT_CONSTEXPR20 void
+round_up_bigint(bigint &big, size_t &count) noexcept {
+  // need to round-up the digits, but need to avoid rounding
+  // ....9999 to ...10000, which could cause a false halfway point.
+  add_native(big, 10, 1);
+  count++;
+}
+
+// parse the significant digits into a big integer
+template <typename UC>
+inline GLZ_FASTFLOAT_CONSTEXPR20 void
+parse_mantissa(bigint &result, parsed_number_string_t<UC> &num,
+               size_t max_digits, size_t &digits) noexcept {
+  // try to minimize the number of big integer and scalar multiplication.
+  // therefore, try to parse 8 digits at a time, and multiply by the largest
+  // scalar value (9 or 19 digits) for each step.
+  size_t counter = 0;
+  digits = 0;
+  limb value = 0;
+#ifdef GLZ_FASTFLOAT_64BIT_LIMB
+  size_t step = 19;
+#else
+  size_t step = 9;
+#endif
+
+  // process all integer digits.
+  UC const *p = num.integer.ptr;
+  UC const *pend = p + num.integer.len();
+  skip_zeros(p, pend);
+  // process all digits, in increments of step per loop
+  while (p != pend) {
+    while ((std::distance(p, pend) >= 8) && (step - counter >= 8) &&
+           (max_digits - digits >= 8)) {
+      parse_eight_digits(p, value, counter, digits);
+    }
+    while (counter < step && p != pend && digits < max_digits) {
+      parse_one_digit(p, value, counter, digits);
+    }
+    if (digits == max_digits) {
+      // add the temporary value, then check if we've truncated any digits
+      add_native(result, limb(powers_of_ten_uint64[counter]), value);
+      bool truncated = is_truncated(p, pend);
+      if (num.fraction.ptr != nullptr) {
+        truncated |= is_truncated(num.fraction);
+      }
+      if (truncated) {
+        round_up_bigint(result, digits);
+      }
+      return;
+    } else {
+      add_native(result, limb(powers_of_ten_uint64[counter]), value);
+      counter = 0;
+      value = 0;
+    }
+  }
+
+  // add our fraction digits, if they're available.
+  if (num.fraction.ptr != nullptr) {
+    p = num.fraction.ptr;
+    pend = p + num.fraction.len();
+    if (digits == 0) {
+      skip_zeros(p, pend);
+    }
+    // process all digits, in increments of step per loop
+    while (p != pend) {
+      while ((std::distance(p, pend) >= 8) && (step - counter >= 8) &&
+             (max_digits - digits >= 8)) {
+        parse_eight_digits(p, value, counter, digits);
+      }
+      while (counter < step && p != pend && digits < max_digits) {
+        parse_one_digit(p, value, counter, digits);
+      }
+      if (digits == max_digits) {
+        // add the temporary value, then check if we've truncated any digits
+        add_native(result, limb(powers_of_ten_uint64[counter]), value);
+        bool truncated = is_truncated(p, pend);
+        if (truncated) {
+          round_up_bigint(result, digits);
+        }
+        return;
+      } else {
+        add_native(result, limb(powers_of_ten_uint64[counter]), value);
+        counter = 0;
+        value = 0;
+      }
+    }
+  }
+
+  if (counter != 0) {
+    add_native(result, limb(powers_of_ten_uint64[counter]), value);
+  }
+}
+
+template <typename T>
+inline GLZ_FASTFLOAT_CONSTEXPR20 adjusted_mantissa
+positive_digit_comp(bigint &bigmant, int32_t exponent) noexcept {
+  GLZ_FASTFLOAT_ASSERT(bigmant.pow10(uint32_t(exponent)));
+  adjusted_mantissa answer;
+  bool truncated;
+  answer.mantissa = bigmant.hi64(truncated);
+  int bias = binary_format<T>::mantissa_explicit_bits() -
+             binary_format<T>::minimum_exponent();
+  answer.power2 = bigmant.bit_length() - 64 + bias;
+
+  round<T>(answer, [truncated](adjusted_mantissa &a, int32_t shift) {
+    round_nearest_tie_even(
+        a, shift,
+        [truncated](bool is_odd, bool is_halfway, bool is_above) -> bool {
+          return is_above || (is_halfway && truncated) ||
+                 (is_odd && is_halfway);
+        });
+  });
+
+  return answer;
+}
+
+// the scaling here is quite simple: we have, for the real digits `m * 10^e`,
+// and for the theoretical digits `n * 2^f`. Since `e` is always negative,
+// to scale them identically, we do `n * 2^f * 5^-f`, so we now have `m * 2^e`.
+// we then need to scale by `2^(f- e)`, and then the two significant digits
+// are of the same magnitude.
+template <typename T>
+inline GLZ_FASTFLOAT_CONSTEXPR20 adjusted_mantissa negative_digit_comp(
+    bigint &bigmant, adjusted_mantissa am, int32_t exponent) noexcept {
+  bigint &real_digits = bigmant;
+  int32_t real_exp = exponent;
+
+  // get the value of `b`, rounded down, and get a bigint representation of b+h
+  adjusted_mantissa am_b = am;
+  // gcc7 buf: use a lambda to remove the noexcept qualifier bug with
+  // -Wnoexcept-type.
+  round<T>(am_b,
+           [](adjusted_mantissa &a, int32_t shift) { round_down(a, shift); });
+  T b;
+  to_float(false, am_b, b);
+  adjusted_mantissa theor = to_extended_halfway(b);
+  bigint theor_digits(theor.mantissa);
+  int32_t theor_exp = theor.power2;
+
+  // scale real digits and theor digits to be same power.
+  int32_t pow2_exp = theor_exp - real_exp;
+  uint32_t pow5_exp = uint32_t(-real_exp);
+  if (pow5_exp != 0) {
+    GLZ_FASTFLOAT_ASSERT(theor_digits.pow5(pow5_exp));
+  }
+  if (pow2_exp > 0) {
+    GLZ_FASTFLOAT_ASSERT(theor_digits.pow2(uint32_t(pow2_exp)));
+  } else if (pow2_exp < 0) {
+    GLZ_FASTFLOAT_ASSERT(real_digits.pow2(uint32_t(-pow2_exp)));
+  }
+
+  // compare digits, and use it to director rounding
+  int ord = real_digits.compare(theor_digits);
+  adjusted_mantissa answer = am;
+  round<T>(answer, [ord](adjusted_mantissa &a, int32_t shift) {
+    round_nearest_tie_even(
+        a, shift, [ord](bool is_odd, bool _, bool __) -> bool {
+          (void)_;  // not needed, since we've done our comparison
+          (void)__; // not needed, since we've done our comparison
+          if (ord > 0) {
+            return true;
+          } else if (ord < 0) {
+            return false;
+          } else {
+            return is_odd;
+          }
+        });
+  });
+
+  return answer;
+}
+
+// parse the significant digits as a big integer to unambiguously round the
+// the significant digits. here, we are trying to determine how to round
+// an extended float representation close to `b+h`, halfway between `b`
+// (the float rounded-down) and `b+u`, the next positive float. this
+// algorithm is always correct, and uses one of two approaches. when
+// the exponent is positive relative to the significant digits (such as
+// 1234), we create a big-integer representation, get the high 64-bits,
+// determine if any lower bits are truncated, and use that to direct
+// rounding. in case of a negative exponent relative to the significant
+// digits (such as 1.2345), we create a theoretical representation of
+// `b` as a big-integer type, scaled to the same binary exponent as
+// the actual digits. we then compare the big integer representations
+// of both, and use that to direct rounding.
+template <typename T, typename UC>
+inline GLZ_FASTFLOAT_CONSTEXPR20 adjusted_mantissa
+digit_comp(parsed_number_string_t<UC> &num, adjusted_mantissa am) noexcept {
+  // remove the invalid exponent bias
+  am.power2 -= invalid_am_bias;
+
+  int32_t sci_exp = scientific_exponent(num);
+  size_t max_digits = binary_format<T>::max_digits();
+  size_t digits = 0;
+  bigint bigmant;
+  parse_mantissa(bigmant, num, max_digits, digits);
+  // can't underflow, since digits is at most max_digits.
+  int32_t exponent = sci_exp + 1 - int32_t(digits);
+  if (exponent >= 0) {
+    return positive_digit_comp<T>(bigmant, exponent);
+  } else {
+    return negative_digit_comp<T>(bigmant, am, exponent);
+  }
+}
+
+} // namespace glz::fast_float
+
+#endif
+
+#ifndef GLZ_FASTFLOAT_PARSE_NUMBER_H
+#define GLZ_FASTFLOAT_PARSE_NUMBER_H
+
+
+#include <cmath>
+#include <cstring>
+#include <limits>
+#include <system_error>
+
+namespace glz::fast_float {
+
+namespace detail {
+/**
+ * Special case +inf, -inf, nan, infinity, -infinity.
+ * The case comparisons could be made much faster given that we know that the
+ * strings a null-free and fixed.
+ **/
+template <typename T, typename UC>
+from_chars_result_t<UC>
+    GLZ_FASTFLOAT_CONSTEXPR14 parse_infnan(UC const *first, UC const *last,
+                                       T &value, chars_format fmt) noexcept {
+  from_chars_result_t<UC> answer{};
+  answer.ptr = first;
+  answer.ec = std::errc(); // be optimistic
+  // assume first < last, so dereference without checks;
+  bool const minusSign = (*first == UC('-'));
+  // C++17 20.19.3.(7.1) explicitly forbids '+' sign here
+  if ((*first == UC('-')) ||
+      (uint64_t(fmt & chars_format::allow_leading_plus) &&
+       (*first == UC('+')))) {
+    ++first;
+  }
+  if (last - first >= 3) {
+    if (fastfloat_strncasecmp(first, str_const_nan<UC>(), 3)) {
+      answer.ptr = (first += 3);
+      value = minusSign ? -std::numeric_limits<T>::quiet_NaN()
+                        : std::numeric_limits<T>::quiet_NaN();
+      // Check for possible nan(n-char-seq-opt), C++17 20.19.3.7,
+      // C11 7.20.1.3.3. At least MSVC produces nan(ind) and nan(snan).
+      if (first != last && *first == UC('(')) {
+        for (UC const *ptr = first + 1; ptr != last; ++ptr) {
+          if (*ptr == UC(')')) {
+            answer.ptr = ptr + 1; // valid nan(n-char-seq-opt)
+            break;
+          } else if (!((UC('a') <= *ptr && *ptr <= UC('z')) ||
+                       (UC('A') <= *ptr && *ptr <= UC('Z')) ||
+                       (UC('0') <= *ptr && *ptr <= UC('9')) || *ptr == UC('_')))
+            break; // forbidden char, not nan(n-char-seq-opt)
+        }
+      }
+      return answer;
+    }
+    if (fastfloat_strncasecmp(first, str_const_inf<UC>(), 3)) {
+      if ((last - first >= 8) &&
+          fastfloat_strncasecmp(first + 3, str_const_inf<UC>() + 3, 5)) {
+        answer.ptr = first + 8;
+      } else {
+        answer.ptr = first + 3;
+      }
+      value = minusSign ? -std::numeric_limits<T>::infinity()
+                        : std::numeric_limits<T>::infinity();
+      return answer;
+    }
+  }
+  answer.ec = std::errc::invalid_argument;
+  return answer;
+}
+
+/**
+ * Returns true if the floating-pointing rounding mode is to 'nearest'.
+ * It is the default on most system. This function is meant to be inexpensive.
+ * Credit : @mwalcott3
+ */
+fastfloat_really_inline bool rounds_to_nearest() noexcept {
+  // https://lemire.me/blog/2020/06/26/gcc-not-nearest/
+#if (FLT_EVAL_METHOD != 1) && (FLT_EVAL_METHOD != 0)
+  return false;
+#endif
+  // See
+  // A fast function to check your floating-point rounding mode
+  // https://lemire.me/blog/2022/11/16/a-fast-function-to-check-your-floating-point-rounding-mode/
+  //
+  // This function is meant to be equivalent to :
+  // prior: #include <cfenv>
+  //  return fegetround() == FE_TONEAREST;
+  // However, it is expected to be much faster than the fegetround()
+  // function call.
+  //
+  // The volatile keyword prevents the compiler from computing the function
+  // at compile-time.
+  // There might be other ways to prevent compile-time optimizations (e.g.,
+  // asm). The value does not need to be std::numeric_limits<float>::min(), any
+  // small value so that 1 + x should round to 1 would do (after accounting for
+  // excess precision, as in 387 instructions).
+  static float volatile fmin = std::numeric_limits<float>::min();
+  float fmini = fmin; // we copy it so that it gets loaded at most once.
+//
+// Explanation:
+// Only when fegetround() == FE_TONEAREST do we have that
+// fmin + 1.0f == 1.0f - fmin.
+//
+// FE_UPWARD:
+//  fmin + 1.0f > 1
+//  1.0f - fmin == 1
+//
+// FE_DOWNWARD or  FE_TOWARDZERO:
+//  fmin + 1.0f == 1
+//  1.0f - fmin < 1
+//
+// Note: This may fail to be accurate if fast-math has been
+// enabled, as rounding conventions may not apply.
+#ifdef GLZ_FASTFLOAT_VISUAL_STUDIO
+#pragma warning(push)
+//  todo: is there a VS warning?
+//  see
+//  https://stackoverflow.com/questions/46079446/is-there-a-warning-for-floating-point-equality-checking-in-visual-studio-2013
+#elif defined(__clang__)
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wfloat-equal"
+#elif defined(__GNUC__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+  return (fmini + 1.0f == 1.0f - fmini);
+#ifdef GLZ_FASTFLOAT_VISUAL_STUDIO
+#pragma warning(pop)
+#elif defined(__clang__)
+#pragma clang diagnostic pop
+#elif defined(__GNUC__)
+#pragma GCC diagnostic pop
+#endif
+}
+
+} // namespace detail
+
+template <typename T> struct from_chars_caller {
+  template <typename UC>
+  GLZ_FASTFLOAT_CONSTEXPR20 static from_chars_result_t<UC>
+  call(UC const *first, UC const *last, T &value,
+       parse_options_t<UC> options) noexcept {
+    return from_chars_advanced(first, last, value, options);
+  }
+};
+
+#ifdef __STDCPP_FLOAT32_T__
+template <> struct from_chars_caller<std::float32_t> {
+  template <typename UC>
+  GLZ_FASTFLOAT_CONSTEXPR20 static from_chars_result_t<UC>
+  call(UC const *first, UC const *last, std::float32_t &value,
+       parse_options_t<UC> options) noexcept {
+    // if std::float32_t is defined, and we are in C++23 mode; macro set for
+    // float32; set value to float due to equivalence between float and
+    // float32_t
+    float val;
+    auto ret = from_chars_advanced(first, last, val, options);
+    value = val;
+    return ret;
+  }
+};
+#endif
+
+#ifdef __STDCPP_FLOAT64_T__
+template <> struct from_chars_caller<std::float64_t> {
+  template <typename UC>
+  GLZ_FASTFLOAT_CONSTEXPR20 static from_chars_result_t<UC>
+  call(UC const *first, UC const *last, std::float64_t &value,
+       parse_options_t<UC> options) noexcept {
+    // if std::float64_t is defined, and we are in C++23 mode; macro set for
+    // float64; set value as double due to equivalence between double and
+    // float64_t
+    double val;
+    auto ret = from_chars_advanced(first, last, val, options);
+    value = val;
+    return ret;
+  }
+};
+#endif
+
+template <typename T, typename UC, typename>
+GLZ_FASTFLOAT_CONSTEXPR20 from_chars_result_t<UC>
+from_chars(UC const *first, UC const *last, T &value,
+           chars_format fmt /*= chars_format::general*/) noexcept {
+  return from_chars_caller<T>::call(first, last, value,
+                                    parse_options_t<UC>(fmt));
+}
+
+/**
+ * This function overload takes parsed_number_string_t structure that is created
+ * and populated either by from_chars_advanced function taking chars range and
+ * parsing options or other parsing custom function implemented by user.
+ */
+template <typename T, typename UC>
+GLZ_FASTFLOAT_CONSTEXPR20 from_chars_result_t<UC>
+from_chars_advanced(parsed_number_string_t<UC> &pns, T &value) noexcept {
+
+  static_assert(is_supported_float_type<T>::value,
+                "only some floating-point types are supported");
+  static_assert(is_supported_char_type<UC>::value,
+                "only char, wchar_t, char16_t and char32_t are supported");
+
+  from_chars_result_t<UC> answer;
+
+  answer.ec = std::errc(); // be optimistic
+  answer.ptr = pns.lastmatch;
+  // The implementation of the Clinger's fast path is convoluted because
+  // we want round-to-nearest in all cases, irrespective of the rounding mode
+  // selected on the thread.
+  // We proceed optimistically, assuming that detail::rounds_to_nearest()
+  // returns true.
+  if (binary_format<T>::min_exponent_fast_path() <= pns.exponent &&
+      pns.exponent <= binary_format<T>::max_exponent_fast_path() &&
+      !pns.too_many_digits) {
+    // Unfortunately, the conventional Clinger's fast path is only possible
+    // when the system rounds to the nearest float.
+    //
+    // We expect the next branch to almost always be selected.
+    // We could check it first (before the previous branch), but
+    // there might be performance advantages at having the check
+    // be last.
+    if (!cpp20_and_in_constexpr() && detail::rounds_to_nearest()) {
+      // We have that fegetround() == FE_TONEAREST.
+      // Next is Clinger's fast path.
+      if (pns.mantissa <= binary_format<T>::max_mantissa_fast_path()) {
+        value = T(pns.mantissa);
+        if (pns.exponent < 0) {
+          value = value / binary_format<T>::exact_power_of_ten(-pns.exponent);
+        } else {
+          value = value * binary_format<T>::exact_power_of_ten(pns.exponent);
+        }
+        if (pns.negative) {
+          value = -value;
+        }
+        return answer;
+      }
+    } else {
+      // We do not have that fegetround() == FE_TONEAREST.
+      // Next is a modified Clinger's fast path, inspired by Jakub Jelínek's
+      // proposal
+      if (pns.exponent >= 0 &&
+          pns.mantissa <=
+              binary_format<T>::max_mantissa_fast_path(pns.exponent)) {
+#if defined(__clang__) || defined(GLZ_FASTFLOAT_32BIT)
+        // Clang may map 0 to -0.0 when fegetround() == FE_DOWNWARD
+        if (pns.mantissa == 0) {
+          value = pns.negative ? T(-0.) : T(0.);
+          return answer;
+        }
+#endif
+        value = T(pns.mantissa) *
+                binary_format<T>::exact_power_of_ten(pns.exponent);
+        if (pns.negative) {
+          value = -value;
+        }
+        return answer;
+      }
+    }
+  }
+  adjusted_mantissa am =
+      compute_float<binary_format<T>>(pns.exponent, pns.mantissa);
+  if (pns.too_many_digits && am.power2 >= 0) {
+    if (am != compute_float<binary_format<T>>(pns.exponent, pns.mantissa + 1)) {
+      am = compute_error<binary_format<T>>(pns.exponent, pns.mantissa);
+    }
+  }
+  // If we called compute_float<binary_format<T>>(pns.exponent, pns.mantissa)
+  // and we have an invalid power (am.power2 < 0), then we need to go the long
+  // way around again. This is very uncommon.
+  if (am.power2 < 0) {
+    am = digit_comp<T>(pns, am);
+  }
+  to_float(pns.negative, am, value);
+  // Test for over/underflow.
+  if ((pns.mantissa != 0 && am.mantissa == 0 && am.power2 == 0) ||
+      am.power2 == binary_format<T>::infinite_power()) {
+    answer.ec = std::errc::result_out_of_range;
+  }
+  return answer;
+}
+
+template <typename T, typename UC>
+GLZ_FASTFLOAT_CONSTEXPR20 from_chars_result_t<UC>
+from_chars_float_advanced(UC const *first, UC const *last, T &value,
+                          parse_options_t<UC> options) noexcept {
+
+  static_assert(is_supported_float_type<T>::value,
+                "only some floating-point types are supported");
+  static_assert(is_supported_char_type<UC>::value,
+                "only char, wchar_t, char16_t and char32_t are supported");
+
+  chars_format const fmt = detail::adjust_for_feature_macros(options.format);
+
+  from_chars_result_t<UC> answer;
+  if (uint64_t(fmt & chars_format::skip_white_space)) {
+    while ((first != last) && fast_float::is_space(*first)) {
+      first++;
+    }
+  }
+  if (first == last) {
+    answer.ec = std::errc::invalid_argument;
+    answer.ptr = first;
+    return answer;
+  }
+  parsed_number_string_t<UC> pns =
+      uint64_t(fmt & detail::basic_json_fmt)
+          ? parse_number_string<true, UC>(first, last, options)
+          : parse_number_string<false, UC>(first, last, options);
+  if (!pns.valid) {
+    if (uint64_t(fmt & chars_format::no_infnan)) {
+      answer.ec = std::errc::invalid_argument;
+      answer.ptr = first;
+      return answer;
+    } else {
+      return detail::parse_infnan(first, last, value, fmt);
+    }
+  }
+
+  // call overload that takes parsed_number_string_t directly.
+  return from_chars_advanced(pns, value);
+}
+
+template <typename T, typename UC, typename>
+GLZ_FASTFLOAT_CONSTEXPR20 from_chars_result_t<UC>
+from_chars(UC const *first, UC const *last, T &value, int base) noexcept {
+
+  static_assert(is_supported_integer_type<T>::value,
+                "only integer types are supported");
+  static_assert(is_supported_char_type<UC>::value,
+                "only char, wchar_t, char16_t and char32_t are supported");
+
+  parse_options_t<UC> options;
+  options.base = base;
+  return from_chars_advanced(first, last, value, options);
+}
+
+template <typename T, typename UC>
+GLZ_FASTFLOAT_CONSTEXPR20 from_chars_result_t<UC>
+from_chars_int_advanced(UC const *first, UC const *last, T &value,
+                        parse_options_t<UC> options) noexcept {
+
+  static_assert(is_supported_integer_type<T>::value,
+                "only integer types are supported");
+  static_assert(is_supported_char_type<UC>::value,
+                "only char, wchar_t, char16_t and char32_t are supported");
+
+  chars_format const fmt = detail::adjust_for_feature_macros(options.format);
+  int const base = options.base;
+
+  from_chars_result_t<UC> answer;
+  if (uint64_t(fmt & chars_format::skip_white_space)) {
+    while ((first != last) && fast_float::is_space(*first)) {
+      first++;
+    }
+  }
+  if (first == last || base < 2 || base > 36) {
+    answer.ec = std::errc::invalid_argument;
+    answer.ptr = first;
+    return answer;
+  }
+
+  return parse_int_string(first, last, value, options);
+}
+
+template <size_t TypeIx> struct from_chars_advanced_caller {
+  static_assert(TypeIx > 0, "unsupported type");
+};
+
+template <> struct from_chars_advanced_caller<1> {
+  template <typename T, typename UC>
+  GLZ_FASTFLOAT_CONSTEXPR20 static from_chars_result_t<UC>
+  call(UC const *first, UC const *last, T &value,
+       parse_options_t<UC> options) noexcept {
+    return from_chars_float_advanced(first, last, value, options);
+  }
+};
+
+template <> struct from_chars_advanced_caller<2> {
+  template <typename T, typename UC>
+  GLZ_FASTFLOAT_CONSTEXPR20 static from_chars_result_t<UC>
+  call(UC const *first, UC const *last, T &value,
+       parse_options_t<UC> options) noexcept {
+    return from_chars_int_advanced(first, last, value, options);
+  }
+};
+
+template <typename T, typename UC>
+GLZ_FASTFLOAT_CONSTEXPR20 from_chars_result_t<UC>
+from_chars_advanced(UC const *first, UC const *last, T &value,
+                    parse_options_t<UC> options) noexcept {
+  return from_chars_advanced_caller<
+      size_t(is_supported_float_type<T>::value) +
+      2 * size_t(is_supported_integer_type<T>::value)>::call(first, last, value,
+                                                             options);
+}
+
+} // namespace glz::fast_float
+
+#endif
+
diff --git a/deps/saucer/include/glaze/util/for_each.hpp b/deps/saucer/include/glaze/util/for_each.hpp
index e2c537e..b0570a8 100644
--- a/deps/saucer/include/glaze/util/for_each.hpp
+++ b/deps/saucer/include/glaze/util/for_each.hpp
@@ -3,35 +3,329 @@
 
 #pragma once
 
+#include <tuple>
 #include <utility>
 
+#include "glaze/util/inline.hpp"
+#include "glaze/util/utility.hpp"
+
+// We do not mark these functions noexcept so that it can be used in exception contexts
+// Furthermore, adding noexcept can increase assembly size because exceptions need to cause termination
+
 namespace glz
 {
+   // There is no benefit to perfectly forward the lambda (in the internal lambda) because it is immediately invoked
+   // It actually removes an assembly instruction on GCC and Clang to pass by reference with O0
+   // With O0 GCC and Clang produce better assembly using the templated I approach rather than
+   // the approach that passes std::integral_constant
+
    // Compile time iterate over I indices
-   // We do not make this noexcept so that it can be used in exception contexts
-   template <std::size_t N, class Func>
-   constexpr void for_each(Func&& f)
+   template <size_t N>
+   inline constexpr void for_each(auto&& lambda)
    {
-      [&]<std::size_t... I>(std::index_sequence<I...>) constexpr {
-         (f(std::integral_constant<std::size_t, I>{}), ...);
-      }(std::make_index_sequence<N>{});
+      if constexpr (N > 0) {
+         // Explicit sizes for small N to help the compiler and make debugging easier
+         // These generate less assembly with O0, but make no difference for higher optimization
+         if constexpr (N == 1) {
+            lambda.template operator()<0>();
+         }
+         else if constexpr (N == 2) {
+            lambda.template operator()<0>();
+            lambda.template operator()<1>();
+         }
+         else if constexpr (N == 3) {
+            lambda.template operator()<0>();
+            lambda.template operator()<1>();
+            lambda.template operator()<2>();
+         }
+         else if constexpr (N == 4) {
+            lambda.template operator()<0>();
+            lambda.template operator()<1>();
+            lambda.template operator()<2>();
+            lambda.template operator()<3>();
+         }
+         else {
+            [&]<size_t... I>(std::index_sequence<I...>) {
+               (void)(lambda.template operator()<I>(), ...);
+            }(std::make_index_sequence<N>{});
+         }
+      }
    }
 
    // Runtime short circuiting if function returns true, return false to continue evaluation
-   template <std::size_t N, class Func>
-   constexpr void for_each_short_circuit(Func&& f)
+   template <size_t N>
+   constexpr void for_each_short_circuit(auto&& lambda)
    {
-      [&]<std::size_t... I>(std::index_sequence<I...>) constexpr {
-         (f(std::integral_constant<std::size_t, I>{}) || ...);
-      }(std::make_index_sequence<N>{});
+      if constexpr (N > 0) {
+         [&]<size_t... I>(std::index_sequence<I...>) {
+            (lambda.template operator()<I>() || ...);
+         }(std::make_index_sequence<N>{});
+      }
    }
 
    template <class Func, class Tuple>
    constexpr void for_each_apply(Func&& f, Tuple&& t)
    {
-      constexpr size_t N = glz::tuple_size_v<std::decay_t<Tuple>>;
-      [&]<std::size_t... I>(std::index_sequence<I...>) constexpr {
-         (f(std::get<I>(t)), ...);
-      }(std::make_index_sequence<N>{});
+      constexpr size_t N = std::tuple_size_v<std::decay_t<Tuple>>;
+      [&]<size_t... I>(std::index_sequence<I...>) { (f(std::get<I>(t)), ...); }(std::make_index_sequence<N>{});
+   }
+
+   template <size_t I, class Lambda>
+   constexpr auto make_jump_function()
+   {
+      return +[](Lambda& l) { l.template operator()<I>(); };
+   }
+
+   // Important: index must be less than N
+   template <size_t N>
+   inline constexpr void visit(auto&& lambda, const size_t index)
+   {
+      if constexpr (N > 0) {
+         // Explicit sizes for small N to help the compiler and make debugging easier
+         if constexpr (N == 1) {
+            (void)index;
+            (void)(lambda.template operator()<0>());
+         }
+         else if constexpr (N == 2) {
+            switch (index) {
+            case 0:
+               lambda.template operator()<0>();
+               break;
+            case 1:
+               lambda.template operator()<1>();
+               break;
+            default:
+               std::unreachable();
+            }
+         }
+         else if constexpr (N == 3) {
+            switch (index) {
+            case 0:
+               lambda.template operator()<0>();
+               break;
+            case 1:
+               lambda.template operator()<1>();
+               break;
+            case 2:
+               lambda.template operator()<2>();
+               break;
+            default:
+               std::unreachable();
+            }
+         }
+         else if constexpr (N == 4) {
+            switch (index) {
+            case 0:
+               lambda.template operator()<0>();
+               break;
+            case 1:
+               lambda.template operator()<1>();
+               break;
+            case 2:
+               lambda.template operator()<2>();
+               break;
+            case 3:
+               lambda.template operator()<3>();
+               break;
+            default:
+               std::unreachable();
+            }
+         }
+         else if constexpr (N == 5) {
+            switch (index) {
+            case 0:
+               lambda.template operator()<0>();
+               break;
+            case 1:
+               lambda.template operator()<1>();
+               break;
+            case 2:
+               lambda.template operator()<2>();
+               break;
+            case 3:
+               lambda.template operator()<3>();
+               break;
+            case 4:
+               lambda.template operator()<4>();
+               break;
+            default:
+               std::unreachable();
+            }
+         }
+         else if constexpr (N == 6) {
+            switch (index) {
+            case 0:
+               lambda.template operator()<0>();
+               break;
+            case 1:
+               lambda.template operator()<1>();
+               break;
+            case 2:
+               lambda.template operator()<2>();
+               break;
+            case 3:
+               lambda.template operator()<3>();
+               break;
+            case 4:
+               lambda.template operator()<4>();
+               break;
+            case 5:
+               lambda.template operator()<5>();
+               break;
+            default:
+               std::unreachable();
+            }
+         }
+         else if constexpr (N == 7) {
+            switch (index) {
+            case 0:
+               lambda.template operator()<0>();
+               break;
+            case 1:
+               lambda.template operator()<1>();
+               break;
+            case 2:
+               lambda.template operator()<2>();
+               break;
+            case 3:
+               lambda.template operator()<3>();
+               break;
+            case 4:
+               lambda.template operator()<4>();
+               break;
+            case 5:
+               lambda.template operator()<5>();
+               break;
+            case 6:
+               lambda.template operator()<6>();
+               break;
+            default:
+               std::unreachable();
+            }
+         }
+         else if constexpr (N == 8) {
+            switch (index) {
+            case 0:
+               lambda.template operator()<0>();
+               break;
+            case 1:
+               lambda.template operator()<1>();
+               break;
+            case 2:
+               lambda.template operator()<2>();
+               break;
+            case 3:
+               lambda.template operator()<3>();
+               break;
+            case 4:
+               lambda.template operator()<4>();
+               break;
+            case 5:
+               lambda.template operator()<5>();
+               break;
+            case 6:
+               lambda.template operator()<6>();
+               break;
+            case 7:
+               lambda.template operator()<7>();
+               break;
+            default:
+               std::unreachable();
+            }
+         }
+         else if constexpr (N == 9) {
+            switch (index) {
+            case 0:
+               lambda.template operator()<0>();
+               break;
+            case 1:
+               lambda.template operator()<1>();
+               break;
+            case 2:
+               lambda.template operator()<2>();
+               break;
+            case 3:
+               lambda.template operator()<3>();
+               break;
+            case 4:
+               lambda.template operator()<4>();
+               break;
+            case 5:
+               lambda.template operator()<5>();
+               break;
+            case 6:
+               lambda.template operator()<6>();
+               break;
+            case 7:
+               lambda.template operator()<7>();
+               break;
+            case 8:
+               lambda.template operator()<8>();
+               break;
+            default:
+               std::unreachable();
+            }
+         }
+         else if constexpr (N == 10) {
+            switch (index) {
+            case 0:
+               lambda.template operator()<0>();
+               break;
+            case 1:
+               lambda.template operator()<1>();
+               break;
+            case 2:
+               lambda.template operator()<2>();
+               break;
+            case 3:
+               lambda.template operator()<3>();
+               break;
+            case 4:
+               lambda.template operator()<4>();
+               break;
+            case 5:
+               lambda.template operator()<5>();
+               break;
+            case 6:
+               lambda.template operator()<6>();
+               break;
+            case 7:
+               lambda.template operator()<7>();
+               break;
+            case 8:
+               lambda.template operator()<8>();
+               break;
+            case 9:
+               lambda.template operator()<9>();
+               break;
+            default:
+               std::unreachable();
+            }
+         }
+         else {
+#ifdef _MSC_VER
+            using Lambda = std::decay_t<decltype(lambda)>;
+            static const auto jump_table = []<size_t... I>(std::index_sequence<I...>) {
+               return std::array{make_jump_function<I, Lambda>()...};
+            }(std::make_index_sequence<N>{});
+#else
+            static constexpr auto jump_table = []<size_t... I>(std::index_sequence<I...>) {
+               return std::array{+[](std::decay_t<decltype(lambda)>& l) { l.template operator()<I>(); }...};
+            }(std::make_index_sequence<N>{});
+#endif
+
+#if defined(__clang_major__) && (__clang_major__ >= 19)
+            [[assume(index < N)]];
+#endif
+            jump_table[index](lambda);
+
+            // This code runs significantly slower on Clang
+            // Simple tests with assembly show that this should be faster,
+            // but full Glaze assembly need to be looked into
+            /*[&, index]<size_t... I>(std::index_sequence<I...>) {
+               (void)((index == I ? lambda.template operator()<I>() : void()), ...);
+            }(std::make_index_sequence<N>{});*/
+         }
+      }
    }
 }
diff --git a/deps/saucer/include/glaze/util/glaze_fast_float.hpp b/deps/saucer/include/glaze/util/glaze_fast_float.hpp
new file mode 100644
index 0000000..9f81956
--- /dev/null
+++ b/deps/saucer/include/glaze/util/glaze_fast_float.hpp
@@ -0,0 +1,251 @@
+// Glaze Library
+// For the license information refer to glaze.hpp
+
+#pragma once
+
+// This is an adapter to speed up the parsing portion of the fast_float conversion
+
+#include "glaze/util/fast_float.hpp"
+#include "glaze/util/inline.hpp"
+
+namespace glz
+{
+   // Assuming that you use no more than 19 digits, this will
+   // parse an ASCII string.
+   template <bool null_terminated, class UC>
+   GLZ_ALWAYS_INLINE constexpr glz::fast_float::parsed_number_string_t<UC> parse_number_string(UC const* p,
+                                                                                               UC const* pend) noexcept
+   {
+      using namespace glz::fast_float;
+      static constexpr UC decimal_point = '.';
+
+      parsed_number_string_t<UC> answer;
+      answer.valid = false;
+      answer.too_many_digits = false;
+      answer.negative = (*p == UC('-'));
+      if (*p == UC('-')) { // C++17 20.19.3.(7.1) explicitly forbids '+' sign here
+         ++p;
+
+         if constexpr (not null_terminated) {
+            if (p == pend) [[unlikely]] {
+               return answer;
+            }
+         }
+
+         if (!glz::fast_float::is_integer(*p)) [[unlikely]] { // a sign must be followed by an integer
+            return answer;
+         }
+      }
+      UC const* const start_digits = p;
+
+      uint64_t i = 0; // an unsigned int avoids signed overflows (which are bad)
+
+      if constexpr (null_terminated) {
+         while (glz::fast_float::is_integer(*p)) {
+            // a multiplication by 10 is cheaper than an arbitrary integer
+            // multiplication
+            i = 10 * i + uint64_t(*p - UC('0')); // might overflow, we will handle the overflow later
+            ++p;
+         }
+      }
+      else {
+         while ((p != pend) && glz::fast_float::is_integer(*p)) {
+            // a multiplication by 10 is cheaper than an arbitrary integer
+            // multiplication
+            i = 10 * i + uint64_t(*p - UC('0')); // might overflow, we will handle the overflow later
+            ++p;
+         }
+      }
+
+      UC const* const end_of_integer_part = p;
+      int64_t digit_count = int64_t(end_of_integer_part - start_digits);
+      answer.integer = glz::fast_float::span<const UC>(start_digits, size_t(digit_count));
+
+      // at least 1 digit in integer part, without leading zeros
+      if (digit_count == 0 || (start_digits[0] == UC('0') && digit_count > 1)) {
+         return answer;
+      }
+
+      int64_t exponent = 0;
+      const bool has_decimal_point = [&] {
+         if constexpr (null_terminated) {
+            return (*p == decimal_point);
+         }
+         else {
+            return (p != pend) && (*p == decimal_point);
+         }
+      }();
+      if (has_decimal_point) {
+         ++p;
+         UC const* before = p;
+         // can occur at most twice without overflowing, but let it occur more, since
+         // for integers with many digits, digit parsing is the primary bottleneck.
+         loop_parse_if_eight_digits(p, pend, i);
+
+         if constexpr (null_terminated) {
+            while (glz::fast_float::is_integer(*p)) {
+               uint8_t digit = uint8_t(*p - UC('0'));
+               ++p;
+               i = i * 10 + digit; // in rare cases, this will overflow, but that's ok
+            }
+         }
+         else {
+            while ((p != pend) && glz::fast_float::is_integer(*p)) {
+               uint8_t digit = uint8_t(*p - UC('0'));
+               ++p;
+               i = i * 10 + digit; // in rare cases, this will overflow, but that's ok
+            }
+         }
+         exponent = before - p;
+         answer.fraction = glz::fast_float::span<const UC>(before, size_t(p - before));
+         digit_count -= exponent;
+      }
+      // at least 1 digit in fractional part
+      if (has_decimal_point && exponent == 0) {
+         return answer;
+      }
+
+      int64_t exp_number = 0; // explicit exponential part
+
+      if constexpr (null_terminated) {
+         if ((UC('e') == *p) || (UC('E') == *p)) {
+            UC const* location_of_e = p;
+            ++p;
+            bool neg_exp = false;
+            if (UC('-') == *p) {
+               neg_exp = true;
+               ++p;
+            }
+            else if (UC('+') == *p) { // '+' on exponent is allowed by C++17 20.19.3.(7.1)
+               ++p;
+            }
+            if (!glz::fast_float::is_integer(*p)) {
+               // Otherwise, we will be ignoring the 'e'.
+               p = location_of_e;
+            }
+            else {
+               while (glz::fast_float::is_integer(*p)) {
+                  uint8_t digit = uint8_t(*p - UC('0'));
+                  if (exp_number < 0x10000000) {
+                     exp_number = 10 * exp_number + digit;
+                  }
+                  ++p;
+               }
+               if (neg_exp) {
+                  exp_number = -exp_number;
+               }
+               exponent += exp_number;
+            }
+         }
+      }
+      else {
+         if ((p != pend) && ((UC('e') == *p) || (UC('E') == *p))) {
+            UC const* location_of_e = p;
+            ++p;
+            bool neg_exp = false;
+            if ((p != pend) && (UC('-') == *p)) {
+               neg_exp = true;
+               ++p;
+            }
+            else if ((p != pend) && (UC('+') == *p)) { // '+' on exponent is allowed by C++17 20.19.3.(7.1)
+               ++p;
+            }
+            if ((p == pend) || !glz::fast_float::is_integer(*p)) {
+               // Otherwise, we will be ignoring the 'e'.
+               p = location_of_e;
+            }
+            else {
+               while ((p != pend) && glz::fast_float::is_integer(*p)) {
+                  uint8_t digit = uint8_t(*p - UC('0'));
+                  if (exp_number < 0x10000000) {
+                     exp_number = 10 * exp_number + digit;
+                  }
+                  ++p;
+               }
+               if (neg_exp) {
+                  exp_number = -exp_number;
+               }
+               exponent += exp_number;
+            }
+         }
+      }
+
+      answer.lastmatch = p;
+      answer.valid = true;
+
+      // If we frequently had to deal with long strings of digits,
+      // we could extend our code by using a 128-bit integer instead
+      // of a 64-bit integer. However, this is uncommon.
+      //
+      // We can deal with up to 19 digits.
+      if (digit_count > 19) { // this is uncommon
+         // It is possible that the integer had an overflow.
+         // We have to handle the case where we have 0.0000somenumber.
+         // We need to be mindful of the case where we only have zeroes...
+         // E.g., 0.000000000...000.
+         UC const* start = start_digits;
+         if constexpr (null_terminated) {
+            while ((*start == UC('0') || *start == decimal_point)) {
+               if (*start == UC('0')) {
+                  --digit_count;
+               }
+               ++start;
+            }
+         }
+         else {
+            while ((start != pend) && (*start == UC('0') || *start == decimal_point)) {
+               if (*start == UC('0')) {
+                  --digit_count;
+               }
+               ++start;
+            }
+         }
+
+         if (digit_count > 19) {
+            answer.too_many_digits = true;
+            // Let us start again, this time, avoiding overflows.
+            // We don't need to check if is_integer, since we use the
+            // pre-tokenized spans from above.
+            i = 0;
+            p = answer.integer.ptr;
+            UC const* int_end = p + answer.integer.len();
+            const uint64_t minimal_nineteen_digit_integer{1000000000000000000};
+            while ((i < minimal_nineteen_digit_integer) && (p != int_end)) {
+               i = i * 10 + uint64_t(*p - UC('0'));
+               ++p;
+            }
+            if (i >= minimal_nineteen_digit_integer) { // We have a big integers
+               exponent = end_of_integer_part - p + exp_number;
+            }
+            else { // We have a value with a fractional component.
+               p = answer.fraction.ptr;
+               UC const* frac_end = p + answer.fraction.len();
+               while ((i < minimal_nineteen_digit_integer) && (p != frac_end)) {
+                  i = i * 10 + uint64_t(*p - UC('0'));
+                  ++p;
+               }
+               exponent = answer.fraction.ptr - p + exp_number;
+            }
+            // We have now corrected both exponent and i, to a truncated value
+         }
+      }
+      answer.exponent = exponent;
+      answer.mantissa = i;
+      return answer;
+   }
+
+   template <bool null_terminated, class T, class UC>
+   constexpr glz::fast_float::from_chars_result_t<UC> from_chars(UC const* first, UC const* last, T& value) noexcept
+   {
+      using namespace glz::fast_float;
+      static_assert(is_supported_float_type<T>(), "only some floating-point types are supported");
+      static_assert(is_supported_char_type<UC>(), "only char, wchar_t, char16_t and char32_t are supported");
+
+      parsed_number_string_t<UC> pns = glz::parse_number_string<null_terminated, UC>(first, last);
+      if (!pns.valid) [[unlikely]] {
+         return {.ptr = first, .ec = std::errc::invalid_argument};
+      }
+
+      return from_chars_advanced(pns, value);
+   }
+}
diff --git a/deps/saucer/include/glaze/util/hash_map.hpp b/deps/saucer/include/glaze/util/hash_map.hpp
index 0710d2f..8235af9 100644
--- a/deps/saucer/include/glaze/util/hash_map.hpp
+++ b/deps/saucer/include/glaze/util/hash_map.hpp
@@ -52,7 +52,7 @@ namespace glz
    template <class T1, class T2>
    pair(T1, T2) -> pair<T1, T2>;
 
-   template <size_t I, detail::pair_t T>
+   template <size_t I, pair_t T>
    constexpr decltype(auto) get(T&& p) noexcept
    {
       if constexpr (I == 0) {
@@ -67,21 +67,20 @@ namespace glz
    }
 }
 
-namespace glz::detail
+namespace glz
 {
-   constexpr size_t naive_map_max_size = 32;
+   inline constexpr size_t naive_map_max_size = 128;
 
    struct naive_map_desc
    {
       size_t N{};
       uint64_t seed{};
       size_t bucket_size{};
-      bool use_hash_comparison = false;
       size_t min_length = (std::numeric_limits<size_t>::max)();
       size_t max_length{};
    };
 
-   constexpr uint64_t to_uint64_n_below_8(const char* bytes, const size_t N) noexcept
+   inline constexpr uint64_t to_uint64_n_below_8(const char* bytes, const size_t N) noexcept
    {
       static_assert(std::endian::native == std::endian::little);
       uint64_t res{};
@@ -177,22 +176,12 @@ namespace glz::detail
    // we keep generating seeds until its perfect. This allows for the usage of fast
    // but terible hashing algs.
    // This is one such terible hashing alg
-   template <bool use_hash_comparison>
    struct naive_hash final
    {
       static inline constexpr uint64_t bitmix(uint64_t h) noexcept
       {
-         if constexpr (use_hash_comparison) {
-            h ^= (h >> 33);
-            h *= 0xff51afd7ed558ccdL;
-            h ^= (h >> 33);
-            h *= 0xc4ceb9fe1a85ec53L;
-            h ^= (h >> 33);
-         }
-         else {
-            h *= 0x9FB21C651E98DF25L;
-            h ^= std::rotr(h, 49);
-         }
+         h *= 0x9FB21C651E98DF25L;
+         h ^= std::rotr(h, 49);
          return h;
       };
 
@@ -271,10 +260,11 @@ namespace glz::detail
       }
    };
 
-   constexpr bool contains(auto&& data, auto&& val) noexcept
+   // Check if a size_t value exists inside of a container like std::array<size_t, N>
+   // Using a pointer and size rather than std::span for faster compile times
+   constexpr bool contains(const size_t* data, const size_t size, const size_t val) noexcept
    {
-      const auto n = data.size();
-      for (size_t i = 0; i < n; ++i) {
+      for (size_t i = 0; i < size; ++i) {
          if (data[i] == val) {
             return true;
          }
@@ -282,7 +272,7 @@ namespace glz::detail
       return false;
    }
 
-   template <bool use_hash_comparison, size_t N>
+   template <size_t N>
       requires(N <= naive_map_max_size)
    constexpr naive_map_desc naive_map_hash(const std::array<std::string_view, N>& v) noexcept
    {
@@ -293,7 +283,6 @@ namespace glz::detail
       // This uses 512 bytes for 32 keys.
       // Keeping the bucket size a power of 2 probably makes the modulus more efficient.
       desc.bucket_size = (N == 1) ? 1 : std::bit_ceil(N * N) / 2;
-      desc.use_hash_comparison = use_hash_comparison;
       auto& seed = desc.seed;
 
       for (size_t i = 0; i < N; ++i) {
@@ -314,12 +303,12 @@ namespace glz::detail
             seed = gen();
             size_t index = 0;
             for (const auto& key : v) {
-               const auto hash = naive_hash<use_hash_comparison>{}(key, seed);
+               const auto hash = naive_hash{}(key, seed);
                if (hash == seed) {
                   break;
                }
                const auto bucket = hash % desc.bucket_size;
-               if (contains(std::span{bucket_index.data(), index}, bucket)) {
+               if (contains(bucket_index.data(), index, bucket)) {
                   break;
                }
                bucket_index[index] = bucket;
@@ -329,7 +318,7 @@ namespace glz::detail
             if (index == N) {
                // make sure the seed does not collide with any hashes
                const auto bucket = seed % desc.bucket_size;
-               if (not contains(std::span{bucket_index.data(), N}, bucket)) {
+               if (not contains(bucket_index.data(), N, bucket)) {
                   return; // found working seed
                }
             }
@@ -355,9 +344,8 @@ namespace glz::detail
       // Birthday paradox makes this unsuitable for large numbers of keys without
       // using a ton of memory.
       static constexpr auto N = D.N;
-      using hash_alg = naive_hash<D.use_hash_comparison>;
+      using hash_alg = naive_hash;
       std::array<pair<std::string_view, Value>, N> items{};
-      std::array<uint64_t, N * D.use_hash_comparison> hashes{};
       std::array<uint8_t, D.bucket_size> table{};
 
       constexpr decltype(auto) begin() const noexcept { return items.begin(); }
@@ -371,17 +359,9 @@ namespace glz::detail
          // constexpr bucket_size means the compiler can replace the modulos with
          // more efficient instructions So this is not as expensive as this looks
          const auto index = table[hash % D.bucket_size];
-         if constexpr (D.use_hash_comparison) {
-            // Odds of having a uint64_t hash collision extremely small for naive map sizes
-            // And no valid/known keys could colide becuase of perfect hashing
-            if (hashes[index] != hash) [[unlikely]]
-               return items.end();
-         }
-         else {
-            const auto& item = items[index];
-            if (!compare_sv(item.first, key)) [[unlikely]]
-               return items.end();
-         }
+         const auto& item = items[index];
+         if (!compare_sv(item.first, key)) [[unlikely]]
+            return items.end();
          return items.begin() + index;
       }
    };
@@ -392,13 +372,10 @@ namespace glz::detail
    {
       naive_map<T, D> ht{pairs};
 
-      using hash_alg = naive_hash<D.use_hash_comparison>;
+      using hash_alg = naive_hash;
 
       for (size_t i = 0; i < D.N; ++i) {
          const auto hash = hash_alg{}.template operator()<D>(pairs[i].first);
-         if constexpr (D.use_hash_comparison) {
-            ht.hashes[i] = hash;
-         }
          ht.table[hash % D.bucket_size] = uint8_t(i);
       }
 
@@ -425,13 +402,13 @@ namespace glz::detail
       }
    }
 
-   template <class Key, class Value, size_t N, bool use_hash_comparison = false>
+   template <class Key, class Value, size_t N>
    struct normal_map
    {
       // From serge-sans-paille/frozen
       static constexpr uint64_t storage_size = std::bit_ceil(N) * (N < 32 ? 2 : 1);
       static constexpr auto max_bucket_size = 2 * std::bit_width(N);
-      using hash_alg = naive_hash<use_hash_comparison>;
+      using hash_alg = naive_hash;
       uint64_t seed{};
       // The extra info in the bucket most likely does not need to be 64 bits
       std::array<int64_t, N> buckets{};
@@ -457,26 +434,20 @@ namespace glz::detail
          // more efficient instructions So this is not as expensive as this looks
          const auto extra = buckets[hash % N];
          const size_t index = extra < 1 ? -extra : table[combine(hash, extra) % storage_size];
-         if constexpr (!std::integral<Key> && use_hash_comparison) {
-            // Odds of having a uint64_t hash collision is pretty small
-            // And no valid/known keys could colide becuase of perfect hashing
-            if (hashes[index] != hash) [[unlikely]]
+
+         if (index >= N) [[unlikely]] {
+            return items.end();
+         }
+         const auto& item = items[index];
+         if constexpr (std::integral<Key>) {
+            if (item.first != key) [[unlikely]]
                return items.end();
          }
          else {
-            if (index >= N) [[unlikely]] {
+            if (!compare_sv(item.first, key)) [[unlikely]]
                return items.end();
-            }
-            const auto& item = items[index];
-            if constexpr (std::integral<Key>) {
-               if (item.first != key) [[unlikely]]
-                  return items.end();
-            }
-            else {
-               if (!compare_sv(item.first, key)) [[unlikely]]
-                  return items.end();
-            }
          }
+
          return items.begin() + index;
       }
 
@@ -485,24 +456,20 @@ namespace glz::detail
          const auto hash = hash_alg{}(key, seed);
          const auto extra = buckets[hash % N];
          const size_t index = extra < 1 ? -extra : table[combine(hash, extra) % storage_size];
-         if constexpr (!std::integral<Key> && use_hash_comparison) {
-            if (hashes[index] != hash) [[unlikely]]
+
+         if (index >= N) [[unlikely]] {
+            return items.end();
+         }
+         const auto& item = items[index];
+         if constexpr (std::integral<Key>) {
+            if (item.first != key) [[unlikely]]
                return items.end();
          }
          else {
-            if (index >= N) [[unlikely]] {
+            if (!compare_sv(item.first, key)) [[unlikely]]
                return items.end();
-            }
-            const auto& item = items[index];
-            if constexpr (std::integral<Key>) {
-               if (item.first != key) [[unlikely]]
-                  return items.end();
-            }
-            else {
-               if (!compare_sv(item.first, key)) [[unlikely]]
-                  return items.end();
-            }
          }
+
          return items.begin() + index;
       }
 
@@ -516,67 +483,68 @@ namespace glz::detail
          if constexpr (N == 0) {
             return;
          }
+         else {
+            std::array<std::array<storage_type, max_bucket_size>, N> full_buckets{};
+            std::array<size_t, N> bucket_sizes{};
+            naive_prng gen{};
 
-         std::array<std::array<storage_type, max_bucket_size>, N> full_buckets{};
-         std::array<size_t, N> bucket_sizes{};
-         detail::naive_prng gen{};
-
-         bool failed;
-         do {
-            failed = false;
-            seed = gen() + 1;
-            for (storage_type i{}; i < N; ++i) {
-               const auto hash = hash_alg{}(items[i].first, seed);
-               if (hash == seed) {
-                  failed = true;
-                  break;
-               }
-               hashes[i] = hash;
-               const auto bucket = hash % N;
-               const auto bucket_size = bucket_sizes[bucket]++;
-               if (bucket_size == max_bucket_size) {
-                  failed = true;
-                  bucket_sizes = {};
-                  break;
-               }
-               else {
-                  full_buckets[bucket][bucket_size] = i;
-               }
-            }
-         } while (failed);
-
-         std::array<size_t, N> buckets_index{};
-         std::iota(buckets_index.begin(), buckets_index.end(), 0);
-         std::sort(buckets_index.begin(), buckets_index.end(),
-                   [&bucket_sizes](size_t i1, size_t i2) { return bucket_sizes[i1] > bucket_sizes[i2]; });
-
-         constexpr auto unknown_key_indice = N;
-         std::fill(table.begin(), table.end(), storage_type(unknown_key_indice));
-         for (auto bucket_index : buckets_index) {
-            const auto bucket_size = bucket_sizes[bucket_index];
-            if (bucket_size < 1) break;
-            if (bucket_size == 1) {
-               buckets[bucket_index] = -int64_t(full_buckets[bucket_index][0]);
-               continue;
-            }
-            const auto table_old = table;
+            bool failed;
             do {
                failed = false;
-               // We need to reserve top bit for bucket_size == 1
-               const auto secondary_seed = gen() >> 1;
-               for (size_t i = 0; i < bucket_size; ++i) {
-                  const auto index = full_buckets[bucket_index][i];
-                  const auto hash = hashes[index];
-                  const auto slot = combine(hash, secondary_seed) % storage_size;
-                  if (table[slot] != unknown_key_indice) {
+               seed = gen() + 1;
+               for (storage_type i{}; i < N; ++i) {
+                  const auto hash = hash_alg{}(items[i].first, seed);
+                  if (hash == seed) {
                      failed = true;
-                     table = table_old;
                      break;
                   }
-                  table[slot] = index;
+                  hashes[i] = hash;
+                  const auto bucket = hash % N;
+                  const auto bucket_size = bucket_sizes[bucket]++;
+                  if (bucket_size == max_bucket_size) {
+                     failed = true;
+                     bucket_sizes = {};
+                     break;
+                  }
+                  else {
+                     full_buckets[bucket][bucket_size] = i;
+                  }
                }
-               buckets[bucket_index] = secondary_seed;
             } while (failed);
+
+            std::array<size_t, N> buckets_index{};
+            std::iota(buckets_index.begin(), buckets_index.end(), 0);
+            std::sort(buckets_index.begin(), buckets_index.end(),
+                      [&bucket_sizes](size_t i1, size_t i2) { return bucket_sizes[i1] > bucket_sizes[i2]; });
+
+            constexpr auto unknown_key_indice = N;
+            std::fill(table.begin(), table.end(), storage_type(unknown_key_indice));
+            for (auto bucket_index : buckets_index) {
+               const auto bucket_size = bucket_sizes[bucket_index];
+               if (bucket_size < 1) break;
+               if (bucket_size == 1) {
+                  buckets[bucket_index] = -int64_t(full_buckets[bucket_index][0]);
+                  continue;
+               }
+               const auto table_old = table;
+               do {
+                  failed = false;
+                  // We need to reserve top bit for bucket_size == 1
+                  const auto secondary_seed = gen() >> 1;
+                  for (size_t i = 0; i < bucket_size; ++i) {
+                     const auto index = full_buckets[bucket_index][i];
+                     const auto hash = hashes[index];
+                     const auto slot = combine(hash, secondary_seed) % storage_size;
+                     if (table[slot] != unknown_key_indice) {
+                        failed = true;
+                        table = table_old;
+                        break;
+                     }
+                     table[slot] = index;
+                  }
+                  buckets[bucket_index] = secondary_seed;
+               } while (failed);
+            }
          }
       }
    };
diff --git a/deps/saucer/include/glaze/util/inline.hpp b/deps/saucer/include/glaze/util/inline.hpp
index d7ba13e..f74117f 100644
--- a/deps/saucer/include/glaze/util/inline.hpp
+++ b/deps/saucer/include/glaze/util/inline.hpp
@@ -3,7 +3,7 @@
 
 #pragma once
 
-#if defined(__clang__) || defined(__GNUC__)
+#if defined(__clang__) || defined(__GNUC__) || defined(_MSC_VER)
 #ifndef GLZ_USE_ALWAYS_INLINE
 #define GLZ_USE_ALWAYS_INLINE
 #endif
@@ -11,33 +11,37 @@
 
 #if defined(GLZ_USE_ALWAYS_INLINE) && defined(NDEBUG)
 #ifndef GLZ_ALWAYS_INLINE
+#if defined(_MSC_VER) && !defined(__clang__)
+#define GLZ_ALWAYS_INLINE [[msvc::forceinline]] inline
+#else
 #define GLZ_ALWAYS_INLINE inline __attribute__((always_inline))
 #endif
 #endif
+#endif
 
 #ifndef GLZ_ALWAYS_INLINE
 #define GLZ_ALWAYS_INLINE inline
 #endif
 
-// IMPORTNAT: GLZ_FLATTEN should only be used with extreme care
+// IMPORTANT: GLZ_FLATTEN should only be used with extreme care
 // It often adds to the binary size and greatly increases compilation times.
 // It should only be applied in very specific circumstances.
 // It is best to more often rely on the compiler.
 
-#if defined(__clang__) && defined(NDEBUG)
+#if (defined(__clang__) || defined(__GNUC__)) && defined(NDEBUG)
 #ifndef GLZ_FLATTEN
 #define GLZ_FLATTEN inline __attribute__((flatten))
 #endif
-
-#ifndef GLZ_FLATTEN_NO_INLINE
-#define GLZ_FLATTEN_NO_INLINE __attribute__((noinline)) __attribute__((flatten))
-#endif
 #endif
 
 #ifndef GLZ_FLATTEN
 #define GLZ_FLATTEN inline
 #endif
 
-#ifndef GLZ_FLATTEN_NO_INLINE
-#define GLZ_FLATTEN_NO_INLINE
+#ifndef GLZ_NO_INLINE
+#if defined(__clang__) || defined(__GNUC__)
+#define GLZ_NO_INLINE __attribute__((noinline))
+#elif defined(_MSC_VER)
+#define GLZ_NO_INLINE __declspec((noinline))
+#endif
 #endif
diff --git a/deps/saucer/include/glaze/util/itoa.hpp b/deps/saucer/include/glaze/util/itoa.hpp
index 2eec4e4..7c915bc 100644
--- a/deps/saucer/include/glaze/util/itoa.hpp
+++ b/deps/saucer/include/glaze/util/itoa.hpp
@@ -37,7 +37,7 @@
 
 namespace glz
 {
-   constexpr char char_table[200] = {
+   inline constexpr char char_table[200] = {
       '0', '0', '0', '1', '0', '2', '0', '3', '0', '4', '0', '5', '0', '6', '0', '7', '0', '8', '0', '9', '1', '0', '1',
       '1', '1', '2', '1', '3', '1', '4', '1', '5', '1', '6', '1', '7', '1', '8', '1', '9', '2', '0', '2', '1', '2', '2',
       '2', '3', '2', '4', '2', '5', '2', '6', '2', '7', '2', '8', '2', '9', '3', '0', '3', '1', '3', '2', '3', '3', '3',
@@ -49,8 +49,8 @@ namespace glz
       '9', '2', '9', '3', '9', '4', '9', '5', '9', '6', '9', '7', '9', '8', '9', '9'};
 
    template <class T>
-      requires std::same_as<T, std::remove_cvref_t<uint32_t>>
-   inline auto* to_chars(auto* buf, T val) noexcept
+      requires std::same_as<std::remove_cvref_t<T>, uint32_t>
+   auto* to_chars(auto* buf, T val) noexcept
    {
       /* The maximum value of uint32_t is 4294967295 (10 digits), */
       /* these digits are named as 'aabbccddee' here.             */
@@ -131,8 +131,8 @@ namespace glz
    }
 
    template <class T>
-      requires std::same_as<T, std::remove_cvref_t<int32_t>>
-   inline auto* to_chars(auto* buf, T x) noexcept
+      requires std::same_as<std::remove_cvref_t<T>, int32_t>
+   auto* to_chars(auto* buf, T x) noexcept
    {
       *buf = '-';
       // shifts are necessary to have the numeric_limits<int32_t>::min case
@@ -222,7 +222,7 @@ namespace glz
 
    template <class T>
       requires(std::same_as<std::remove_cvref_t<T>, uint32_t>)
-   inline auto* to_chars_u64_len_5_8(auto* buf, T val) noexcept
+   auto* to_chars_u64_len_5_8(auto* buf, T val) noexcept
    {
       if (val < 1000000) { /* 5-6 digits: aabbcc */
          const uint32_t aa = uint32_t((uint64_t(val) * 429497) >> 32); /* (val / 10000) */
@@ -256,7 +256,7 @@ namespace glz
 
    template <class T>
       requires(std::same_as<std::remove_cvref_t<T>, uint64_t>)
-   inline auto* to_chars(auto* buf, T val) noexcept
+   auto* to_chars(auto* buf, T val) noexcept
    {
       if (val < 100000000) { /* 1-8 digits */
          buf = to_chars_u64_len_1_8(buf, uint32_t(val));
@@ -282,8 +282,8 @@ namespace glz
    }
 
    template <class T>
-      requires std::same_as<T, std::remove_cvref_t<int64_t>>
-   inline auto* to_chars(auto* buf, T x) noexcept
+      requires std::same_as<std::remove_cvref_t<T>, int64_t>
+   auto* to_chars(auto* buf, T x) noexcept
    {
       *buf = '-';
       // shifts are necessary to have the numeric_limits<int64_t>::min case
diff --git a/deps/saucer/include/glaze/util/memory_pool.hpp b/deps/saucer/include/glaze/util/memory_pool.hpp
new file mode 100644
index 0000000..732abdd
--- /dev/null
+++ b/deps/saucer/include/glaze/util/memory_pool.hpp
@@ -0,0 +1,76 @@
+#pragma once
+
+#include <cstdint>
+#include <deque>
+#include <memory>
+#include <mutex>
+#include <vector>
+
+namespace glz
+{
+   template <class T>
+      requires(std::is_default_constructible_v<T>)
+   struct memory_pool final
+   {
+      memory_pool() = default;
+
+      // Disable copy and move semantics
+      memory_pool(const memory_pool&) = delete;
+      memory_pool& operator=(const memory_pool&) = delete;
+      memory_pool(memory_pool&&) = delete;
+      memory_pool& operator=(memory_pool&&) = delete;
+
+      // Ensures that release is called exactly once per acquired object
+      struct handle final
+      {
+         memory_pool<T>* pool;
+         size_t index;
+
+         handle(memory_pool<T>* p, size_t i) : pool(p), index(i) {}
+         ~handle() { pool->release(index); }
+      };
+
+      std::shared_ptr<T> borrow()
+      {
+         std::lock_guard lock{mtx};
+         if (available.empty()) {
+            const auto current_size = values.size();
+            const auto new_size = values.size() * 2;
+            values.resize(new_size);
+            for (size_t i = current_size; i < new_size; ++i) {
+               available.emplace_back(i);
+            }
+         }
+
+         const auto index = available.back();
+         available.pop_back();
+
+         // Use an aliasing constructor with a handle that will return the value
+         // to the pool
+         return std::shared_ptr<T>{std::make_shared<handle>(this, index), &values[index]};
+      }
+
+      size_t size() const
+      {
+         std::lock_guard lock{mtx};
+         return values.size();
+      }
+
+      size_t available_size() const
+      {
+         std::lock_guard lock{mtx};
+         return available.size();
+      }
+
+     private:
+      void release(size_t index)
+      {
+         std::lock_guard lock{mtx};
+         available.emplace_back(index);
+      }
+
+      mutable std::mutex mtx{};
+      std::deque<T> values{2};
+      std::vector<size_t> available{0, 1}; // indices of available values
+   };
+}
diff --git a/deps/saucer/include/glaze/util/parse.hpp b/deps/saucer/include/glaze/util/parse.hpp
index afbb264..2a4e3d9 100644
--- a/deps/saucer/include/glaze/util/parse.hpp
+++ b/deps/saucer/include/glaze/util/parse.hpp
@@ -3,7 +3,9 @@
 
 #pragma once
 
+#include <algorithm>
 #include <bit>
+#include <charconv>
 #include <cstring>
 #include <iterator>
 #include <span>
@@ -11,15 +13,16 @@
 #include "glaze/core/context.hpp"
 #include "glaze/core/meta.hpp"
 #include "glaze/core/opts.hpp"
+#include "glaze/util/atoi.hpp"
 #include "glaze/util/compare.hpp"
+#include "glaze/util/convert.hpp"
 #include "glaze/util/expected.hpp"
 #include "glaze/util/inline.hpp"
-#include "glaze/util/stoui64.hpp"
 #include "glaze/util/string_literal.hpp"
 
-namespace glz::detail
+namespace glz
 {
-   constexpr std::array<bool, 256> numeric_table = [] {
+   inline constexpr std::array<bool, 256> numeric_table = [] {
       std::array<bool, 256> t{};
       t['0'] = true;
       t['1'] = true;
@@ -39,7 +42,7 @@ namespace glz::detail
       return t;
    }();
 
-   constexpr std::array<char, 256> char_unescape_table = [] {
+   inline constexpr std::array<char, 256> char_unescape_table = [] {
       std::array<char, 256> t{};
       t['"'] = '"';
       t['/'] = '/';
@@ -52,7 +55,7 @@ namespace glz::detail
       return t;
    }();
 
-   constexpr std::array<bool, 256> valid_escape_table = [] {
+   inline constexpr std::array<bool, 256> valid_escape_table = [] {
       std::array<bool, 256> t{};
       t['"'] = true;
       t['/'] = true;
@@ -66,7 +69,7 @@ namespace glz::detail
       return t;
    }();
 
-   constexpr std::array<bool, 256> whitespace_table = [] {
+   inline constexpr std::array<bool, 256> whitespace_table = [] {
       std::array<bool, 256> t{};
       t['\n'] = true;
       t['\t'] = true;
@@ -75,7 +78,7 @@ namespace glz::detail
       return t;
    }();
 
-   constexpr std::array<bool, 256> whitespace_comment_table = [] {
+   inline constexpr std::array<bool, 256> whitespace_comment_table = [] {
       std::array<bool, 256> t{};
       t['\n'] = true;
       t['\t'] = true;
@@ -85,7 +88,7 @@ namespace glz::detail
       return t;
    }();
 
-   constexpr std::array<uint8_t, 256> digit_hex_table = [] {
+   inline constexpr std::array<uint8_t, 256> digit_hex_table = [] {
       std::array<uint8_t, 256> t;
       std::fill(t.begin(), t.end(), uint8_t(255));
       t['0'] = 0;
@@ -113,43 +116,42 @@ namespace glz::detail
       return t;
    }();
 
-   consteval uint32_t repeat_byte4(const auto repeat) { return 0x01010101u * uint8_t(repeat); }
+   consteval uint32_t repeat_byte4(const auto repeat) { return uint32_t(0x01010101u) * uint8_t(repeat); }
 
-   GLZ_ALWAYS_INLINE constexpr uint32_t has_zero_u32(const uint32_t chunk) noexcept
-   {
-      return (((chunk - 0x01010101u) & ~chunk) & 0x80808080u);
-   }
+   consteval uint64_t repeat_byte8(const uint8_t repeat) { return 0x0101010101010101ull * repeat; }
 
-   GLZ_ALWAYS_INLINE constexpr uint32_t is_less_16_u32(const uint32_t chunk) noexcept
+#if defined(__SIZEOF_INT128__)
+   consteval __uint128_t repeat_byte16(const uint8_t repeat)
    {
-      return has_zero_u32(chunk & repeat_byte4(0b11110000u));
+      __uint128_t multiplier = (__uint128_t(0x0101010101010101ull) << 64) | 0x0101010101010101ull;
+      return multiplier * repeat;
    }
-
-   consteval uint64_t repeat_byte8(const uint8_t repeat) { return 0x0101010101010101ull * repeat; }
+#endif
 
    consteval uint64_t not_repeat_byte8(const uint8_t repeat) { return ~(0x0101010101010101ull * repeat); }
 
    [[nodiscard]] GLZ_ALWAYS_INLINE uint32_t hex_to_u32(const char* c) noexcept
    {
-      const auto& t = digit_hex_table;
-      const uint8_t arr[4]{t[c[3]], t[c[2]], t[c[1]], t[c[0]]};
-      uint32_t chunk;
-      std::memcpy(&chunk, arr, 4);
+      constexpr auto& t = digit_hex_table;
+      const uint8_t arr[4]{t[uint8_t(c[3])], t[uint8_t(c[2])], t[uint8_t(c[1])], t[uint8_t(c[0])]};
+      const auto chunk = std::bit_cast<uint32_t>(arr);
       // check that all hex characters are valid
-      if (is_less_16_u32(chunk)) [[likely]] {
-         // now pack into first four bytes of uint32_t
-         uint32_t packed{};
-         packed |= (chunk & 0x0000000F);
-         packed |= (chunk & 0x00000F00) >> 4;
-         packed |= (chunk & 0x000F0000) >> 8;
-         packed |= (chunk & 0x0F000000) >> 12;
-         return packed;
-      }
-      return 0xFFFFFFFFu;
+      if (chunk & repeat_byte4(0b11110000u)) [[unlikely]] {
+         return 0xFFFFFFFFu;
+      }
+
+      // TODO: can you use std::bit_cast here?
+      // now pack into first four bytes of uint32_t
+      uint32_t packed{};
+      packed |= (chunk & 0x0000000F);
+      packed |= (chunk & 0x00000F00) >> 4;
+      packed |= (chunk & 0x000F0000) >> 8;
+      packed |= (chunk & 0x0F000000) >> 12;
+      return packed;
    }
 
    template <class Char>
-   [[nodiscard]] GLZ_ALWAYS_INLINE uint32_t code_point_to_utf8(const uint32_t code_point, Char* c)
+   [[nodiscard]] GLZ_ALWAYS_INLINE uint32_t code_point_to_utf8(const uint32_t code_point, Char* c) noexcept
    {
       if (code_point <= 0x7F) {
          c[0] = Char(code_point);
@@ -176,7 +178,7 @@ namespace glz::detail
       return 0;
    }
 
-   [[nodiscard]] GLZ_ALWAYS_INLINE uint32_t skip_code_point(const uint32_t code_point)
+   [[nodiscard]] GLZ_ALWAYS_INLINE uint32_t skip_code_point(const uint32_t code_point) noexcept
    {
       if (code_point <= 0x7F) {
          return 1;
@@ -208,60 +210,18 @@ namespace glz::detail
    }
 
    template <class Char>
-   [[nodiscard]] GLZ_ALWAYS_INLINE bool handle_unicode_code_point(const Char*& it, Char*& dst)
+   [[nodiscard]] GLZ_ALWAYS_INLINE uint32_t handle_unicode_code_point(const Char*& it, Char*& dst,
+                                                                      const Char* end) noexcept
    {
       using namespace unicode;
 
-      const uint32_t high = hex_to_u32(it);
-      if (high == 0xFFFFFFFFu) [[unlikely]] {
+      if (it + 4 >= end) [[unlikely]] {
          return false;
       }
-      it += 4; // skip the code point characters
-
-      uint32_t code_point;
-
-      if ((high & generic_surrogate_mask) == generic_surrogate_value) {
-         // surrogate pair code points
-         if ((high & surrogate_mask) != high_surrogate_value) {
-            return false;
-         }
-
-         it += 2;
-         // verify that second unicode escape sequence is present
-         const uint32_t low = hex_to_u32(it);
-         if (low == 0xFFFFFFFFu) [[unlikely]] {
-            return false;
-         }
-         it += 4;
-
-         if ((low & surrogate_mask) != low_surrogate_value) {
-            return false;
-         }
-
-         code_point = (high & surrogate_codepoint_mask) << surrogate_codepoint_bits;
-         code_point |= (low & surrogate_codepoint_mask);
-         code_point += surrogate_codepoint_offset;
-      }
-      else {
-         code_point = high;
-      }
-      const uint32_t offset = code_point_to_utf8(code_point, dst);
-      dst += offset;
-      return offset > 0;
-   }
-
-   template <class Char>
-   [[nodiscard]] GLZ_ALWAYS_INLINE bool handle_unicode_code_point(const Char*& it, Char*& dst, const Char* end)
-   {
-      using namespace unicode;
-
       const uint32_t high = hex_to_u32(it);
       if (high == 0xFFFFFFFFu) [[unlikely]] {
          return false;
       }
-      if (it + 4 >= end) [[unlikely]] {
-         return false;
-      }
       it += 4; // skip the code point characters
 
       uint32_t code_point;
@@ -275,6 +235,12 @@ namespace glz::detail
          if (it + 6 >= end) [[unlikely]] {
             return false;
          }
+         // The next two characters must be `\u`
+         uint16_t u;
+         std::memcpy(&u, it, 2);
+         if (u != to_uint16_t(R"(\u)")) [[unlikely]] {
+            return false;
+         }
          it += 2;
          // verify that second unicode escape sequence is present
          const uint32_t low = hex_to_u32(it);
@@ -283,7 +249,7 @@ namespace glz::detail
          }
          it += 4;
 
-         if ((low & surrogate_mask) != low_surrogate_value) {
+         if ((low & surrogate_mask) != low_surrogate_value) [[unlikely]] {
             return false;
          }
 
@@ -296,11 +262,11 @@ namespace glz::detail
       }
       const uint32_t offset = code_point_to_utf8(code_point, dst);
       dst += offset;
-      return offset > 0;
+      return offset;
    }
 
    template <class Char>
-   [[nodiscard]] GLZ_ALWAYS_INLINE bool skip_unicode_code_point(const Char*& it, const Char* end)
+   [[nodiscard]] GLZ_ALWAYS_INLINE bool skip_unicode_code_point(const Char*& it, const Char* end) noexcept
    {
       using namespace unicode;
       if (it + 4 >= end) [[unlikely]] {
@@ -317,13 +283,19 @@ namespace glz::detail
 
       if ((high & generic_surrogate_mask) == generic_surrogate_value) {
          // surrogate pair code points
-         if ((high & surrogate_mask) != high_surrogate_value) {
+         if ((high & surrogate_mask) != high_surrogate_value) [[unlikely]] {
             return false;
          }
 
          if (it + 6 >= end) [[unlikely]] {
             return false;
          }
+         // The next two characters must be `\u`
+         uint16_t u;
+         std::memcpy(&u, it, 2);
+         if (u != to_uint16_t(R"(\u)")) [[unlikely]] {
+            return false;
+         }
          it += 2;
          // verify that second unicode escape sequence is present
          const uint32_t low = hex_to_u32(it);
@@ -332,7 +304,7 @@ namespace glz::detail
          }
          it += 4;
 
-         if ((low & surrogate_mask) != low_surrogate_value) {
+         if ((low & surrogate_mask) != low_surrogate_value) [[unlikely]] {
             return false;
          }
 
@@ -346,98 +318,79 @@ namespace glz::detail
       return skip_code_point(code_point) > 0;
    }
 
-   // assumes null terminated
-#define GLZ_MATCH_QUOTE                       \
-   if (*it != '"') [[unlikely]] {             \
-      ctx.error = error_code::expected_quote; \
-      return;                                 \
-   }                                          \
-   else [[likely]] {                          \
-      ++it;                                   \
-   }
-
-#define GLZ_MATCH_COMMA                       \
-   if (*it != ',') [[unlikely]] {             \
-      ctx.error = error_code::expected_comma; \
-      return;                                 \
-   }                                          \
-   else [[likely]] {                          \
-      ++it;                                   \
-   }
-
-#define GLZ_MATCH_COLON                       \
-   if (*it != ':') [[unlikely]] {             \
-      ctx.error = error_code::expected_colon; \
-      return;                                 \
-   }                                          \
-   else [[likely]] {                          \
-      ++it;                                   \
-   }
-
-#define GLZ_MATCH_OPEN_BRACKET                  \
-   if (*it != '[') [[unlikely]] {               \
-      ctx.error = error_code::expected_bracket; \
-      return;                                   \
-   }                                            \
-   else [[likely]] {                            \
-      ++it;                                     \
-   }
-
-#define GLZ_MATCH_CLOSE_BRACKET                 \
-   if (*it != ']') [[unlikely]] {               \
-      ctx.error = error_code::expected_bracket; \
-      return;                                   \
-   }                                            \
-   else [[likely]] {                            \
-      ++it;                                     \
-   }
-
-#define GLZ_MATCH_OPEN_BRACE                  \
-   if (*it != '{') [[unlikely]] {             \
-      ctx.error = error_code::expected_brace; \
-      return;                                 \
-   }                                          \
-   else [[likely]] {                          \
-      ++it;                                   \
-   }
-
-#define GLZ_MATCH_CLOSE_BRACE                 \
-   if (*it != '}') [[unlikely]] {             \
-      ctx.error = error_code::expected_brace; \
-      return;                                 \
-   }                                          \
-   else [[likely]] {                          \
-      ++it;                                   \
-   }
-
-   template <char c>
-   GLZ_ALWAYS_INLINE void match(is_context auto&& ctx, auto&& it) noexcept
+   // Checks for a character and validates that we are not at the end (considered an error)
+   template <char C, auto Opts>
+   GLZ_ALWAYS_INLINE bool match_invalid_end(is_context auto& ctx, auto&& it, auto&& end) noexcept
    {
-      if (*it != c) [[unlikely]] {
-         ctx.error = error_code::syntax_error;
+      if (*it != C) [[unlikely]] {
+         if constexpr (C == '"') {
+            ctx.error = error_code::expected_quote;
+         }
+         else if constexpr (C == ',') {
+            ctx.error = error_code::expected_comma;
+         }
+         else if constexpr (C == ':') {
+            ctx.error = error_code::expected_colon;
+         }
+         else if constexpr (C == '[' || C == ']') {
+            ctx.error = error_code::expected_bracket;
+         }
+         else if constexpr (C == '{' || C == '}') {
+            ctx.error = error_code::expected_brace;
+         }
+         else {
+            ctx.error = error_code::syntax_error;
+         }
+         return true;
       }
       else [[likely]] {
          ++it;
       }
+      if constexpr (not Opts.null_terminated) {
+         if (it == end) [[unlikely]] {
+            ctx.error = error_code::unexpected_end;
+            return true;
+         }
+      }
+      return false;
    }
 
-   // assumes null terminated
-   template <char c>
-   GLZ_ALWAYS_INLINE void match(is_context auto&& ctx, auto&& it, auto&&) noexcept
+   template <char C>
+   GLZ_ALWAYS_INLINE bool match(is_context auto& ctx, auto&& it) noexcept
    {
-      if (*it != c) [[unlikely]] {
-         ctx.error = error_code::syntax_error;
+      if (*it != C) [[unlikely]] {
+         if constexpr (C == '"') {
+            ctx.error = error_code::expected_quote;
+         }
+         else if constexpr (C == ',') {
+            ctx.error = error_code::expected_comma;
+         }
+         else if constexpr (C == ':') {
+            ctx.error = error_code::expected_colon;
+         }
+         else if constexpr (C == '[' || C == ']') {
+            ctx.error = error_code::expected_bracket;
+         }
+         else if constexpr (C == '{' || C == '}') {
+            ctx.error = error_code::expected_brace;
+         }
+         else {
+            ctx.error = error_code::syntax_error;
+         }
+         return true;
       }
       else [[likely]] {
          ++it;
+         return false;
       }
    }
 
-   template <string_literal str, opts Opts>
-      requires(Opts.is_padded && str.size() <= padding_bytes)
+   template <string_literal str, auto Opts>
+      requires(check_is_padded(Opts) && str.size() <= padding_bytes)
    GLZ_ALWAYS_INLINE void match(is_context auto&& ctx, auto&& it, auto&&) noexcept
    {
-      if (!compare<str.size()>(it, str.value)) [[unlikely]] {
+      static constexpr auto S = str.sv();
+      if (not comparitor<S>(it)) [[unlikely]] {
          ctx.error = error_code::syntax_error;
       }
       else [[likely]] {
@@ -445,12 +398,13 @@ namespace glz::detail
       }
    }
 
-   template <string_literal str, opts Opts>
-      requires(!Opts.is_padded)
+   template <string_literal str, auto Opts>
+      requires(!check_is_padded(Opts))
    GLZ_ALWAYS_INLINE void match(is_context auto&& ctx, auto&& it, auto&& end) noexcept
    {
       const auto n = size_t(end - it);
-      if ((n < str.size()) || !compare<str.size()>(it, str.value)) [[unlikely]] {
+      static constexpr auto S = str.sv();
+      if ((n < str.size()) || not comparitor<S>(it)) [[unlikely]] {
          ctx.error = error_code::syntax_error;
       }
       else [[likely]] {
@@ -465,8 +419,7 @@ namespace glz::detail
          ctx.error = error_code::unexpected_end;
       }
       else if (*it == '/') {
-         while (++it != end && *it != '\n')
-            ;
+         while (++it != end && *it != '\n');
       }
       else if (*it == '*') {
          while (++it != end) {
@@ -520,53 +473,68 @@ namespace glz::detail
    {
       return (chunk & repeat_byte8(0b11110000u));
    }
+}
 
-#define GLZ_SKIP_WS                                \
-   if constexpr (!Opts.minified) {                 \
-      if constexpr (Opts.comments) {               \
-         while (whitespace_comment_table[*it]) {   \
-            if (*it == '/') [[unlikely]] {         \
-               skip_comment(ctx, it, end);         \
-               if (bool(ctx.error)) [[unlikely]] { \
-                  return;                          \
-               }                                   \
-            }                                      \
-            else [[likely]] {                      \
-               ++it;                               \
-            }                                      \
-         }                                         \
-      }                                            \
-      else {                                       \
-         while (whitespace_table[*it]) {           \
-            ++it;                                  \
-         }                                         \
-      }                                            \
-   }
-
+namespace glz
+{
    // skip whitespace
-   template <opts Opts>
-   GLZ_ALWAYS_INLINE void skip_ws(is_context auto&& ctx, auto&& it, auto&& end) noexcept
+   template <auto Opts>
+   GLZ_ALWAYS_INLINE bool skip_ws(is_context auto&& ctx, auto&& it, auto&& end) noexcept
    {
+      using namespace glz::detail;
+
       if constexpr (!Opts.minified) {
-         if constexpr (Opts.comments) {
-            while (whitespace_comment_table[*it]) {
-               if (*it == '/') [[unlikely]] {
-                  skip_comment(ctx, it, end);
-                  if (bool(ctx.error)) [[unlikely]] {
-                     return;
+         if constexpr (Opts.null_terminated) {
+            if constexpr (Opts.comments) {
+               while (whitespace_comment_table[uint8_t(*it)]) {
+                  if (*it == '/') [[unlikely]] {
+                     skip_comment(ctx, it, end);
+                     if (bool(ctx.error)) [[unlikely]] {
+                        return true;
+                     }
+                  }
+                  else [[likely]] {
+                     ++it;
                   }
                }
-               else [[likely]] {
+            }
+            else {
+               while (whitespace_table[uint8_t(*it)]) {
                   ++it;
                }
             }
          }
          else {
-            while (whitespace_table[*it]) {
-               ++it;
+            if constexpr (Opts.comments) {
+               while (it < end && whitespace_comment_table[uint8_t(*it)]) {
+                  if (*it == '/') [[unlikely]] {
+                     skip_comment(ctx, it, end);
+                     if (bool(ctx.error)) [[unlikely]] {
+                        return true;
+                     }
+                  }
+                  else [[likely]] {
+                     ++it;
+                  }
+               }
+               if (it == end) [[unlikely]] {
+                  ctx.error = error_code::end_reached;
+                  return true;
+               }
+            }
+            else {
+               while (it < end && whitespace_table[uint8_t(*it)]) {
+                  ++it;
+               }
+               if (it == end) [[unlikely]] {
+                  ctx.error = error_code::end_reached;
+                  return true;
+               }
             }
          }
       }
+
+      return false;
    }
 
    GLZ_ALWAYS_INLINE void skip_matching_ws(const auto* ws, auto&& it, uint64_t length) noexcept
@@ -630,6 +598,19 @@ namespace glz::detail
 
    // std::countr_zero uses another branch check whether the input is zero,
    // we use this function when we know that x > 0
+   GLZ_ALWAYS_INLINE auto countr_zero(const uint32_t x) noexcept
+   {
+#ifdef _MSC_VER
+      return std::countr_zero(x);
+#else
+#if __has_builtin(__builtin_ctzll)
+      return __builtin_ctzl(x);
+#else
+      return std::countr_zero(x);
+#endif
+#endif
+   }
+
    GLZ_ALWAYS_INLINE auto countr_zero(const uint64_t x) noexcept
    {
 #ifdef _MSC_VER
@@ -643,6 +624,20 @@ namespace glz::detail
 #endif
    }
 
+#if defined(__SIZEOF_INT128__)
+   GLZ_ALWAYS_INLINE auto countr_zero(__uint128_t x) noexcept
+   {
+      uint64_t low = uint64_t(x);
+      if (low != 0) {
+         return countr_zero(low);
+      }
+      else {
+         uint64_t high = uint64_t(x >> 64);
+         return countr_zero(high) + 64;
+      }
+   }
+#endif
+
    GLZ_ALWAYS_INLINE void skip_till_quote(is_context auto&& ctx, auto&& it, auto&& end) noexcept
    {
       const auto* pc = std::memchr(it, '"', size_t(end - it));
@@ -654,19 +649,13 @@ namespace glz::detail
       ctx.error = error_code::expected_quote;
    }
 
-   template <opts Opts>
-      requires(Opts.is_padded)
+   template <auto Opts>
    GLZ_ALWAYS_INLINE void skip_string_view(is_context auto&& ctx, auto&& it, auto&& end) noexcept
    {
-      static_assert(std::contiguous_iterator<std::decay_t<decltype(it)>>);
-
       while (it < end) [[likely]] {
-         uint64_t chunk;
-         std::memcpy(&chunk, it, 8);
-         const uint64_t test_chars = has_quote(chunk);
-         if (test_chars) {
-            it += (countr_zero(test_chars) >> 3);
-
+         const auto* pc = std::memchr(it, '"', size_t(end - it));
+         if (pc) [[likely]] {
+            it = reinterpret_cast<std::decay_t<decltype(it)>>(pc);
             auto* prev = it - 1;
             while (*prev == '\\') {
                --prev;
@@ -676,228 +665,113 @@ namespace glz::detail
             }
             ++it; // skip the escaped quote
          }
-         else {
-            it += 8;
+         else [[unlikely]] {
+            break;
          }
       }
 
       ctx.error = error_code::expected_quote;
    }
 
-   template <opts Opts>
-      requires(!Opts.is_padded)
-   GLZ_ALWAYS_INLINE void skip_string_view(is_context auto&& ctx, auto&& it, auto&& end) noexcept
+   template <auto Opts>
+      requires(check_is_padded(Opts))
+   GLZ_ALWAYS_INLINE void skip_string(is_context auto&& ctx, auto&& it, auto&& end) noexcept
    {
-      static_assert(std::contiguous_iterator<std::decay_t<decltype(it)>>);
-
-      for (const auto fin = end - 7; it < fin;) {
-         uint64_t chunk;
-         std::memcpy(&chunk, it, 8);
-         const uint64_t test_chars = has_quote(chunk);
-         if (test_chars) {
-            it += (countr_zero(test_chars) >> 3);
-
-            auto* prev = it - 1;
-            while (*prev == '\\') {
-               --prev;
-            }
-            if (size_t(it - prev) % 2) {
-               return;
-            }
-            ++it; // skip the escaped quote
-         }
-         else {
-            it += 8;
-         }
+      if constexpr (!check_opening_handled(Opts)) {
+         ++it;
       }
 
-      // Tail end of buffer. Should be rare we even get here
-      while (it < end) {
-         switch (*it) {
-         case '\\': {
-            ++it;
-            if (it == end) [[unlikely]] {
-               ctx.error = error_code::expected_quote;
-               return;
-            }
-            ++it;
-            break;
-         }
-         case '"': {
-            auto* prev = it - 1;
-            while (*prev == '\\') {
-               --prev;
-            }
-            if (size_t(it - prev) % 2) {
-               return;
+      if constexpr (check_validate_skipped(Opts)) {
+         while (true) {
+            uint64_t swar{};
+            std::memcpy(&swar, it, 8);
+
+            constexpr uint64_t lo7_mask = repeat_byte8(0b01111111);
+            const uint64_t lo7 = swar & lo7_mask;
+            const uint64_t backslash = (lo7 ^ repeat_byte8('\\')) + lo7_mask;
+            const uint64_t quote = (lo7 ^ repeat_byte8('"')) + lo7_mask;
+            const uint64_t less_32 = (swar & repeat_byte8(0b01100000)) + lo7_mask;
+            uint64_t next = ~((backslash & quote & less_32) | swar);
+            next &= repeat_byte8(0b10000000);
+
+            if (next == 0) {
+               // No special characters in this chunk
+               it += 8;
+               continue;
             }
-            ++it; // skip the escaped quote
-            break;
-         }
-         default: {
-            ++it;
-         }
-         }
-      }
-
-      ctx.error = error_code::expected_quote;
-   }
-
-   struct key_stats_t
-   {
-      uint32_t min_length = (std::numeric_limits<uint32_t>::max)();
-      uint32_t max_length{};
-      uint32_t length_range{};
-   };
-
-   // consumes the iterator and returns the key
-   // for error_on_unknown_keys = false, this may not return a valid key, in which case the iterator will not point to a
-   // quote (")
-   template <opts Opts, key_stats_t stats>
-      requires(stats.length_range < 24)
-   [[nodiscard]] GLZ_ALWAYS_INLINE const sv parse_key_cx(auto&& it) noexcept
-   {
-      static_assert(std::contiguous_iterator<std::decay_t<decltype(it)>>);
 
-      static constexpr auto LengthRange = stats.length_range;
+            // Find the first occurrence
+            size_t offset = (countr_zero(next) >> 3);
+            it += offset;
 
-      auto start = it;
-
-      if constexpr (Opts.error_on_unknown_keys) {
-         it += stats.min_length; // immediately skip minimum length
-      }
-      else {
-         // unknown keys must be searched for within the min_length
-
-         // I don't want to support unknown keys having escaped quotes.
-         // This would make everyone pay significant performance losses for an edge case that can be handled with known
-         // keys.
-
-         if constexpr (stats.min_length <= 8) {
-            uint64_t chunk{};
-            std::memcpy(&chunk, it, stats.min_length);
-            const uint64_t test_chunk = has_quote(chunk);
-            if (test_chunk) [[likely]] {
-               it += (countr_zero(test_chunk) >> 3);
-               return {start, size_t(it - start)};
+            const auto c = *it;
+            if ((c & 0b11100000) == 0) [[unlikely]] {
+               // Invalid control character (<0x20)
+               ctx.error = error_code::syntax_error;
+               return;
             }
-            it += stats.min_length;
-         }
-         else {
-            auto e = it + stats.min_length;
-            uint64_t chunk;
-            for (const auto end_m7 = e - 7; it < end_m7; it += 8) {
-               std::memcpy(&chunk, it, 8);
-               const uint64_t test_chars = has_quote(chunk);
-               if (test_chars) {
-                  it += (countr_zero(test_chars) >> 3);
-                  return {start, size_t(it - start)};
+            else if (c == '"') {
+               // Check if this quote is escaped
+               const auto* p = it - 1;
+               int backslash_count{};
+               // We don't have to worry about rewinding too far because we started with a quote
+               while (*p == '\\') {
+                  ++backslash_count;
+                  --p;
                }
-            }
-
-            while (it < e) {
-               if (*it == '"') {
-                  return {start, size_t(it - start)};
+               if ((backslash_count & 1) == 0) {
+                  // Even number of backslashes => not escaped => closing quote found
+                  ++it;
+                  return;
+               }
+               else {
+                  // Odd number of backslashes => escaped quote
+                  ++it;
+                  continue;
                }
-               ++it;
             }
-         }
-      }
+            else if (c == '\\') {
+               // Handle escape sequence
+               ++it;
 
-      if constexpr (LengthRange == 0) {
-         return {start, stats.min_length};
-      }
-      else if constexpr (LengthRange == 1) {
-         if (*it != '"') {
-            ++it;
-         }
-         return {start, size_t(it - start)};
-      }
-      else if constexpr (LengthRange < 4) {
-         for (const auto e = it + stats.length_range + 1; it < e; ++it) {
-            if (*it == '"') {
-               break;
+               if (*it == 'u') {
+                  ++it;
+                  if (not skip_unicode_code_point(it, end)) [[unlikely]] {
+                     ctx.error = error_code::unicode_escape_conversion_failure;
+                     return;
+                  }
+               }
+               else {
+                  if (not char_unescape_table[uint8_t(*it)]) [[unlikely]] {
+                     ctx.error = error_code::invalid_escape;
+                     return;
+                  }
+                  ++it;
+               }
             }
          }
-         return {start, size_t(it - start)};
-      }
-      else if constexpr (LengthRange == 7) {
-         uint64_t chunk; // no need to default initialize
-         std::memcpy(&chunk, it, 8);
-         const uint64_t test_chunk = has_quote(chunk);
-         if (test_chunk) [[likely]] {
-            it += (countr_zero(test_chunk) >> 3);
-         }
-         return {start, size_t(it - start)};
-      }
-      else if constexpr (LengthRange > 15) {
-         uint64_t chunk; // no need to default initialize
-         std::memcpy(&chunk, it, 8);
-         uint64_t test_chunk = has_quote(chunk);
-         if (test_chunk) {
-            goto finish;
-         }
 
-         it += 8;
-         std::memcpy(&chunk, it, 8);
-         test_chunk = has_quote(chunk);
-         if (test_chunk) {
-            goto finish;
-         }
-
-         it += 8;
-         static constexpr auto rest = LengthRange + 1 - 16;
-         chunk = 0; // must zero out the chunk
-         std::memcpy(&chunk, it, rest);
-         test_chunk = has_quote(chunk);
-         // If our chunk is zero, we have an invalid key (for error_on_unknown_keys = true)
-         // We set the chunk to 1 so that we increment it by 0
-         if (!test_chunk) {
-            test_chunk = 1;
-         }
-
-      finish:
-         it += (std::countr_zero(test_chunk) >> 3);
-         return {start, size_t(it - start)};
-      }
-      else if constexpr (LengthRange > 7) {
-         uint64_t chunk; // no need to default initialize
-         std::memcpy(&chunk, it, 8);
-         uint64_t test_chunk = has_quote(chunk);
-         if (test_chunk) {
-            it += (countr_zero(test_chunk) >> 3);
-         }
-         else {
-            it += 8;
-            static constexpr auto rest = LengthRange + 1 - 8;
-            chunk = 0; // must zero out the chunk
-            std::memcpy(&chunk, it, rest);
-            test_chunk = has_quote(chunk);
-            if (test_chunk) {
-               it += (countr_zero(test_chunk) >> 3);
-            }
-         }
-         return {start, size_t(it - start)};
+         // If we exit here, we never found a closing quote
+         ctx.error = error_code::unexpected_end;
       }
       else {
-         uint64_t chunk{};
-         std::memcpy(&chunk, it, LengthRange + 1);
-         const uint64_t test_chunk = has_quote(chunk);
-         if (test_chunk) [[likely]] {
-            it += (countr_zero(test_chunk) >> 3);
+         skip_string_view<Opts>(ctx, it, end);
+         if (bool(ctx.error)) [[unlikely]] {
+            return;
          }
-         return {start, size_t(it - start)};
+         ++it; // skip the quote
       }
    }
 
-   template <opts Opts>
+   template <auto Opts>
+      requires(not check_is_padded(Opts))
    GLZ_ALWAYS_INLINE void skip_string(is_context auto&& ctx, auto&& it, auto&& end) noexcept
    {
-      if constexpr (!Opts.opening_handled) {
+      if constexpr (!check_opening_handled(Opts)) {
          ++it;
       }
 
-      if constexpr (Opts.force_conformance) {
+      if constexpr (check_validate_skipped(Opts)) {
          while (true) {
             if ((*it & 0b11100000) == 0) [[unlikely]] {
                ctx.error = error_code::syntax_error;
@@ -911,7 +785,7 @@ namespace glz::detail
             }
             case '\\': {
                ++it;
-               if (char_unescape_table[*it]) {
+               if (char_unescape_table[uint8_t(*it)]) {
                   ++it;
                   continue;
                }
@@ -941,8 +815,56 @@ namespace glz::detail
       }
    }
 
-   template <opts Opts, char open, char close, size_t Depth = 1>
-      requires(Opts.is_padded)
+   template <auto Opts, char open, char close, size_t Depth = 1>
+      requires(check_is_padded(Opts) && not bool(Opts.comments))
+   GLZ_ALWAYS_INLINE void skip_until_closed(is_context auto&& ctx, auto&& it, auto&& end) noexcept
+   {
+      size_t depth = Depth;
+
+      while (it < end) [[likely]] {
+         uint64_t chunk;
+         std::memcpy(&chunk, it, 8);
+         const uint64_t test = has_quote(chunk) | has_char<open>(chunk) | has_char<close>(chunk);
+         if (test) {
+            it += (countr_zero(test) >> 3);
+
+            switch (*it) {
+            case '"': {
+               skip_string<opts{}>(ctx, it, end);
+               if (bool(ctx.error)) [[unlikely]] {
+                  return;
+               }
+               break;
+            }
+            case open: {
+               ++it;
+               ++depth;
+               break;
+            }
+            case close: {
+               ++it;
+               --depth;
+               if (depth == 0) {
+                  return;
+               }
+               break;
+            }
+            default: {
+               ctx.error = error_code::unexpected_end;
+               return;
+            }
+            }
+         }
+         else {
+            it += 8;
+         }
+      }
+
+      ctx.error = error_code::unexpected_end;
+   }
+
+   template <auto Opts, char open, char close, size_t Depth = 1>
+      requires(check_is_padded(Opts) && bool(Opts.comments))
    GLZ_ALWAYS_INLINE void skip_until_closed(is_context auto&& ctx, auto&& it, auto&& end) noexcept
    {
       size_t depth = Depth;
@@ -996,8 +918,92 @@ namespace glz::detail
       ctx.error = error_code::unexpected_end;
    }
 
-   template <opts Opts, char open, char close, size_t Depth = 1>
-      requires(!Opts.is_padded)
+   template <auto Opts, char open, char close, size_t Depth = 1>
+      requires(!check_is_padded(Opts) && not bool(Opts.comments))
+   GLZ_ALWAYS_INLINE void skip_until_closed(is_context auto&& ctx, auto&& it, auto&& end) noexcept
+   {
+      size_t depth = Depth;
+
+      for (const auto fin = end - 7; it < fin;) {
+         uint64_t chunk;
+         std::memcpy(&chunk, it, 8);
+         const uint64_t test = has_quote(chunk) | has_char<open>(chunk) | has_char<close>(chunk);
+         if (test) {
+            it += (countr_zero(test) >> 3);
+
+            switch (*it) {
+            case '"': {
+               skip_string<opts{}>(ctx, it, end);
+               if (bool(ctx.error)) [[unlikely]] {
+                  return;
+               }
+               break;
+            }
+            case open: {
+               ++it;
+               ++depth;
+               break;
+            }
+            case close: {
+               ++it;
+               --depth;
+               if (depth == 0) {
+                  return;
+               }
+               break;
+            }
+            default: {
+               ctx.error = error_code::unexpected_end;
+               return;
+            }
+            }
+         }
+         else {
+            it += 8;
+         }
+      }
+
+      // Tail end of buffer. Should be rare we even get here
+      while (it < end) {
+         switch (*it) {
+         case '"': {
+            skip_string<opts{}>(ctx, it, end);
+            if (bool(ctx.error)) [[unlikely]] {
+               return;
+            }
+            break;
+         }
+         case '/': {
+            skip_comment(ctx, it, end);
+            if (bool(ctx.error)) [[unlikely]] {
+               return;
+            }
+            break;
+         }
+         case open: {
+            ++it;
+            ++depth;
+            break;
+         }
+         case close: {
+            ++it;
+            --depth;
+            if (depth == 0) {
+               return;
+            }
+            break;
+         }
+         default: {
+            ++it;
+         }
+         }
+      }
+
+      ctx.error = error_code::unexpected_end;
+   }
+
+   template <auto Opts, char open, char close, size_t Depth = 1>
+      requires(!check_is_padded(Opts) && bool(Opts.comments))
    GLZ_ALWAYS_INLINE void skip_until_closed(is_context auto&& ctx, auto&& it, auto&& end) noexcept
    {
       size_t depth = Depth;
@@ -1145,11 +1151,11 @@ namespace glz::detail
       }
    }
 
-   template <opts Opts>
+   template <auto Opts>
    GLZ_ALWAYS_INLINE void skip_number(is_context auto&& ctx, auto&& it, auto&& end) noexcept
    {
-      if constexpr (!Opts.force_conformance) {
-         while (numeric_table[*it]) {
+      if constexpr (!check_validate_skipped(Opts)) {
+         while (numeric_table[uint8_t(*it)]) {
             ++it;
          }
       }
@@ -1158,9 +1164,6 @@ namespace glz::detail
       }
    }
 
-   template <opts Opts>
-   GLZ_ALWAYS_INLINE void skip_value(is_context auto&& ctx, auto&& it, auto&& end) noexcept;
-
    // expects opening whitespace to be handled
    GLZ_ALWAYS_INLINE sv parse_key(is_context auto&& ctx, auto&& it, auto&& end) noexcept
    {
@@ -1168,9 +1171,9 @@ namespace glz::detail
       if (bool(ctx.error)) [[unlikely]]
          return {};
 
-      match<'"'>(ctx, it);
-      if (bool(ctx.error)) [[unlikely]]
+      if (match<'"'>(ctx, it)) {
          return {};
+      }
       auto start = it;
       skip_till_quote(ctx, it, end);
       if (bool(ctx.error)) [[unlikely]]
@@ -1184,3 +1187,129 @@ namespace glz::detail
       return val + (multiple - (val % multiple)) % multiple;
    }
 }
+
+namespace glz
+{
+   // TODO: GCC 12 lacks constexpr std::from_chars
+   // Remove this code when dropping GCC 12 support
+   namespace detail
+   {
+      struct from_chars_result
+      {
+         const char* ptr;
+         std::errc ec;
+      };
+
+      inline constexpr int char_to_digit(char c) noexcept
+      {
+         if (c >= '0' && c <= '9') return c - '0';
+         if (c >= 'a' && c <= 'z') return c - 'a' + 10;
+         if (c >= 'A' && c <= 'Z') return c - 'A' + 10;
+         return -1;
+      }
+
+      template <class I>
+      constexpr from_chars_result from_chars(const char* first, const char* last, I& value, int base = 10)
+      {
+         from_chars_result result{first, std::errc{}};
+
+         // Basic validation of base
+         if (base < 2 || base > 36) {
+            // Not standard behavior to check base validity here, but let's return invalid_argument
+            result.ec = std::errc::invalid_argument;
+            return result;
+         }
+
+         using U = std::make_unsigned_t<I>;
+         constexpr bool is_signed = std::is_signed<I>::value;
+         constexpr U umax = (std::numeric_limits<U>::max)();
+
+         if (first == last) {
+            // Empty range
+            result.ec = std::errc::invalid_argument;
+            return result;
+         }
+
+         bool negative = false;
+         // Check for sign only if signed type
+         if constexpr (is_signed) {
+            if (*first == '-') {
+               negative = true;
+               ++first;
+            }
+            else if (*first == '+') {
+               ++first;
+            }
+         }
+
+         if (first == last) {
+            // After sign there's nothing
+            result.ec = std::errc::invalid_argument;
+            return result;
+         }
+
+         U acc = 0;
+         bool any = false;
+
+         // We'll do overflow checking as we parse
+         // For accumulation: acc * base + digit
+         // Overflow if acc > (umax - digit)/base
+
+         while (first != last) {
+            int d = char_to_digit(*first);
+            if (d < 0 || d >= base) break;
+
+            // Check overflow before multiplying/adding
+            if (acc > (umax - static_cast<U>(d)) / static_cast<U>(base)) {
+               // Overflow
+               result.ec = std::errc::result_out_of_range;
+               // We still move ptr to the last valid digit parsed
+               result.ptr = first;
+               // No need to parse further; we know it's out of range.
+               return result;
+            }
+
+            acc = acc * base + static_cast<U>(d);
+            any = true;
+            ++first;
+         }
+
+         if (!any) {
+            // No digits parsed
+            result.ec = std::errc::invalid_argument;
+            return result;
+         }
+
+         // If signed and negative, check if result fits
+         if constexpr (is_signed) {
+            using S = std::make_signed_t<U>;
+            // The largest magnitude we can represent in a negative value is (max + 1)
+            // since -(min()) = max() + 1.
+            U limit = static_cast<U>((std::numeric_limits<I>::max)()) + 1U;
+            if (negative) {
+               if (acc > limit) {
+                  result.ec = std::errc::result_out_of_range;
+                  result.ptr = first;
+                  return result;
+               }
+               value = static_cast<I>(0 - static_cast<S>(acc));
+            }
+            else {
+               if (acc > static_cast<U>((std::numeric_limits<I>::max)())) {
+                  result.ec = std::errc::result_out_of_range;
+                  result.ptr = first;
+                  return result;
+               }
+               value = static_cast<I>(acc);
+            }
+         }
+         else {
+            // Unsigned type
+            value = acc;
+         }
+
+         result.ptr = first;
+         return result;
+      }
+   }
+}
diff --git a/deps/saucer/include/glaze/util/poly.hpp b/deps/saucer/include/glaze/util/poly.hpp
deleted file mode 100644
index 01fe595..0000000
--- a/deps/saucer/include/glaze/util/poly.hpp
+++ /dev/null
@@ -1,169 +0,0 @@
-// Glaze Library
-// For the license information refer to glaze.hpp
-
-#pragma once
-
-#include "glaze/core/common.hpp"
-#include "glaze/util/any.hpp"
-
-namespace glz
-{
-   template <class Spec>
-   inline constexpr auto fn_tuple()
-   {
-      return map_tuple(
-         [](auto& v) {
-            using mem_fn_t = std::decay_t<decltype(get<1>(v))>;
-            return typename function_signature<mem_fn_t>::type{};
-         },
-         meta_v<Spec>);
-   }
-
-   template <class Spec>
-   using fn_variant = typename detail::tuple_variant<decltype(fn_tuple<Spec>())>::type;
-
-   template <class Spec, size_t... I>
-   inline constexpr auto make_mem_fn_wrapper_map_impl(std::index_sequence<I...>)
-   {
-      constexpr auto N = glz::tuple_size_v<meta_t<Spec>>;
-      return detail::normal_map<sv, fn_variant<Spec>, N>(std::array{pair<sv, fn_variant<Spec>>{
-         sv(get<0>(get<I>(meta_v<Spec>))), get_argument<get<1>(get<I>(meta_v<Spec>))>()}...});
-   }
-
-   template <class Spec>
-   inline constexpr auto make_mem_fn_wrapper_map()
-   {
-      constexpr auto N = glz::tuple_size_v<meta_t<Spec>>;
-      return make_mem_fn_wrapper_map_impl<Spec>(std::make_index_sequence<N>{});
-   }
-
-   union void_union {
-      void* ptr;
-      void (*fptr)();
-   };
-
-   template <class = void, std::size_t... Is>
-   constexpr auto indexer(std::index_sequence<Is...>) noexcept
-   {
-      return []<class F>(F&& f) noexcept -> decltype(auto) {
-         return std::forward<F>(f)(std::integral_constant<std::size_t, Is>{}...);
-      };
-   }
-
-   // takes a number N
-   // returns a function object that, when passed a function object f
-   // passes it compile-time values from 0 to N-1 inclusive.
-   template <size_t N>
-   constexpr auto indexer() noexcept
-   {
-      return indexer(std::make_index_sequence<N>{});
-   }
-
-   template <size_t N, class Func>
-   constexpr auto for_each_poly(Func&& f) noexcept
-   {
-      return indexer<N>()([&](auto&&... i) noexcept { (std::forward<Func>(f)(i), ...); });
-   }
-
-   template <class Spec>
-   struct poly
-   {
-      template <class T>
-      poly(T&& v) : anything(std::forward<T>(v))
-      {
-         raw_ptr = anything.data();
-
-         static constexpr auto N = glz::tuple_size_v<meta_t<Spec>>;
-         static constexpr auto frozen_map = detail::make_map<std::remove_pointer_t<T>, false>();
-
-         for_each_poly<N>([&](auto I) {
-            static constexpr auto spec = meta_v<Spec>;
-
-            static constexpr sv key = glz::get<0>(glz::get<I>(spec));
-            static constexpr auto member_it = frozen_map.find(key);
-            if constexpr (member_it != frozen_map.end()) {
-               static constexpr auto index = cmap.index(key);
-               static constexpr auto member_ptr = std::get<member_it->second.index()>(member_it->second);
-
-               using SpecElement = std::decay_t<decltype(glz::get<1>(glz::get<I>(spec)))>;
-
-               using X = std::decay_t<decltype(member_ptr)>;
-               if constexpr (std::is_member_object_pointer_v<X>) {
-                  using SpecMember = typename member_value<SpecElement>::type;
-                  using XMember = typename member_value<X>::type;
-                  if constexpr (!std::same_as<SpecMember, XMember>) {
-                     static_assert(false_v<SpecMember, XMember>, "spec and type do not match for member object");
-                  }
-
-                  if constexpr (std::is_pointer_v<T>) {
-                     map[index].ptr = &((*static_cast<T>(raw_ptr)).*member_ptr);
-                  }
-                  else {
-                     map[index].ptr = &((*static_cast<T*>(raw_ptr)).*member_ptr);
-                  }
-               }
-               else {
-                  using SpecF = typename std_function_signature<SpecElement>::type;
-                  using F = typename std_function_signature<std::decay_t<decltype(member_ptr)>>::type;
-
-                  if constexpr (!std::same_as<SpecF, F>) {
-                     static_assert(false_v<SpecF, F>, "spec and type function signatures do not match");
-                  }
-
-                  map[index].fptr = reinterpret_cast<void (*)()>(arguments<member_ptr, X>::op);
-               }
-            }
-            else {
-               static_assert(false_v<decltype(member_it)>, "spec key does not match meta");
-            }
-         });
-      }
-
-      glz::any anything;
-      static constexpr auto cmap = make_mem_fn_wrapper_map<Spec>();
-      std::array<void_union, cmap.size()> map;
-
-      template <string_literal name, class... Args>
-      decltype(auto) call(Args&&... args)
-      {
-         static constexpr sv key = chars<name>;
-         static constexpr auto member_it = cmap.find(key);
-
-         if constexpr (member_it != cmap.end()) {
-            static constexpr auto index = cmap.index(key);
-            using X = std::decay_t<decltype(std::get<member_it->second.index()>(cmap.find(key)->second))>;
-            auto* v = reinterpret_cast<X>(map[index].fptr);
-            using V = std::decay_t<decltype(v)>;
-            if constexpr (std::invocable<V, void*, Args...>) {
-               return v(raw_ptr, std::forward<Args>(args)...);
-            }
-            else {
-               static_assert(false_v<decltype(name)>, "call: invalid arguments to call");
-            }
-         }
-         else {
-            static_assert(false_v<decltype(name)>, "call: invalid name");
-         }
-      }
-
-      template <string_literal name>
-      decltype(auto) get()
-      {
-         static constexpr sv key = chars<name>;
-         static constexpr auto member_it = cmap.find(key);
-
-         if constexpr (member_it != cmap.end()) {
-            static constexpr auto index = cmap.index(key);
-            using X = decltype(std::get<member_it->second.index()>(cmap.find(key)->second));
-            auto* v = reinterpret_cast<X>(map[index].ptr);
-            return *v;
-         }
-         else {
-            static_assert(false_v<decltype(name)>, "call: invalid name");
-         }
-      }
-
-     private:
-      void* raw_ptr;
-   };
-}
diff --git a/deps/saucer/include/glaze/util/primes_64.hpp b/deps/saucer/include/glaze/util/primes_64.hpp
new file mode 100644
index 0000000..02e4786
--- /dev/null
+++ b/deps/saucer/include/glaze/util/primes_64.hpp
@@ -0,0 +1,66 @@
+// Glaze Library
+// For the license information refer to glaze.hpp
+
+#pragma once
+
+#include <array>
+#include <cstdint>
+
+namespace glz
+{
+   // Array of random 64bit primes to avoid needing a generator
+   // If you have a 10% chance of success, 128 tries has 1 : 719'380 odds of failure
+   // formula: 1 / (1 - .10)^128
+   // If you have a 15% chance of success, 128 tries has 1 : 1'082'374'392 odds of failure
+   inline constexpr std::array<uint64_t, 128> primes_64 = {
+      12835920395396008793ull, 15149911783463666029ull, 15211026597907833541ull, 14523965596842631817ull,
+      16449355892475772073ull, 15002762636229733759ull, 12275448295353509891ull, 16826285440568349437ull,
+      17433093378066653197ull, 10902769355249605843ull,
+      // 10
+      13434269760430048511ull, 11322871945166463571ull, 9764742595129026499ull, 13799666429485716229ull,
+      14861204462552525359ull, 17599486090324515493ull, 10266842847898195667ull, 13468209895759219897ull,
+      16289274021814922521ull, 17204791465022878523ull,
+      // 20
+      17650915497556268801ull, 9455725851336774341ull, 9961868820920778071ull, 18289017266131008167ull,
+      16309921878298474091ull, 11652007405601517343ull, 17496906368504743207ull, 13339901080756288547ull,
+      10018112158103183191ull, 14981853847663275059ull,
+      // 30
+      15024425770511821387ull, 10063189458099824779ull, 11839419318547724641ull, 12830508825440804579ull,
+      18433073685722024387ull, 17299753196133391897ull, 15396274865347173053ull, 13749499465490568733ull,
+      13860497513065316459ull, 11692484392508072123ull,
+      // 40
+      9438685344574842347ull, 14400973074801304571ull, 15991854874494707081ull, 12114831452910579989ull,
+      13998562683662696077ull, 10851982863396796529ull, 10344539733475859441ull, 10045431121852560691ull,
+      12186301656248163491ull, 10339340957932801343ull,
+      // 50
+      12602808298244447957ull, 9729322814141112953ull, 16362682788060189359ull, 14286005063617200559ull,
+      10711312188467965759ull, 17189878401094383577ull, 14020292519311722517ull, 14345076507873302501ull,
+      12604083410008146689ull, 13199781912416808047ull,
+      // 60
+      12315285542260457987ull, 9594690105092455043ull, 18319948908022195243ull, 16595976138570481823ull,
+      12195274638706298323ull, 17646127793987855047ull, 16841966643138849923ull, 13507873747212661603ull,
+      13643501673321416333ull, 12363547163076811279ull,
+      // 70
+      14884690672546139069ull, 16390599211964954609ull, 13389084014248465909ull, 9833412254409620477ull,
+      13398707790907619797ull, 18368581595698861159ull, 10384836406878147059ull, 9453231669972318281ull,
+      16669513057697818169ull, 14697852657232879237ull,
+      // 80
+      15363091209268144241ull, 15275124567630446861ull, 17481357028816037011ull, 12534821792295694231ull,
+      11054303650520058359ull, 12403322865831490261ull, 16889743306920098983ull, 16047403249754946029ull,
+      16775982981238529423ull, 12421181800577384167ull,
+      // 90
+      9280311361047996317ull, 12160582891762080001ull, 17367939315478490407ull, 9267482598791369377ull,
+      17806662591996060709ull, 11533875385674872861ull, 16816712667689633689ull, 16223588510861656927ull,
+      13482535659370429831ull, 11801382448764686461ull,
+      // 100
+      18177646705946605939ull, 12608957628213527767ull, 17302819561726521227ull, 10609776890453861677ull,
+      16615779974080376533ull, 14779379909309032351ull, 14673741062489338759ull, 11634351264868983527ull,
+      13874971253878591537ull, 17332275173558136899ull,
+      // 110
+      11257300840627829851ull, 13341443249676872783ull, 11607230252125083613ull, 12141161410409106457ull,
+      13282325402819801929ull, 17990774082148480601ull, 15496227723025164119ull, 15956314649183876369ull,
+      9834926670622290883ull, 16435035491439552943ull,
+      // 120
+      14806063675962222449ull, 18113370406266068597ull, 9968958022058734229ull, 14864844583184822773ull,
+      11170341707334307859ull, 10502344452987841991ull, 16247553219265957739ull, 14933089789266129581ull};
+}
diff --git a/deps/saucer/include/glaze/util/stoui64.hpp b/deps/saucer/include/glaze/util/stoui64.hpp
deleted file mode 100644
index df52f41..0000000
--- a/deps/saucer/include/glaze/util/stoui64.hpp
+++ /dev/null
@@ -1,390 +0,0 @@
-#pragma once
-
-#include <array>
-#include <bit>
-#include <cmath>
-#include <iterator>
-
-#include "glaze/util/inline.hpp"
-#include "glaze/util/strod.hpp"
-
-namespace glz::detail
-{
-   GLZ_ALWAYS_INLINE constexpr bool is_digit(const char c) noexcept { return c >= '0' && c <= '9'; }
-
-   GLZ_ALWAYS_INLINE constexpr bool is_safe_addition(uint64_t a, uint64_t b) noexcept
-   {
-      return a <= (std::numeric_limits<uint64_t>::max)() - b;
-   }
-
-   GLZ_ALWAYS_INLINE constexpr bool is_safe_multiplication10(uint64_t a) noexcept
-   {
-      constexpr auto b = (std::numeric_limits<uint64_t>::max)() / 10;
-      return a <= b;
-   }
-
-   template <class T = uint64_t>
-   GLZ_ALWAYS_INLINE constexpr bool stoui64(uint64_t& res, const char*& c) noexcept
-   {
-      if (!is_digit(*c)) [[unlikely]] {
-         return false;
-      }
-
-      // maximum number of digits need is: 3, 5, 10, 20, for byte sizes of 1, 2, 4, 8
-      // we need to store one extra space for a digit for sizes of 1, 2, and 4 because we avoid checking for overflow
-      // since we store in a uint64_t
-      constexpr std::array<uint32_t, 4> max_digits_from_size = {4, 6, 11, 20};
-      constexpr auto N = max_digits_from_size[std::bit_width(sizeof(T)) - 1];
-
-      std::array<uint8_t, N> digits{0};
-      auto next_digit = digits.begin();
-      auto consume_digit = [&c, &next_digit, &digits]() {
-         if (next_digit < digits.cend()) [[likely]] {
-            *next_digit = (*c - '0');
-            ++next_digit;
-         }
-         ++c;
-      };
-
-      if (*c == '0') {
-         // digits[i] = 0; already set to zero
-         ++c;
-         ++next_digit;
-
-         if (*c == '0') [[unlikely]] {
-            return false;
-         }
-      }
-
-      while (is_digit(*c)) {
-         consume_digit();
-      }
-      auto n = std::distance(digits.begin(), next_digit);
-
-      if (*c == '.') {
-         ++c;
-         while (is_digit(*c)) {
-            consume_digit();
-         }
-      }
-
-      if (*c == 'e' || *c == 'E') {
-         ++c;
-
-         bool negative = false;
-         if (*c == '+' || *c == '-') {
-            negative = (*c == '-');
-            ++c;
-         }
-         uint8_t exp = 0;
-         while (is_digit(*c) && exp < 128) {
-            exp = 10 * exp + (*c - '0');
-            ++c;
-         }
-         n += negative ? -exp : exp;
-      }
-
-      res = 0;
-      if (n < 0) [[unlikely]] {
-         return true;
-      }
-
-      if constexpr (std::same_as<T, uint64_t>) {
-         if (n > 20) [[unlikely]] {
-            return false;
-         }
-
-         if (n == 20) [[unlikely]] {
-            for (auto k = 0; k < 19; ++k) {
-               res = 10 * res + digits[k];
-            }
-
-            if (is_safe_multiplication10(res)) [[likely]] {
-               res *= 10;
-            }
-            else [[unlikely]] {
-               return false;
-            }
-            if (is_safe_addition(res, digits.back())) [[likely]] {
-               res += digits.back();
-            }
-            else [[unlikely]] {
-               return false;
-            }
-         }
-         else [[likely]] {
-            for (auto k = 0; k < n; ++k) {
-               res = 10 * res + digits[k];
-            }
-         }
-      }
-      else {
-         // a value of n == N would result in reading digits[N], which is invalid
-         if (n >= N) [[unlikely]] {
-            return false;
-         }
-         else [[likely]] {
-            for (auto k = 0; k < n; ++k) {
-               res = 10 * res + digits[k];
-            }
-         }
-      }
-
-      return true;
-   }
-
-   template <class T = uint64_t>
-   GLZ_ALWAYS_INLINE constexpr bool stoui64(uint64_t& res, auto& it) noexcept
-   {
-      static_assert(sizeof(*it) == sizeof(char));
-      const char* cur = reinterpret_cast<const char*>(it);
-      const char* beg = cur;
-      if (stoui64(res, cur)) {
-         it += (cur - beg);
-         return true;
-      }
-      return false;
-   }
-
-   template <class T, bool force_conformance, class CharType>
-      requires(std::is_unsigned_v<T>)
-   inline bool parse_int(auto& val, const CharType*& cur) noexcept
-   {
-      using X = std::remove_volatile_t<T>;
-      constexpr auto is_volatile = std::is_volatile_v<std::remove_reference_t<decltype(val)>>;
-      const CharType* sig_cut{}; // significant part cutting position for long number
-      [[maybe_unused]] const CharType* sig_end{}; // significant part ending position
-      const CharType* dot_pos{}; // decimal point position
-      uint32_t frac_zeros = 0;
-      uint64_t sig = uint64_t(*cur - '0'); // significant part of the number
-      int32_t exp = 0; // exponent part of the number
-      bool exp_sign; // temporary exponent sign from literal part
-      int32_t exp_sig = 0; // temporary exponent number from significant part
-      int32_t exp_lit = 0; // temporary exponent number from exponent literal part
-      uint64_t num_tmp; // temporary number for reading
-      const CharType* tmp; // temporary cursor for reading
-
-      /* begin with non-zero digit */
-      if (sig > 9) [[unlikely]] {
-         return false;
-      }
-      constexpr auto zero = uint8_t('0');
-#define expr_intg(i)                              \
-   if ((num_tmp = cur[i] - zero) <= 9) [[likely]] \
-      sig = num_tmp + sig * 10;                   \
-   else {                                         \
-      if constexpr (force_conformance && i > 1) { \
-         if (*cur == zero) return false;          \
-      }                                           \
-      goto digi_sepr_##i;                         \
-   }
-      repeat_in_1_18(expr_intg);
-#undef expr_intg
-      if constexpr (force_conformance) {
-         if (*cur == zero) return false;
-      }
-      cur += 19; /* skip continuous 19 digits */
-      if (!digi_is_digit_or_fp(*cur)) {
-         val = static_cast<X>(sig);
-         return true;
-      }
-      goto digi_intg_more; /* read more digits in integral part */
-      /* process first non-digit character */
-#define expr_sepr(i)                                              \
-   digi_sepr_##i : if ((!digi_is_fp(uint8_t(cur[i])))) [[likely]] \
-   {                                                              \
-      cur += i;                                                   \
-      val = sig;                                                  \
-      return true;                                                \
-   }                                                              \
-   dot_pos = cur + i;                                             \
-   if ((cur[i] == '.')) [[likely]] {                              \
-      if (sig == 0)                                               \
-         while (cur[frac_zeros + i + 1] == zero) ++frac_zeros;    \
-      goto digi_frac_##i;                                         \
-   }                                                              \
-   cur += i;                                                      \
-   sig_end = cur;                                                 \
-   goto digi_exp_more;
-      repeat_in_1_18(expr_sepr)
-#undef expr_sepr
-      /* read fraction part */
-#define expr_frac(i)                                                                                 \
-   digi_frac_##i : if (((num_tmp = uint64_t(cur[i + 1 + frac_zeros] - zero)) <= 9)) [[likely]] sig = \
-                      num_tmp + sig * 10;                                                            \
-   else                                                                                              \
-   {                                                                                                 \
-      goto digi_stop_##i;                                                                            \
-   }
-         repeat_in_1_18(expr_frac)
-#undef expr_frac
-            cur += 20 + frac_zeros; /* skip 19 digits and 1 decimal point */
-      if (uint8_t(*cur - zero) > 9) goto digi_frac_end; /* fraction part end */
-      goto digi_frac_more; /* read more digits in fraction part */
-      /* significant part end */
-#define expr_stop(i)                          \
-   digi_stop_##i : cur += i + 1 + frac_zeros; \
-   goto digi_frac_end;
-      repeat_in_1_18(expr_stop)
-#undef expr_stop
-         /* read more digits in integral part */
-         digi_intg_more : static constexpr uint64_t U64_MAX = (std::numeric_limits<uint64_t>::max)(); // todo
-      if ((num_tmp = *cur - zero) < 10) {
-         if (!digi_is_digit_or_fp(cur[1])) {
-            /* this number is an integer consisting of 20 digits */
-            if ((sig < (U64_MAX / 10)) || (sig == (U64_MAX / 10) && num_tmp <= (U64_MAX % 10))) {
-               sig = num_tmp + sig * 10;
-               cur++;
-               val = static_cast<X>(sig);
-               return true;
-            }
-         }
-      }
-      if ((e_bit | *cur) == 'e') {
-         dot_pos = cur;
-         goto digi_exp_more;
-      }
-      if (*cur == '.') {
-         dot_pos = cur++;
-         if (uint8_t(*cur - zero) > 9) [[unlikely]] {
-            return false;
-         }
-      }
-      /* read more digits in fraction part */
-   digi_frac_more:
-      sig_cut = cur; /* too large to fit in u64, excess digits need to be cut */
-      sig += (*cur >= '5'); /* round */
-      while (uint8_t(*++cur - zero) < 10) {
-      }
-      if (!dot_pos) {
-         dot_pos = cur;
-         if (*cur == '.') {
-            if (uint8_t(*++cur - zero) > 9) [[unlikely]] {
-               return false;
-            }
-            while (uint8_t(*++cur - zero) < 10) {
-            }
-         }
-      }
-      exp_sig = int32_t(dot_pos - sig_cut);
-      exp_sig += (dot_pos < sig_cut);
-      /* ignore trailing zeros */
-      tmp = cur - 1;
-      while (*tmp == '0' || *tmp == '.') tmp--;
-      if (tmp < sig_cut) {
-         sig_cut = nullptr;
-      }
-      else {
-         sig_end = cur;
-      }
-      if ((e_bit | *cur) == 'e') goto digi_exp_more;
-      goto digi_exp_finish;
-      /* fraction part end */
-   digi_frac_end:
-      sig_end = cur;
-      exp_sig = -int32_t((cur - dot_pos) - 1);
-      if constexpr (force_conformance) {
-         if (exp_sig == 0) [[unlikely]]
-            return false;
-      }
-      if ((e_bit | *cur) != 'e') [[likely]] {
-         if ((exp_sig < F64_MIN_DEC_EXP - 19)) [[unlikely]] {
-            val = 0;
-            return true;
-         }
-         exp = exp_sig;
-         goto digi_finish;
-      }
-      else {
-         goto digi_exp_more;
-      }
-      /* read exponent part */
-   digi_exp_more:
-      exp_sign = (*++cur == '-');
-      cur += (*cur == '+' || *cur == '-');
-      if (uint8_t(*cur - zero) > 9) {
-         if constexpr (force_conformance) {
-            return false;
-         }
-         else {
-            goto digi_finish;
-         }
-      }
-      while (*cur == '0') ++cur;
-      /* read exponent literal */
-      tmp = cur;
-      uint8_t c;
-      while (uint8_t(c = *cur - zero) < 10) {
-         ++cur;
-         exp_lit = c + uint32_t(exp_lit) * 10;
-      }
-      // large exponent case
-      if ((cur - tmp >= 6)) [[unlikely]] {
-         if (sig == 0 || exp_sign) {
-            val = 0;
-            return true;
-         }
-         else {
-            return false;
-         }
-      }
-      exp_sig += exp_sign ? -exp_lit : exp_lit;
-      // validate exponent value
-   digi_exp_finish:
-      if (sig == 0) {
-         val = 0;
-         return true;
-      }
-      if (exp_sig == 19) {
-         if constexpr (is_volatile) {
-            val = val * static_cast<X>(powers_of_ten_int[exp_sig - 1]);
-            if (is_safe_multiplication10(val)) [[likely]] {
-               val = val * 10;
-               return val;
-            }
-            else [[unlikely]] {
-               return false;
-            }
-         }
-         else {
-            val *= static_cast<X>(powers_of_ten_int[exp_sig - 1]);
-            if (is_safe_multiplication10(val)) [[likely]] {
-               return val *= 10;
-            }
-            else [[unlikely]] {
-               return false;
-            }
-         }
-      }
-      else if (exp_sig >= 20) [[unlikely]] {
-         return false;
-      }
-      exp = exp_sig;
-      /* all digit read finished */
-   digi_finish:
-
-      if (exp <= -20) [[unlikely]] {
-         val = X(0);
-         return true;
-      }
-
-      val = static_cast<X>(sig);
-      if constexpr (is_volatile) {
-         if (exp >= 0) {
-            val = val * static_cast<X>(powers_of_ten_int[exp]);
-         }
-         else {
-            val = val / static_cast<X>(powers_of_ten_int[-exp]);
-         }
-      }
-      else {
-         if (exp >= 0) {
-            val *= static_cast<X>(powers_of_ten_int[exp]);
-         }
-         else {
-            val /= static_cast<X>(powers_of_ten_int[-exp]);
-         }
-      }
-      return true;
-   }
-}
diff --git a/deps/saucer/include/glaze/util/string_literal.hpp b/deps/saucer/include/glaze/util/string_literal.hpp
index a7f59c5..ee9f1d9 100644
--- a/deps/saucer/include/glaze/util/string_literal.hpp
+++ b/deps/saucer/include/glaze/util/string_literal.hpp
@@ -3,7 +3,7 @@
 
 #pragma once
 
-#include <algorithm> // for std::copy_n
+#include <array>
 #include <string_view>
 
 namespace glz
@@ -13,6 +13,13 @@ namespace glz
    template <size_t N>
    struct string_literal
    {
+      using value_type = char;
+      using reference = value_type&;
+      using const_reference = const value_type&;
+      using pointer = value_type*;
+      using const_pointer = const value_type*;
+      using size_type = size_t;
+
       static constexpr size_t length = (N > 0) ? (N - 1) : 0;
 
       [[nodiscard]] constexpr size_t size() const noexcept { return length; }
@@ -23,7 +30,12 @@ namespace glz
       constexpr string_literal& operator=(const string_literal&) noexcept = default;
       constexpr string_literal& operator=(string_literal&&) noexcept = default;
 
-      constexpr string_literal(const char (&str)[N]) noexcept { std::copy_n(str, N, value); }
+      constexpr string_literal(const char (&str)[N]) noexcept
+      {
+         for (size_t i = 0; i < N; ++i) {
+            value[i] = str[i];
+         }
+      }
 
       char value[N];
       constexpr const char* begin() const noexcept { return value; }
@@ -34,22 +46,27 @@ namespace glz
       [[nodiscard]] constexpr const std::string_view sv() const noexcept { return {value, length}; }
 
       [[nodiscard]] constexpr operator std::string_view() const noexcept { return {value, length}; }
+
+      constexpr reference operator[](size_type index) noexcept { return value[index]; }
+      constexpr const_reference operator[](size_type index) const noexcept { return value[index]; }
    };
 
    template <size_t N>
    constexpr auto string_literal_from_view(sv str)
    {
       string_literal<N + 1> sl{};
-      std::copy_n(str.data(), str.size(), sl.value);
+      for (size_t i = 0; i < str.size(); ++i) {
+         sl[i] = str[i];
+      }
       *(sl.value + N) = '\0';
       return sl;
    }
 
    template <string_literal Str>
-   constexpr std::string_view chars = Str.sv();
+   inline constexpr std::string_view chars = Str.sv();
 
    template <string_literal Str>
-   constexpr std::string_view root = Str.sv();
+   inline constexpr std::string_view root = Str.sv();
 
    namespace detail
    {
@@ -64,12 +81,12 @@ namespace glz
       {
          constexpr auto joined_arr = []() {
             constexpr size_t len = (Strs.size() + ... + 0);
-            std::array<char, len + 1> arr{};
+            std::array<char, len + 1> arr;
             auto append = [i = 0, &arr](const auto& s) mutable {
                for (auto c : s) arr[i++] = c;
             };
             (append(Strs), ...);
-            arr[len] = 0;
+            arr[len] = '\0';
             return arr;
          }();
          auto& static_arr = make_static<joined_arr>::value;
@@ -79,5 +96,30 @@ namespace glz
 
    // Helper to get the value out
    template <const std::string_view&... Strs>
-   constexpr auto join_v = detail::join<Strs...>();
+   inline constexpr auto join_v = detail::join<Strs...>();
+
+   template <const std::string_view& Key, bool Prettify = false>
+   inline constexpr auto quoted_key_v = []() -> std::string_view {
+      constexpr auto quoted = [] {
+         constexpr auto N = Key.size();
+         std::array<char, N + 4 + Prettify> result; // [quote, key, quote, colon, (prettify? space), null]
+         result[0] = '"';
+         for (size_t i = 0; i < N; ++i) {
+            result[i + 1] = Key[i];
+         }
+         result[N + 1] = '"';
+         result[N + 2] = ':';
+         if constexpr (Prettify) {
+            result[N + 3] = ' ';
+            result[N + 4] = '\0';
+         }
+         else {
+            result[N + 3] = '\0';
+         }
+         return result;
+      }();
+      // TODO: make_static required by GCC 12
+      auto& static_arr = detail::make_static<quoted>::value;
+      return {static_arr.data(), static_arr.size() - 1};
+   }();
 }
diff --git a/deps/saucer/include/glaze/util/strod.hpp b/deps/saucer/include/glaze/util/strod.hpp
deleted file mode 100644
index 99ea4f1..0000000
--- a/deps/saucer/include/glaze/util/strod.hpp
+++ /dev/null
@@ -1,797 +0,0 @@
-#pragma once
-
-#include <array>
-#include <bit>
-#include <bitset>
-#include <cfenv>
-#include <charconv>
-#include <cmath>
-#include <cstdint>
-#include <cstring>
-#include <limits>
-#include <string>
-#include <type_traits>
-#include <vector>
-
-#if defined(_M_X64) || defined(_M_ARM64)
-#include <intrin.h>
-#endif
-
-namespace glz::detail
-{
-   // Based on yyjson: https://github.com/ibireme/yyjson/blob/master/src/yyjson.c with some changes to rounding and
-   // dirrect for floats
-   // TODO: Subnormals are not handled right now.
-   // Wontfix: Numbers with more than 19 sigfigs may be off by 1ulp. No algorithm should be outputing more than 17
-   // digits so I dont think roundtripping matters if you supply extra digits
-
-   constexpr std::array<uint64_t, 20> powers_of_ten_int{1ull,
-                                                        10ull,
-                                                        100ull,
-                                                        1000ull,
-                                                        10000ull,
-                                                        100000ull,
-                                                        1000000ull,
-                                                        10000000ull,
-                                                        100000000ull,
-                                                        1000000000ull,
-                                                        10000000000ull,
-                                                        100000000000ull,
-                                                        1000000000000ull,
-                                                        10000000000000ull,
-                                                        100000000000000ull,
-                                                        1000000000000000ull,
-                                                        10000000000000000ull,
-                                                        100000000000000000ull,
-                                                        1000000000000000000ull,
-                                                        10000000000000000000ull};
-   constexpr std::array<double, 23> powers_of_ten_float = {1e0,  1e1,  1e2,  1e3,  1e4,  1e5,  1e6,  1e7,
-                                                           1e8,  1e9,  1e10, 1e11, 1e12, 1e13, 1e14, 1e15,
-                                                           1e16, 1e17, 1e18, 1e19, 1e20, 1e21, 1e22};
-// https://stackoverflow.com/questions/28868367/getting-the-high-part-of-64-bit-integer-multiplication
-#ifdef __SIZEOF_INT128__
-   inline uint64_t mulhi64(uint64_t a, uint64_t b)
-   {
-#if defined(__GNUC__) || defined(__GNUG__)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wpedantic"
-      unsigned __int128 prod = a * static_cast<unsigned __int128>(b);
-#pragma GCC diagnostic pop
-#else
-      unsigned __int128 prod = a * static_cast<unsigned __int128>(b);
-#endif
-      return prod >> 64;
-   }
-#elif defined(_M_X64) || defined(_M_ARM64)
-#define mulhi64 __umulh
-#else
-   inline uint64_t mulhi64(uint64_t a, uint64_t b) noexcept
-   {
-      uint64_t a_lo = (uint32_t)a;
-      uint64_t a_hi = a >> 32;
-      uint64_t b_lo = (uint32_t)b;
-      uint64_t b_hi = b >> 32;
-      uint64_t a_x_b_hi = a_hi * b_hi;
-      uint64_t a_x_b_mid = a_hi * b_lo;
-      uint64_t b_x_a_mid = b_hi * a_lo;
-      uint64_t a_x_b_lo = a_lo * b_lo;
-      uint64_t carry_bit = ((uint64_t)(uint32_t)a_x_b_mid + (uint64_t)(uint32_t)b_x_a_mid + (a_x_b_lo >> 32)) >> 32;
-      uint64_t multhi = a_x_b_hi + (a_x_b_mid >> 32) + (b_x_a_mid >> 32) + carry_bit;
-      return multhi;
-   }
-#endif
-   // Min decimal exponent in pow10_sig_table.
-   constexpr auto pow10_sig_table_min_exp = -343;
-   // Max decimal exponent in pow10_sig_table.
-   constexpr auto pow10_sig_table_max_exp = 324;
-   // Min exact decimal exponent in pow10_sig_table
-   constexpr auto pow10_sig_table_min_exact = 0;
-   // Max exact decimal exponent in pow10_sig_table
-   constexpr auto pow10_sig_table_max_exact = 27;
-   constexpr std::array<uint64_t, 668> pow10_sig_table = {
-      0xBF29DCABA82FDEAE, 0xEEF453D6923BD65A, 0x9558B4661B6565F8, 0xBAAEE17FA23EBF76, 0xE95A99DF8ACE6F53,
-      0x91D8A02BB6C10594, 0xB64EC836A47146F9, 0xE3E27A444D8D98B7, 0x8E6D8C6AB0787F72, 0xB208EF855C969F4F,
-      0xDE8B2B66B3BC4723, 0x8B16FB203055AC76, 0xADDCB9E83C6B1793, 0xD953E8624B85DD78, 0x87D4713D6F33AA6B,
-      0xA9C98D8CCB009506, 0xD43BF0EFFDC0BA48, 0x84A57695FE98746D, 0xA5CED43B7E3E9188, 0xCF42894A5DCE35EA,
-      0x818995CE7AA0E1B2, 0xA1EBFB4219491A1F, 0xCA66FA129F9B60A6, 0xFD00B897478238D0, 0x9E20735E8CB16382,
-      0xC5A890362FDDBC62, 0xF712B443BBD52B7B, 0x9A6BB0AA55653B2D, 0xC1069CD4EABE89F8, 0xF148440A256E2C76,
-      0x96CD2A865764DBCA, 0xBC807527ED3E12BC, 0xEBA09271E88D976B, 0x93445B8731587EA3, 0xB8157268FDAE9E4C,
-      0xE61ACF033D1A45DF, 0x8FD0C16206306BAB, 0xB3C4F1BA87BC8696, 0xE0B62E2929ABA83C, 0x8C71DCD9BA0B4925,
-      0xAF8E5410288E1B6F, 0xDB71E91432B1A24A, 0x892731AC9FAF056E, 0xAB70FE17C79AC6CA, 0xD64D3D9DB981787D,
-      0x85F0468293F0EB4E, 0xA76C582338ED2621, 0xD1476E2C07286FAA, 0x82CCA4DB847945CA, 0xA37FCE126597973C,
-      0xCC5FC196FEFD7D0C, 0xFF77B1FCBEBCDC4F, 0x9FAACF3DF73609B1, 0xC795830D75038C1D, 0xF97AE3D0D2446F25,
-      0x9BECCE62836AC577, 0xC2E801FB244576D5, 0xF3A20279ED56D48A, 0x9845418C345644D6, 0xBE5691EF416BD60C,
-      0xEDEC366B11C6CB8F, 0x94B3A202EB1C3F39, 0xB9E08A83A5E34F07, 0xE858AD248F5C22C9, 0x91376C36D99995BE,
-      0xB58547448FFFFB2D, 0xE2E69915B3FFF9F9, 0x8DD01FAD907FFC3B, 0xB1442798F49FFB4A, 0xDD95317F31C7FA1D,
-      0x8A7D3EEF7F1CFC52, 0xAD1C8EAB5EE43B66, 0xD863B256369D4A40, 0x873E4F75E2224E68, 0xA90DE3535AAAE202,
-      0xD3515C2831559A83, 0x8412D9991ED58091, 0xA5178FFF668AE0B6, 0xCE5D73FF402D98E3, 0x80FA687F881C7F8E,
-      0xA139029F6A239F72, 0xC987434744AC874E, 0xFBE9141915D7A922, 0x9D71AC8FADA6C9B5, 0xC4CE17B399107C22,
-      0xF6019DA07F549B2B, 0x99C102844F94E0FB, 0xC0314325637A1939, 0xF03D93EEBC589F88, 0x96267C7535B763B5,
-      0xBBB01B9283253CA2, 0xEA9C227723EE8BCB, 0x92A1958A7675175F, 0xB749FAED14125D36, 0xE51C79A85916F484,
-      0x8F31CC0937AE58D2, 0xB2FE3F0B8599EF07, 0xDFBDCECE67006AC9, 0x8BD6A141006042BD, 0xAECC49914078536D,
-      0xDA7F5BF590966848, 0x888F99797A5E012D, 0xAAB37FD7D8F58178, 0xD5605FCDCF32E1D6, 0x855C3BE0A17FCD26,
-      0xA6B34AD8C9DFC06F, 0xD0601D8EFC57B08B, 0x823C12795DB6CE57, 0xA2CB1717B52481ED, 0xCB7DDCDDA26DA268,
-      0xFE5D54150B090B02, 0x9EFA548D26E5A6E1, 0xC6B8E9B0709F109A, 0xF867241C8CC6D4C0, 0x9B407691D7FC44F8,
-      0xC21094364DFB5636, 0xF294B943E17A2BC4, 0x979CF3CA6CEC5B5A, 0xBD8430BD08277231, 0xECE53CEC4A314EBD,
-      0x940F4613AE5ED136, 0xB913179899F68584, 0xE757DD7EC07426E5, 0x9096EA6F3848984F, 0xB4BCA50B065ABE63,
-      0xE1EBCE4DC7F16DFB, 0x8D3360F09CF6E4BD, 0xB080392CC4349DEC, 0xDCA04777F541C567, 0x89E42CAAF9491B60,
-      0xAC5D37D5B79B6239, 0xD77485CB25823AC7, 0x86A8D39EF77164BC, 0xA8530886B54DBDEB, 0xD267CAA862A12D66,
-      0x8380DEA93DA4BC60, 0xA46116538D0DEB78, 0xCD795BE870516656, 0x806BD9714632DFF6, 0xA086CFCD97BF97F3,
-      0xC8A883C0FDAF7DF0, 0xFAD2A4B13D1B5D6C, 0x9CC3A6EEC6311A63, 0xC3F490AA77BD60FC, 0xF4F1B4D515ACB93B,
-      0x991711052D8BF3C5, 0xBF5CD54678EEF0B6, 0xEF340A98172AACE4, 0x9580869F0E7AAC0E, 0xBAE0A846D2195712,
-      0xE998D258869FACD7, 0x91FF83775423CC06, 0xB67F6455292CBF08, 0xE41F3D6A7377EECA, 0x8E938662882AF53E,
-      0xB23867FB2A35B28D, 0xDEC681F9F4C31F31, 0x8B3C113C38F9F37E, 0xAE0B158B4738705E, 0xD98DDAEE19068C76,
-      0x87F8A8D4CFA417C9, 0xA9F6D30A038D1DBC, 0xD47487CC8470652B, 0x84C8D4DFD2C63F3B, 0xA5FB0A17C777CF09,
-      0xCF79CC9DB955C2CC, 0x81AC1FE293D599BF, 0xA21727DB38CB002F, 0xCA9CF1D206FDC03B, 0xFD442E4688BD304A,
-      0x9E4A9CEC15763E2E, 0xC5DD44271AD3CDBA, 0xF7549530E188C128, 0x9A94DD3E8CF578B9, 0xC13A148E3032D6E7,
-      0xF18899B1BC3F8CA1, 0x96F5600F15A7B7E5, 0xBCB2B812DB11A5DE, 0xEBDF661791D60F56, 0x936B9FCEBB25C995,
-      0xB84687C269EF3BFB, 0xE65829B3046B0AFA, 0x8FF71A0FE2C2E6DC, 0xB3F4E093DB73A093, 0xE0F218B8D25088B8,
-      0x8C974F7383725573, 0xAFBD2350644EEACF, 0xDBAC6C247D62A583, 0x894BC396CE5DA772, 0xAB9EB47C81F5114F,
-      0xD686619BA27255A2, 0x8613FD0145877585, 0xA798FC4196E952E7, 0xD17F3B51FCA3A7A0, 0x82EF85133DE648C4,
-      0xA3AB66580D5FDAF5, 0xCC963FEE10B7D1B3, 0xFFBBCFE994E5C61F, 0x9FD561F1FD0F9BD3, 0xC7CABA6E7C5382C8,
-      0xF9BD690A1B68637B, 0x9C1661A651213E2D, 0xC31BFA0FE5698DB8, 0xF3E2F893DEC3F126, 0x986DDB5C6B3A76B7,
-      0xBE89523386091465, 0xEE2BA6C0678B597F, 0x94DB483840B717EF, 0xBA121A4650E4DDEB, 0xE896A0D7E51E1566,
-      0x915E2486EF32CD60, 0xB5B5ADA8AAFF80B8, 0xE3231912D5BF60E6, 0x8DF5EFABC5979C8F, 0xB1736B96B6FD83B3,
-      0xDDD0467C64BCE4A0, 0x8AA22C0DBEF60EE4, 0xAD4AB7112EB3929D, 0xD89D64D57A607744, 0x87625F056C7C4A8B,
-      0xA93AF6C6C79B5D2D, 0xD389B47879823479, 0x843610CB4BF160CB, 0xA54394FE1EEDB8FE, 0xCE947A3DA6A9273E,
-      0x811CCC668829B887, 0xA163FF802A3426A8, 0xC9BCFF6034C13052, 0xFC2C3F3841F17C67, 0x9D9BA7832936EDC0,
-      0xC5029163F384A931, 0xF64335BCF065D37D, 0x99EA0196163FA42E, 0xC06481FB9BCF8D39, 0xF07DA27A82C37088,
-      0x964E858C91BA2655, 0xBBE226EFB628AFEA, 0xEADAB0ABA3B2DBE5, 0x92C8AE6B464FC96F, 0xB77ADA0617E3BBCB,
-      0xE55990879DDCAABD, 0x8F57FA54C2A9EAB6, 0xB32DF8E9F3546564, 0xDFF9772470297EBD, 0x8BFBEA76C619EF36,
-      0xAEFAE51477A06B03, 0xDAB99E59958885C4, 0x88B402F7FD75539B, 0xAAE103B5FCD2A881, 0xD59944A37C0752A2,
-      0x857FCAE62D8493A5, 0xA6DFBD9FB8E5B88E, 0xD097AD07A71F26B2, 0x825ECC24C873782F, 0xA2F67F2DFA90563B,
-      0xCBB41EF979346BCA, 0xFEA126B7D78186BC, 0x9F24B832E6B0F436, 0xC6EDE63FA05D3143, 0xF8A95FCF88747D94,
-      0x9B69DBE1B548CE7C, 0xC24452DA229B021B, 0xF2D56790AB41C2A2, 0x97C560BA6B0919A5, 0xBDB6B8E905CB600F,
-      0xED246723473E3813, 0x9436C0760C86E30B, 0xB94470938FA89BCE, 0xE7958CB87392C2C2, 0x90BD77F3483BB9B9,
-      0xB4ECD5F01A4AA828, 0xE2280B6C20DD5232, 0x8D590723948A535F, 0xB0AF48EC79ACE837, 0xDCDB1B2798182244,
-      0x8A08F0F8BF0F156B, 0xAC8B2D36EED2DAC5, 0xD7ADF884AA879177, 0x86CCBB52EA94BAEA, 0xA87FEA27A539E9A5,
-      0xD29FE4B18E88640E, 0x83A3EEEEF9153E89, 0xA48CEAAAB75A8E2B, 0xCDB02555653131B6, 0x808E17555F3EBF11,
-      0xA0B19D2AB70E6ED6, 0xC8DE047564D20A8B, 0xFB158592BE068D2E, 0x9CED737BB6C4183D, 0xC428D05AA4751E4C,
-      0xF53304714D9265DF, 0x993FE2C6D07B7FAB, 0xBF8FDB78849A5F96, 0xEF73D256A5C0F77C, 0x95A8637627989AAD,
-      0xBB127C53B17EC159, 0xE9D71B689DDE71AF, 0x9226712162AB070D, 0xB6B00D69BB55C8D1, 0xE45C10C42A2B3B05,
-      0x8EB98A7A9A5B04E3, 0xB267ED1940F1C61C, 0xDF01E85F912E37A3, 0x8B61313BBABCE2C6, 0xAE397D8AA96C1B77,
-      0xD9C7DCED53C72255, 0x881CEA14545C7575, 0xAA242499697392D2, 0xD4AD2DBFC3D07787, 0x84EC3C97DA624AB4,
-      0xA6274BBDD0FADD61, 0xCFB11EAD453994BA, 0x81CEB32C4B43FCF4, 0xA2425FF75E14FC31, 0xCAD2F7F5359A3B3E,
-      0xFD87B5F28300CA0D, 0x9E74D1B791E07E48, 0xC612062576589DDA, 0xF79687AED3EEC551, 0x9ABE14CD44753B52,
-      0xC16D9A0095928A27, 0xF1C90080BAF72CB1, 0x971DA05074DA7BEE, 0xBCE5086492111AEA, 0xEC1E4A7DB69561A5,
-      0x9392EE8E921D5D07, 0xB877AA3236A4B449, 0xE69594BEC44DE15B, 0x901D7CF73AB0ACD9, 0xB424DC35095CD80F,
-      0xE12E13424BB40E13, 0x8CBCCC096F5088CB, 0xAFEBFF0BCB24AAFE, 0xDBE6FECEBDEDD5BE, 0x89705F4136B4A597,
-      0xABCC77118461CEFC, 0xD6BF94D5E57A42BC, 0x8637BD05AF6C69B5, 0xA7C5AC471B478423, 0xD1B71758E219652B,
-      0x83126E978D4FDF3B, 0xA3D70A3D70A3D70A, 0xCCCCCCCCCCCCCCCC, 0x8000000000000000, 0xA000000000000000,
-      0xC800000000000000, 0xFA00000000000000, 0x9C40000000000000, 0xC350000000000000, 0xF424000000000000,
-      0x9896800000000000, 0xBEBC200000000000, 0xEE6B280000000000, 0x9502F90000000000, 0xBA43B74000000000,
-      0xE8D4A51000000000, 0x9184E72A00000000, 0xB5E620F480000000, 0xE35FA931A0000000, 0x8E1BC9BF04000000,
-      0xB1A2BC2EC5000000, 0xDE0B6B3A76400000, 0x8AC7230489E80000, 0xAD78EBC5AC620000, 0xD8D726B7177A8000,
-      0x878678326EAC9000, 0xA968163F0A57B400, 0xD3C21BCECCEDA100, 0x84595161401484A0, 0xA56FA5B99019A5C8,
-      0xCECB8F27F4200F3A, 0x813F3978F8940984, 0xA18F07D736B90BE5, 0xC9F2C9CD04674EDE, 0xFC6F7C4045812296,
-      0x9DC5ADA82B70B59D, 0xC5371912364CE305, 0xF684DF56C3E01BC6, 0x9A130B963A6C115C, 0xC097CE7BC90715B3,
-      0xF0BDC21ABB48DB20, 0x96769950B50D88F4, 0xBC143FA4E250EB31, 0xEB194F8E1AE525FD, 0x92EFD1B8D0CF37BE,
-      0xB7ABC627050305AD, 0xE596B7B0C643C719, 0x8F7E32CE7BEA5C6F, 0xB35DBF821AE4F38B, 0xE0352F62A19E306E,
-      0x8C213D9DA502DE45, 0xAF298D050E4395D6, 0xDAF3F04651D47B4C, 0x88D8762BF324CD0F, 0xAB0E93B6EFEE0053,
-      0xD5D238A4ABE98068, 0x85A36366EB71F041, 0xA70C3C40A64E6C51, 0xD0CF4B50CFE20765, 0x82818F1281ED449F,
-      0xA321F2D7226895C7, 0xCBEA6F8CEB02BB39, 0xFEE50B7025C36A08, 0x9F4F2726179A2245, 0xC722F0EF9D80AAD6,
-      0xF8EBAD2B84E0D58B, 0x9B934C3B330C8577, 0xC2781F49FFCFA6D5, 0xF316271C7FC3908A, 0x97EDD871CFDA3A56,
-      0xBDE94E8E43D0C8EC, 0xED63A231D4C4FB27, 0x945E455F24FB1CF8, 0xB975D6B6EE39E436, 0xE7D34C64A9C85D44,
-      0x90E40FBEEA1D3A4A, 0xB51D13AEA4A488DD, 0xE264589A4DCDAB14, 0x8D7EB76070A08AEC, 0xB0DE65388CC8ADA8,
-      0xDD15FE86AFFAD912, 0x8A2DBF142DFCC7AB, 0xACB92ED9397BF996, 0xD7E77A8F87DAF7FB, 0x86F0AC99B4E8DAFD,
-      0xA8ACD7C0222311BC, 0xD2D80DB02AABD62B, 0x83C7088E1AAB65DB, 0xA4B8CAB1A1563F52, 0xCDE6FD5E09ABCF26,
-      0x80B05E5AC60B6178, 0xA0DC75F1778E39D6, 0xC913936DD571C84C, 0xFB5878494ACE3A5F, 0x9D174B2DCEC0E47B,
-      0xC45D1DF942711D9A, 0xF5746577930D6500, 0x9968BF6ABBE85F20, 0xBFC2EF456AE276E8, 0xEFB3AB16C59B14A2,
-      0x95D04AEE3B80ECE5, 0xBB445DA9CA61281F, 0xEA1575143CF97226, 0x924D692CA61BE758, 0xB6E0C377CFA2E12E,
-      0xE498F455C38B997A, 0x8EDF98B59A373FEC, 0xB2977EE300C50FE7, 0xDF3D5E9BC0F653E1, 0x8B865B215899F46C,
-      0xAE67F1E9AEC07187, 0xDA01EE641A708DE9, 0x884134FE908658B2, 0xAA51823E34A7EEDE, 0xD4E5E2CDC1D1EA96,
-      0x850FADC09923329E, 0xA6539930BF6BFF45, 0xCFE87F7CEF46FF16, 0x81F14FAE158C5F6E, 0xA26DA3999AEF7749,
-      0xCB090C8001AB551C, 0xFDCB4FA002162A63, 0x9E9F11C4014DDA7E, 0xC646D63501A1511D, 0xF7D88BC24209A565,
-      0x9AE757596946075F, 0xC1A12D2FC3978937, 0xF209787BB47D6B84, 0x9745EB4D50CE6332, 0xBD176620A501FBFF,
-      0xEC5D3FA8CE427AFF, 0x93BA47C980E98CDF, 0xB8A8D9BBE123F017, 0xE6D3102AD96CEC1D, 0x9043EA1AC7E41392,
-      0xB454E4A179DD1877, 0xE16A1DC9D8545E94, 0x8CE2529E2734BB1D, 0xB01AE745B101E9E4, 0xDC21A1171D42645D,
-      0x899504AE72497EBA, 0xABFA45DA0EDBDE69, 0xD6F8D7509292D603, 0x865B86925B9BC5C2, 0xA7F26836F282B732,
-      0xD1EF0244AF2364FF, 0x8335616AED761F1F, 0xA402B9C5A8D3A6E7, 0xCD036837130890A1, 0x802221226BE55A64,
-      0xA02AA96B06DEB0FD, 0xC83553C5C8965D3D, 0xFA42A8B73ABBF48C, 0x9C69A97284B578D7, 0xC38413CF25E2D70D,
-      0xF46518C2EF5B8CD1, 0x98BF2F79D5993802, 0xBEEEFB584AFF8603, 0xEEAABA2E5DBF6784, 0x952AB45CFA97A0B2,
-      0xBA756174393D88DF, 0xE912B9D1478CEB17, 0x91ABB422CCB812EE, 0xB616A12B7FE617AA, 0xE39C49765FDF9D94,
-      0x8E41ADE9FBEBC27D, 0xB1D219647AE6B31C, 0xDE469FBD99A05FE3, 0x8AEC23D680043BEE, 0xADA72CCC20054AE9,
-      0xD910F7FF28069DA4, 0x87AA9AFF79042286, 0xA99541BF57452B28, 0xD3FA922F2D1675F2, 0x847C9B5D7C2E09B7,
-      0xA59BC234DB398C25, 0xCF02B2C21207EF2E, 0x8161AFB94B44F57D, 0xA1BA1BA79E1632DC, 0xCA28A291859BBF93,
-      0xFCB2CB35E702AF78, 0x9DEFBF01B061ADAB, 0xC56BAEC21C7A1916, 0xF6C69A72A3989F5B, 0x9A3C2087A63F6399,
-      0xC0CB28A98FCF3C7F, 0xF0FDF2D3F3C30B9F, 0x969EB7C47859E743, 0xBC4665B596706114, 0xEB57FF22FC0C7959,
-      0x9316FF75DD87CBD8, 0xB7DCBF5354E9BECE, 0xE5D3EF282A242E81, 0x8FA475791A569D10, 0xB38D92D760EC4455,
-      0xE070F78D3927556A, 0x8C469AB843B89562, 0xAF58416654A6BABB, 0xDB2E51BFE9D0696A, 0x88FCF317F22241E2,
-      0xAB3C2FDDEEAAD25A, 0xD60B3BD56A5586F1, 0x85C7056562757456, 0xA738C6BEBB12D16C, 0xD106F86E69D785C7,
-      0x82A45B450226B39C, 0xA34D721642B06084, 0xCC20CE9BD35C78A5, 0xFF290242C83396CE, 0x9F79A169BD203E41,
-      0xC75809C42C684DD1, 0xF92E0C3537826145, 0x9BBCC7A142B17CCB, 0xC2ABF989935DDBFE, 0xF356F7EBF83552FE,
-      0x98165AF37B2153DE, 0xBE1BF1B059E9A8D6, 0xEDA2EE1C7064130C, 0x9485D4D1C63E8BE7, 0xB9A74A0637CE2EE1,
-      0xE8111C87C5C1BA99, 0x910AB1D4DB9914A0, 0xB54D5E4A127F59C8, 0xE2A0B5DC971F303A, 0x8DA471A9DE737E24,
-      0xB10D8E1456105DAD, 0xDD50F1996B947518, 0x8A5296FFE33CC92F, 0xACE73CBFDC0BFB7B, 0xD8210BEFD30EFA5A,
-      0x8714A775E3E95C78, 0xA8D9D1535CE3B396, 0xD31045A8341CA07C, 0x83EA2B892091E44D, 0xA4E4B66B68B65D60,
-      0xCE1DE40642E3F4B9, 0x80D2AE83E9CE78F3, 0xA1075A24E4421730, 0xC94930AE1D529CFC, 0xFB9B7CD9A4A7443C,
-      0x9D412E0806E88AA5, 0xC491798A08A2AD4E, 0xF5B5D7EC8ACB58A2, 0x9991A6F3D6BF1765, 0xBFF610B0CC6EDD3F,
-      0xEFF394DCFF8A948E, 0x95F83D0A1FB69CD9, 0xBB764C4CA7A4440F, 0xEA53DF5FD18D5513, 0x92746B9BE2F8552C,
-      0xB7118682DBB66A77, 0xE4D5E82392A40515, 0x8F05B1163BA6832D, 0xB2C71D5BCA9023F8, 0xDF78E4B2BD342CF6,
-      0x8BAB8EEFB6409C1A, 0xAE9672ABA3D0C320, 0xDA3C0F568CC4F3E8, 0x8865899617FB1871, 0xAA7EEBFB9DF9DE8D,
-      0xD51EA6FA85785631, 0x8533285C936B35DE, 0xA67FF273B8460356, 0xD01FEF10A657842C, 0x8213F56A67F6B29B,
-      0xA298F2C501F45F42, 0xCB3F2F7642717713, 0xFE0EFB53D30DD4D7, 0x9EC95D1463E8A506, 0xC67BB4597CE2CE48,
-      0xF81AA16FDC1B81DA, 0x9B10A4E5E9913128, 0xC1D4CE1F63F57D72, 0xF24A01A73CF2DCCF, 0x976E41088617CA01,
-      0xBD49D14AA79DBC82, 0xEC9C459D51852BA2, 0x93E1AB8252F33B45, 0xB8DA1662E7B00A17, 0xE7109BFBA19C0C9D,
-      0x906A617D450187E2, 0xB484F9DC9641E9DA, 0xE1A63853BBD26451, 0x8D07E33455637EB2, 0xB049DC016ABC5E5F,
-      0xDC5C5301C56B75F7, 0x89B9B3E11B6329BA, 0xAC2820D9623BF429, 0xD732290FBACAF133, 0x867F59A9D4BED6C0,
-      0xA81F301449EE8C70, 0xD226FC195C6A2F8C, 0x83585D8FD9C25DB7, 0xA42E74F3D032F525, 0xCD3A1230C43FB26F,
-      0x80444B5E7AA7CF85, 0xA0555E361951C366, 0xC86AB5C39FA63440, 0xFA856334878FC150, 0x9C935E00D4B9D8D2,
-      0xC3B8358109E84F07, 0xF4A642E14C6262C8, 0x98E7E9CCCFBD7DBD, 0xBF21E44003ACDD2C, 0xEEEA5D5004981478,
-      0x95527A5202DF0CCB, 0xBAA718E68396CFFD, 0xE950DF20247C83FD, 0x91D28B7416CDD27E, 0xB6472E511C81471D,
-      0xE3D8F9E563A198E5, 0x8E679C2F5E44FF8F, 0xB201833B35D63F73, 0xDE81E40A034BCF4F, 0x8B112E86420F6191,
-      0xADD57A27D29339F6, 0xD94AD8B1C7380874, 0x87CEC76F1C830548, 0xA9C2794AE3A3C69A, 0xD433179D9C8CB841,
-      0x849FEEC281D7F328, 0xA5C7EA73224DEFF3, 0xCF39E50FEAE16BEF, 0x81842F29F2CCE375, 0xA1E53AF46F801C53,
-      0xCA5E89B18B602368, 0xFCF62C1DEE382C42, 0x9E19DB92B4E31BA9};
-
-   inline constexpr uint64_t sig2_from_exp10(int32_t exp10) noexcept
-   {
-      return pow10_sig_table[exp10 - pow10_sig_table_min_exp];
-   }
-
-   inline constexpr int32_t exp2_from_exp10(int32_t exp10) noexcept
-   {
-      return (((exp10 * 217706 - 4128768) >> 16) + 126);
-   }
-
-   /*==============================================================================
-    * Digit Character Matcher
-    *============================================================================*/
-   // Digit type
-   using digi_type = uint8_t;
-   // Digit: '0'.
-   constexpr digi_type DIGI_TYPE_ZERO = 1 << 0;
-   // Digit: [1-9].
-   constexpr digi_type DIGI_TYPE_NONZERO = 1 << 1;
-   // Plus sign (positive): '+'.
-   constexpr digi_type DIGI_TYPE_POS = 1 << 2;
-   // Minus sign (negative): '-'.
-   constexpr digi_type DIGI_TYPE_NEG = 1 << 3;
-   // Decimal point: '.'
-   constexpr digi_type DIGI_TYPE_DOT = 1 << 4;
-   // Exponent sign: 'e, 'E'.
-   constexpr digi_type DIGI_TYPE_EXP = 1 << 5;
-   // Digit type table
-   constexpr std::array<digi_type, 256> digi_table = {
-      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-      0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x08, 0x10, 0x00, 0x01, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
-      0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
-   /** Match a character with specified type. */
-   inline bool digi_is_type(uint8_t d, digi_type type) noexcept { return (digi_table[d] & type) != 0; }
-   /** Match a floating point indicator: '.', 'e', 'E'. */
-   inline bool digi_is_fp(uint8_t d) noexcept { return digi_is_type(d, digi_type(DIGI_TYPE_DOT | DIGI_TYPE_EXP)); }
-   /** Match a digit or floating point indicator: [0-9], '.', 'e', 'E'. */
-   inline bool digi_is_digit_or_fp(uint8_t d) noexcept
-   {
-      return digi_is_type(d, digi_type(DIGI_TYPE_ZERO | DIGI_TYPE_NONZERO | DIGI_TYPE_DOT | DIGI_TYPE_EXP));
-   }
-/* Macros used for loop unrolling and other purpose. */
-#define repeat2(x) \
-   {               \
-      x x          \
-   }
-#define repeat3(x) \
-   {               \
-      x x x        \
-   }
-#define repeat4(x) \
-   {               \
-      x x x x      \
-   }
-#define repeat8(x)    \
-   {                  \
-      x x x x x x x x \
-   }
-#define repeat16(x)                   \
-   {                                  \
-      x x x x x x x x x x x x x x x x \
-   }
-#define repeat2_incr(x) \
-   {                    \
-      x(0) x(1)         \
-   }
-#define repeat4_incr(x)   \
-   {                      \
-      x(0) x(1) x(2) x(3) \
-   }
-#define repeat8_incr(x)                       \
-   {                                          \
-      x(0) x(1) x(2) x(3) x(4) x(5) x(6) x(7) \
-   }
-#define repeat16_incr(x)                                                                    \
-   {                                                                                        \
-      x(0) x(1) x(2) x(3) x(4) x(5) x(6) x(7) x(8) x(9) x(10) x(11) x(12) x(13) x(14) x(15) \
-   }
-#define repeat_in_1_18(x)                                                                                \
-   {                                                                                                     \
-      x(1) x(2) x(3) x(4) x(5) x(6) x(7) x(8) x(9) x(10) x(11) x(12) x(13) x(14) x(15) x(16) x(17) x(18) \
-   }
-   constexpr auto e_bit = static_cast<uint8_t>('E' ^ 'e');
-   /*==============================================================================
-    * IEEE-754 Double Number Constants
-    *============================================================================*/
-   // maximum decimal power of double number (1.7976931348623157e308)
-   constexpr auto F64_MAX_DEC_EXP = 308;
-   // minimum decimal power of double number (4.9406564584124654e-324)
-   constexpr auto F64_MIN_DEC_EXP = (-324);
-
-   consteval uint32_t ceillog2(uint32_t x) { return x < 2 ? x : 1 + ceillog2(x >> 1); }
-
-   struct bigint_t final
-   {
-      std::vector<uint32_t> data = {};
-      // To print: for (auto item : data) std::cout << std::bitset<32>(item) << '\n';
-
-      bigint_t(uint64_t num) noexcept
-      {
-         uint32_t lower_word = uint32_t(num);
-         uint32_t upper_word = uint32_t(num >> 32);
-         if (upper_word > 0) {
-            data = {lower_word, upper_word};
-         }
-         else {
-            data = {lower_word};
-         }
-      }
-
-      void mul_u32(uint32_t num) noexcept
-      {
-         uint32_t carry = 0;
-         for (std::size_t i = 0; i < data.size(); i++) {
-            uint64_t res = uint64_t(data[i]) * uint64_t(num) + uint64_t(carry);
-            uint32_t lower_word = uint32_t(res);
-            uint32_t upper_word = uint32_t(res >> 32);
-            data[i] = lower_word;
-            carry = upper_word;
-         }
-         if (carry != 0) {
-            data.emplace_back(carry);
-         }
-      }
-
-      void mul_pow10(uint32_t pow10) noexcept
-      {
-         for (; pow10 >= 9; pow10 -= 9) {
-            mul_u32(static_cast<uint32_t>(powers_of_ten_int[9]));
-         }
-         if (pow10) {
-            mul_u32(static_cast<uint32_t>(powers_of_ten_int[pow10]));
-         }
-      }
-
-      void mul_pow2(uint32_t exp) noexcept
-      {
-         uint32_t shft = exp % 32;
-         uint32_t move = exp / 32;
-         uint32_t idx = static_cast<uint32_t>(data.size()) - 1;
-         if (shft == 0) {
-            data.resize(data.size() + move);
-            for (; idx > 0; idx--) {
-               data[idx + move - 1] = data[idx - 1];
-            }
-            while (move) data[--move] = 0;
-         }
-         else {
-            data.resize(data.size() + move + 1);
-            ++idx;
-            for (; idx > 0; idx--) {
-               uint32_t num = data[idx] << shft;
-               num |= data[idx - 1] >> (32 - shft);
-               data[idx + move] = num;
-            }
-            data[move] = data[0] << shft;
-            if (data.back() == 0) data.pop_back();
-            while (move) data[--move] = 0;
-         }
-      }
-
-      auto operator<=>(const bigint_t& rhs) const noexcept
-      {
-         if (data.size() < rhs.data.size()) return -1;
-         if (data.size() > rhs.data.size()) return 1;
-         for (auto i = data.size() - 1; i > 0; --i) {
-            ;
-            if (data[i] < rhs.data[i]) return -1;
-            if (data[i] > rhs.data[i]) return 1;
-         }
-         return 0;
-      }
-   };
-
-   template <std::floating_point T, bool force_conformance = false>
-      requires(sizeof(T) <= 8)
-   inline bool parse_float(auto& val, const uint8_t*& cur) noexcept
-   {
-      constexpr auto is_volatile = std::is_volatile_v<std::remove_reference_t<decltype(val)>>;
-      const uint8_t* sig_cut = nullptr; /* significant part cutting position for long number */
-      [[maybe_unused]] const uint8_t* sig_end = nullptr; /* significant part ending position */
-      const uint8_t* dot_pos = nullptr; /* decimal point position */
-      uint32_t frac_zeros = 0;
-      uint64_t sig = 0; /* significant part of the number */
-      int32_t exp = 0; /* exponent part of the number */
-      bool exp_sign; /* temporary exponent sign from literal part */
-      int32_t exp_sig = 0; /* temporary exponent number from significant part */
-      int32_t exp_lit = 0; /* temporary exponent number from exponent literal part */
-      uint64_t num_tmp; /* temporary number for reading */
-      const uint8_t* tmp; /* temporary cursor for reading */
-      const uint8_t* hdr = cur;
-      bool sign = (*hdr == '-');
-      cur += sign;
-      auto apply_sign = [&](auto&& val) -> T { return sign ? -static_cast<T>(val) : static_cast<T>(val); };
-      /* begin with non-zero digit */
-      sig = uint64_t(*cur - '0');
-      if (sig > 9) {
-         if constexpr (std::integral<T>) {
-            return false;
-         }
-         else if (*cur == 'n' && cur[1] == 'u' && cur[2] == 'l' && cur[3] == 'l') {
-            cur += 4;
-            val = std::numeric_limits<T>::quiet_NaN();
-            return true;
-         }
-         else if ((*cur | e_bit) == 'n' && (cur[1] | e_bit) == 'a' && (cur[2] | e_bit) == 'n') {
-            cur += 3;
-            val = sign ? -std::numeric_limits<T>::quiet_NaN() : std::numeric_limits<T>::quiet_NaN();
-            return true;
-         }
-         else {
-            return false;
-         }
-      }
-      constexpr auto zero = static_cast<uint8_t>('0');
-#define expr_intg(i)                              \
-   if ((num_tmp = cur[i] - zero) <= 9) [[likely]] \
-      sig = num_tmp + sig * 10;                   \
-   else {                                         \
-      if constexpr (force_conformance && i > 1) { \
-         if (*cur == zero) return false;          \
-      }                                           \
-      goto digi_sepr_##i;                         \
-   }
-      repeat_in_1_18(expr_intg);
-#undef expr_intg
-      if (*cur == zero) [[unlikely]] {
-         return false;
-      }
-      cur += 19; /* skip continuous 19 digits */
-      if (!digi_is_digit_or_fp(*cur)) {
-         val = static_cast<T>(sig);
-         if constexpr (!std::is_unsigned_v<T>) {
-            if constexpr (is_volatile) {
-               val = val * (sign ? -1 : 1);
-            }
-            else {
-               val *= sign ? -1 : 1;
-            }
-         }
-         return true;
-      }
-      goto digi_intg_more; /* read more digits in integral part */
-      /* process first non-digit character */
-#define expr_sepr(i)                                           \
-   digi_sepr_##i : if ((!digi_is_fp(cur[i]))) [[likely]]       \
-   {                                                           \
-      cur += i;                                                \
-      val = apply_sign(sig);                                   \
-      return true;                                             \
-   }                                                           \
-   dot_pos = cur + i;                                          \
-   if ((cur[i] == '.')) [[likely]] {                           \
-      if (sig == 0)                                            \
-         while (cur[frac_zeros + i + 1] == zero) ++frac_zeros; \
-      goto digi_frac_##i;                                      \
-   }                                                           \
-   cur += i;                                                   \
-   sig_end = cur;                                              \
-   goto digi_exp_more;
-      repeat_in_1_18(expr_sepr)
-#undef expr_sepr
-      /* read fraction part */
-#define expr_frac(i)                                                                                              \
-   digi_frac_##i : if (((num_tmp = static_cast<uint64_t>(cur[i + 1 + frac_zeros] - zero)) <= 9)) [[likely]] sig = \
-                      num_tmp + sig * 10;                                                                         \
-   else                                                                                                           \
-   {                                                                                                              \
-      goto digi_stop_##i;                                                                                         \
-   }
-         repeat_in_1_18(expr_frac)
-#undef expr_frac
-            cur += 20 + frac_zeros; /* skip 19 digits and 1 decimal point */
-      if (uint8_t(*cur - zero) > 9) goto digi_frac_end; /* fraction part end */
-      goto digi_frac_more; /* read more digits in fraction part */
-      /* significant part end */
-#define expr_stop(i)                          \
-   digi_stop_##i : cur += i + 1 + frac_zeros; \
-   goto digi_frac_end;
-      repeat_in_1_18(expr_stop)
-#undef expr_stop
-         /* read more digits in integral part */
-         digi_intg_more : static constexpr uint64_t U64_MAX = (std::numeric_limits<uint64_t>::max)(); // todo
-      if ((num_tmp = *cur - zero) < 10) {
-         if (!digi_is_digit_or_fp(cur[1])) {
-            /* this number is an integer consisting of 20 digits */
-            if ((sig < (U64_MAX / 10)) || (sig == (U64_MAX / 10) && num_tmp <= (U64_MAX % 10))) {
-               sig = num_tmp + sig * 10;
-               ++cur;
-               val = static_cast<T>(sig);
-               if constexpr (!std::is_unsigned_v<T>) {
-                  if constexpr (is_volatile) {
-                     val = val * (sign ? -1 : 1);
-                  }
-                  else {
-                     val *= sign ? -1 : 1;
-                  }
-               }
-               return true;
-            }
-         }
-      }
-      if ((e_bit | *cur) == 'e') {
-         dot_pos = cur;
-         goto digi_exp_more;
-      }
-      if (*cur == '.') {
-         dot_pos = cur++;
-         if (uint8_t(*cur - zero) > 9) {
-            return false;
-         }
-      }
-      /* read more digits in fraction part */
-   digi_frac_more:
-      sig_cut = cur; /* too large to fit in u64, excess digits need to be cut */
-      sig += (*cur >= '5'); /* round */
-      while (uint8_t(*++cur - zero) < 10) {
-      }
-      if (!dot_pos) {
-         dot_pos = cur;
-         if (*cur == '.') {
-            if (uint8_t(*++cur - zero) > 9) {
-               return false;
-            }
-            while (uint8_t(*++cur - zero) < 10) {
-            }
-         }
-      }
-      exp_sig = static_cast<int32_t>(dot_pos - sig_cut);
-      exp_sig += (dot_pos < sig_cut);
-      // ignore trailing zeros
-      tmp = cur - 1;
-      while (*tmp == '0' || *tmp == '.') {
-         --tmp;
-      }
-      if (tmp < sig_cut) {
-         sig_cut = nullptr;
-      }
-      else {
-         sig_end = cur;
-      }
-      if ((e_bit | *cur) == 'e') goto digi_exp_more;
-      goto digi_exp_finish;
-      // fraction part end
-   digi_frac_end:
-      sig_end = cur;
-      exp_sig = -int32_t((cur - dot_pos) - 1);
-      if constexpr (force_conformance) {
-         if (exp_sig == 0) return false;
-      }
-      if ((e_bit | *cur) != 'e') [[likely]] {
-         if ((exp_sig < F64_MIN_DEC_EXP - 19)) [[unlikely]] {
-            val = apply_sign(0);
-            return true;
-         }
-         exp = exp_sig;
-         goto digi_finish;
-      }
-      else {
-         goto digi_exp_more;
-      }
-      // read exponent part
-   digi_exp_more:
-      exp_sign = (*++cur == '-');
-      cur += (*cur == '+' || *cur == '-');
-      if (uint8_t(*cur - zero) > 9) [[unlikely]] {
-         if constexpr (force_conformance) {
-            return false;
-         }
-         else {
-            goto digi_finish;
-         }
-      }
-      while (*cur == '0') {
-         ++cur;
-      }
-      // read exponent literal
-      tmp = cur;
-      uint8_t c;
-      while (uint8_t(c = *cur - zero) < 10) {
-         ++cur;
-         exp_lit = c + uint32_t(exp_lit) * 10;
-      }
-      // large exponent case
-      if ((cur - tmp >= 6)) [[unlikely]] {
-         if (sig == 0 || exp_sign) {
-            val = apply_sign(0);
-            val = static_cast<T>(sig);
-            return true;
-         }
-         else {
-            val = apply_sign(std::numeric_limits<T>::infinity());
-            return true;
-         }
-      }
-      exp_sig += exp_sign ? -exp_lit : exp_lit;
-      // validate exponent value
-   digi_exp_finish:
-      if (sig == 0) {
-         val = (sign ? -T{0} : T{0});
-         return true;
-      }
-      if ((exp_sig < F64_MIN_DEC_EXP - 19)) [[unlikely]] {
-         val = (sign ? -T{0} : T{0});
-         return true;
-      }
-      else if ((exp_sig > F64_MAX_DEC_EXP)) [[unlikely]] {
-         val = sign ? -std::numeric_limits<T>::infinity() : std::numeric_limits<T>::infinity();
-         return true;
-      }
-      exp = exp_sig;
-      // all digit read finished
-   digi_finish:
-
-      if constexpr (std::is_same_v<double, T>) {
-         // numbers must be exactly representable in this fast path
-         if (sig < (uint64_t(1) << 53) && std::abs(exp) <= 22) {
-            val = static_cast<T>(sig);
-            if constexpr (is_volatile) {
-               if constexpr (!std::is_unsigned_v<T>) {
-                  val = val * (sign ? -1 : 1);
-               }
-               if (exp >= 0) {
-                  val = val * powers_of_ten_float[exp];
-               }
-               else {
-                  val = val / powers_of_ten_float[-exp];
-               }
-            }
-            else {
-               if constexpr (!std::is_unsigned_v<T>) {
-                  val *= sign ? -1 : 1;
-               }
-               if (exp >= 0) {
-                  val *= powers_of_ten_float[exp];
-               }
-               else {
-                  val /= powers_of_ten_float[-exp];
-               }
-            }
-
-            return true;
-         }
-      }
-      else {
-         if (sig < (uint64_t(1) << 24) && std::abs(exp) <= 8) {
-            val = static_cast<T>(sig);
-            if constexpr (!std::is_unsigned_v<T>) {
-               val *= sign ? -1 : 1;
-            }
-            if (exp >= 0) {
-               val *= static_cast<T>(powers_of_ten_float[exp]);
-            }
-            else {
-               val /= static_cast<T>(powers_of_ten_float[-exp]);
-            }
-            return true;
-         }
-      }
-
-      if (sig == 0) [[unlikely]] // fast path is more likely for zeros (0.00000000000000000000000 is uncommon)
-      {
-         val = T(0);
-         return true;
-      }
-
-      static_assert(std::numeric_limits<T>::is_iec559);
-      static_assert(std::numeric_limits<T>::radix == 2);
-      static_assert(std::is_same_v<float, std::decay_t<T>> || std::is_same_v<double, std::decay_t<T>>);
-      static_assert(sizeof(float) == 4 && sizeof(double) == 8);
-
-      using Raw = std::conditional_t<std::is_same_v<float, std::decay_t<T>>, uint32_t, uint64_t>;
-      const auto sig_leading_zeros = std::countl_zero(sig);
-      const auto sig_norm = sig << sig_leading_zeros;
-      const auto sig2_norm = sig2_from_exp10(exp);
-      const auto sig_product = mulhi64(sig_norm, sig2_norm) + 1;
-      const auto sig_product_starts_with_1 = sig_product >> 63;
-      auto mantisa = sig_product << (2 - sig_product_starts_with_1);
-      constexpr uint64_t round_mask = uint64_t(1) << 63 >> (std::numeric_limits<T>::digits - 1);
-      constexpr uint32_t exponent_bits =
-         ceillog2(std::numeric_limits<T>::max_exponent - std::numeric_limits<T>::min_exponent + 1);
-      constexpr uint32_t mantisa_shift = exponent_bits + 1 + 64 - 8 * sizeof(Raw);
-      int32_t exp2 = exp2_from_exp10(exp) + static_cast<uint32_t>(-sig_leading_zeros + sig_product_starts_with_1);
-
-      if (exp2 < std::numeric_limits<T>::min_exponent - 1) [[unlikely]] {
-         // TODO handle subnormal numbers
-         val = sign ? -T(0) : T(0);
-         return true;
-      }
-      else if (exp2 > std::numeric_limits<T>::max_exponent - 1) [[unlikely]] {
-         val = sign ? -std::numeric_limits<T>::infinity() : std::numeric_limits<T>::infinity();
-         return true;
-      }
-
-      uint64_t round = 0;
-      if (round_mask & mantisa) {
-         if (mantisa << (std::numeric_limits<T>::digits) == 0) {
-            // We added one to the product so this is the case were the trailing bits were 1.
-            // This is a problem since the product could underestimate by a bit and uness there is a zero bit to fall
-            // into we cant be sure if we need to round or not
-            auto sig_upper = (mantisa >> (mantisa_shift - 1)) | (uint64_t(1) << 63 >> (mantisa_shift - 2)) | 1;
-            int32_t exp2_upper = exp2 - std::numeric_limits<T>::digits;
-
-            bigint_t big_comp{sig_upper};
-            bigint_t big_full{sig}; // Not dealing will ulp from sig_cut since we only care about roundtriping
-                                    // machine doubles and only a human would use so many sigfigs
-            if (exp >= 0) {
-               big_full.mul_pow10(exp);
-            }
-            else {
-               big_comp.mul_pow10(-exp);
-            }
-            if (exp2_upper >= 0) {
-               big_comp.mul_pow2(exp2_upper);
-            }
-            else {
-               big_full.mul_pow2(-exp2_upper);
-            }
-            auto cmp = big_full <=> big_comp;
-            if (cmp != 0) [[likely]] {
-               // round down or round up
-               round = (cmp > 0);
-            }
-            else {
-               // falls midway, round to even
-               round = (mantisa & (round_mask << 1)) != 0;
-            }
-         }
-         else if ((exp < pow10_sig_table_min_exact ||
-                   exp > pow10_sig_table_max_exact) // If there are ones after 64 bits in sig2 then there will be
-                                                    // ones after the rounding bit in the product
-                  ||
-                  (mantisa & (round_mask << 1)) // Odd nums need to round up regardless of if the rest is nonzero or not
-                  || (static_cast<size_t>(std::countr_zero(sig_norm) + std::countr_zero(sig2_norm)) <
-                      128 - std::numeric_limits<T>::digits -
-                         (2 - sig_product_starts_with_1)) // Check where the least significant one is
-         ) {
-            round = 1;
-         }
-      }
-
-      auto num = Raw(sign) << (sizeof(Raw) * 8 - 1) | Raw(mantisa >> mantisa_shift) |
-                 (Raw(exp2 + std::numeric_limits<T>::max_exponent - 1) << (std::numeric_limits<T>::digits - 1));
-      if constexpr (is_volatile) {
-         num = num + Raw(round);
-         val = std::bit_cast<T>(num);
-      }
-      else {
-         num += Raw(round);
-         std::memcpy(&val, &num, sizeof(T));
-      }
-      return true;
-   }
-
-   template <std::floating_point T, bool force_conformance = false>
-      requires(sizeof(T) <= 8)
-   inline bool parse_float(auto& val, auto& itr) noexcept
-   {
-      const uint8_t* cur = reinterpret_cast<const uint8_t*>(itr);
-      const uint8_t* beg = cur;
-      if (parse_float<T, force_conformance>(val, cur)) {
-         itr += (cur - beg);
-         return true;
-      }
-      return false;
-   }
-}
diff --git a/deps/saucer/include/glaze/util/tuple.hpp b/deps/saucer/include/glaze/util/tuple.hpp
index c0fc432..b56bee4 100644
--- a/deps/saucer/include/glaze/util/tuple.hpp
+++ b/deps/saucer/include/glaze/util/tuple.hpp
@@ -15,163 +15,10 @@ namespace glz
    template <class T>
    concept is_std_tuple = is_specialization_v<T, std::tuple>;
 
-   inline constexpr auto size_impl(auto&& t) { return glz::tuple_size_v<std::decay_t<decltype(t)>>; }
-
-   template <class T>
-   inline constexpr size_t size_v = glz::tuple_size_v<std::decay_t<T>>;
-
-   namespace detail
-   {
-      template <size_t Offset, class Tuple, std::size_t... Is>
-      auto tuple_split_impl(Tuple&& tuple, std::index_sequence<Is...>)
-      {
-         return std::make_tuple(std::get<Is * 2 + Offset>(tuple)...);
-      }
-   }
-
-   template <class Tuple, std::size_t... Is>
-   auto tuple_split(Tuple&& tuple)
-   {
-      static constexpr auto N = glz::tuple_size_v<Tuple>;
-      static constexpr auto is = std::make_index_sequence<N / 2>{};
-      return std::make_pair(detail::tuple_split_impl<0>(tuple, is), detail::tuple_split_impl<1>(tuple, is));
-   }
-
-   // group builder code
-   template <size_t N>
-   constexpr auto shrink_index_array(auto&& arr)
-   {
-      std::array<size_t, N> res{};
-      for (size_t i = 0; i < N; ++i) {
-         res[i] = arr[i];
-      }
-      return res;
-   }
-
+   // TODO: This doesn't appear to be used. Should it be removed?
    template <class Type>
    concept is_schema_class = requires {
       requires std::is_class_v<Type>;
       requires Type::schema_attributes;
    };
-
-   template <class Tuple>
-   constexpr auto filter()
-   {
-      constexpr auto N = glz::tuple_size_v<Tuple>;
-      std::array<uint64_t, N> indices{};
-      size_t i = 0;
-      for_each<N>([&](auto I) {
-         using V = std::decay_t<glz::tuple_element_t<I, Tuple>>;
-         if constexpr (std::is_member_pointer_v<V>) {
-            if constexpr (I == 0) {
-               indices[i++] = 0;
-            }
-            else if constexpr (std::convertible_to<glz::tuple_element_t<I - 1, Tuple>, std::string_view>) {
-               // If the previous element in the tuple is convertible to a std::string_view, then we treat it as the key
-               indices[i++] = I - 1;
-            }
-            else {
-               indices[i++] = I;
-            }
-         }
-         else if constexpr (std::is_enum_v<V>) {
-            if constexpr (I == 0) {
-               indices[i++] = 0;
-            }
-            else if constexpr (std::convertible_to<glz::tuple_element_t<I - 1, Tuple>, std::string_view>) {
-               // If the previous element in the tuple is convertible to a std::string_view, then we treat it as the key
-               indices[i++] = I - 1;
-            }
-            else {
-               indices[i++] = I;
-            }
-         }
-         else if constexpr (!(std::convertible_to<V, std::string_view> || is_schema_class<V> ||
-                              std::same_as<V, comment>)) {
-            indices[i++] = I - 1;
-         }
-      });
-      return std::make_pair(indices, i); // indices for groups and the number of groups
-   }
-
-   namespace detail
-   {
-      template <class Func, class Tuple, std::size_t... Is>
-      inline constexpr auto map_tuple(Func&& f, Tuple&& tuple, std::index_sequence<Is...>)
-      {
-         return tuplet::make_tuple(f(get<Is>(tuple))...);
-      }
-   }
-
-   template <class Func, class Tuple>
-   inline constexpr auto map_tuple(Func&& f, Tuple&& tuple)
-   {
-      constexpr auto N = glz::tuple_size_v<std::decay_t<Tuple>>;
-      return detail::map_tuple(f, tuple, std::make_index_sequence<N>{});
-   }
-
-   template <size_t n_groups>
-   constexpr auto group_sizes(const std::array<size_t, n_groups>& indices, size_t n_total)
-   {
-      std::array<size_t, n_groups> diffs;
-
-      for (size_t i = 0; i < n_groups - 1; ++i) {
-         diffs[i] = indices[i + 1] - indices[i];
-      }
-      diffs[n_groups - 1] = n_total - indices[n_groups - 1];
-      return diffs;
-   }
-
-   template <size_t Start, class Tuple, size_t... Is>
-   constexpr auto make_group(Tuple&& t, std::index_sequence<Is...>)
-   {
-      auto get_elem = [&](auto I) {
-         constexpr auto Index = Start + I;
-         using type = decltype(glz::get<Index>(t));
-         using T = std::decay_t<type>;
-         if constexpr (std::convertible_to<type, std::string_view>) {
-            return std::string_view(glz::get<Index>(t));
-         }
-         else if constexpr (std::same_as<T, comment>) {
-            return glz::get<Index>(t).value;
-         }
-         else {
-            return glz::get<Index>(t);
-         }
-      };
-      return glz::tuplet::tuple{get_elem(std::integral_constant<size_t, Is>{})...};
-   }
-
-   template <auto& GroupStartArr, auto& GroupSizeArr, class Tuple, size_t... GroupNumber>
-   constexpr auto make_groups_impl(Tuple&& t, std::index_sequence<GroupNumber...>)
-   {
-      return glz::tuplet::make_tuple(make_group<get<GroupNumber>(GroupStartArr)>(
-         t, std::make_index_sequence<std::get<GroupNumber>(GroupSizeArr)>{})...);
-   }
-
-   template <class Tuple>
-   constexpr auto make_groups_helper()
-   {
-      constexpr auto N = glz::tuple_size_v<Tuple>;
-
-      constexpr auto filtered = filter<Tuple>();
-      constexpr auto starts = shrink_index_array<filtered.second>(filtered.first);
-      constexpr auto sizes = group_sizes(starts, N);
-
-      return glz::tuplet::make_tuple(starts, sizes);
-   }
-
-   template <class Tuple>
-   struct group_builder
-   {
-      static constexpr auto h = make_groups_helper<Tuple>();
-      static constexpr auto starts = glz::get<0>(h);
-      static constexpr auto sizes = glz::get<1>(h);
-
-      static constexpr auto op(Tuple&& t)
-      {
-         constexpr auto n_groups = starts.size();
-         return make_groups_impl<starts, sizes>(std::forward<Tuple>(t), std::make_index_sequence<n_groups>{});
-      }
-   };
 }
diff --git a/deps/saucer/include/glaze/util/type_traits.hpp b/deps/saucer/include/glaze/util/type_traits.hpp
index 50ec62e..fbebe3d 100644
--- a/deps/saucer/include/glaze/util/type_traits.hpp
+++ b/deps/saucer/include/glaze/util/type_traits.hpp
@@ -137,12 +137,24 @@ namespace glz
       using type = std::tuple<Args...>;
    };
 
+   template <class ClassType, class Result, class... Args>
+   struct inputs_as_tuple<Result (ClassType::*)(Args...) noexcept>
+   {
+      using type = std::tuple<Args...>;
+   };
+
    template <class ClassType, class Result, class... Args>
    struct inputs_as_tuple<Result (ClassType::*)(Args...) const>
    {
       using type = std::tuple<Args...>;
    };
 
+   template <class ClassType, class Result, class... Args>
+   struct inputs_as_tuple<Result (ClassType::*)(Args...) const noexcept>
+   {
+      using type = std::tuple<Args...>;
+   };
+
    template <class T>
    struct parent_of_fn;
 
@@ -152,12 +164,24 @@ namespace glz
       using type = ClassType;
    };
 
+   template <class ClassType, class Result, class... Args>
+   struct parent_of_fn<Result (ClassType::*)(Args...) noexcept>
+   {
+      using type = ClassType;
+   };
+
    template <class ClassType, class Result, class... Args>
    struct parent_of_fn<Result (ClassType::*)(Args...) const>
    {
       using type = ClassType;
    };
 
+   template <class ClassType, class Result, class... Args>
+   struct parent_of_fn<Result (ClassType::*)(Args...) const noexcept>
+   {
+      using type = ClassType;
+   };
+
    template <auto MemPtr, class T>
    struct arguments;
 
@@ -177,6 +201,16 @@ namespace glz
       }
    };
 
+   template <auto MemPtr, class T, class R, class... Args>
+   struct arguments<MemPtr, R (T::*)(Args...) noexcept>
+   {
+      static constexpr auto op(void* ptr, Args&&... args)
+         -> std::invoke_result_t<decltype(std::mem_fn(MemPtr)), T, Args...>
+      {
+         return (reinterpret_cast<T*>(ptr)->*MemPtr)(std::forward<Args>(args)...);
+      }
+   };
+
    template <auto MemPtr, class T, class R, class... Args>
    struct arguments<MemPtr, R (T::*)(Args...) const>
    {
@@ -187,6 +221,16 @@ namespace glz
       }
    };
 
+   template <auto MemPtr, class T, class R, class... Args>
+   struct arguments<MemPtr, R (T::*)(Args...) const noexcept>
+   {
+      static constexpr auto op(void* ptr, Args&&... args)
+         -> std::invoke_result_t<decltype(std::mem_fn(MemPtr)), T, Args...>
+      {
+         return (reinterpret_cast<T*>(ptr)->*MemPtr)(std::forward<Args>(args)...);
+      }
+   };
+
    template <auto MemPtr>
    inline constexpr auto get_argument()
    {
@@ -211,6 +255,14 @@ namespace glz
       using object_type = T;
    };
 
+   template <class R, class T, class... Args>
+   struct invocable_traits<R (T::*)(Args...) const noexcept> : std::true_type
+   {
+      using result_type = R;
+      using arguments = std::tuple<Args...>;
+      using object_type = T;
+   };
+
    template <class R, class T, class... Args>
    struct invocable_traits<R (T::*)(Args...)> : std::true_type
    {
@@ -219,6 +271,14 @@ namespace glz
       using object_type = T;
    };
 
+   template <class R, class T, class... Args>
+   struct invocable_traits<R (T::*)(Args...) noexcept> : std::true_type
+   {
+      using result_type = R;
+      using arguments = std::tuple<Args...>;
+      using object_type = T;
+   };
+
    template <class T>
    using invocable_args_t = typename invocable_traits<decltype(&T::operator())>::arguments;
 
@@ -231,4 +291,30 @@ namespace glz
 
    template <class T>
    using decay_keep_volatile_t = std::remove_const_t<std::remove_reference_t<T>>;
+
+   template <class T>
+   concept is_memory_type = requires(T t) {
+      typename T::element_type;
+      *t;
+      bool(t);
+      t.reset();
+   };
+
+   namespace detail
+   {
+      template <class T>
+      struct memory_type_impl
+      {
+         using type = T;
+      };
+
+      template <is_memory_type T>
+      struct memory_type_impl<T>
+      {
+         using type = typename T::element_type;
+      };
+   }
+
+   template <class T>
+   using memory_type = typename detail::memory_type_impl<std::remove_cvref_t<T>>::type;
 }
diff --git a/deps/saucer/include/glaze/util/variant.hpp b/deps/saucer/include/glaze/util/variant.hpp
index 7c3d516..c51af87 100644
--- a/deps/saucer/include/glaze/util/variant.hpp
+++ b/deps/saucer/include/glaze/util/variant.hpp
@@ -4,11 +4,10 @@
 #pragma once
 
 #include <algorithm>
+#include <array>
 #include <cstddef>
 #include <variant>
 
-#include "glaze/util/for_each.hpp"
-#include "glaze/util/parse.hpp"
 #include "glaze/util/type_traits.hpp"
 
 namespace glz
@@ -16,15 +15,12 @@ namespace glz
    template <class T>
    concept is_variant = is_specialization_v<T, std::variant>;
 
-   namespace detail
+   template <is_variant T>
+   GLZ_ALWAYS_INLINE constexpr auto runtime_variant_map()
    {
-      template <is_variant T>
-      GLZ_ALWAYS_INLINE constexpr auto runtime_variant_map()
-      {
-         constexpr auto N = std::variant_size_v<T>;
-         return [&]<size_t... I>(std::index_sequence<I...>) {
-            return std::array<T, N>{std::variant_alternative_t<I, T>{}...};
-         }(std::make_index_sequence<N>{});
-      }
+      constexpr auto N = std::variant_size_v<T>;
+      return [&]<size_t... I>(std::index_sequence<I...>) {
+         return std::array<T, N>{std::variant_alternative_t<I, T>{}...};
+      }(std::make_index_sequence<N>{});
    }
 }
diff --git a/deps/saucer/include/glaze/version.hpp b/deps/saucer/include/glaze/version.hpp
new file mode 100644
index 0000000..7e830e5
--- /dev/null
+++ b/deps/saucer/include/glaze/version.hpp
@@ -0,0 +1,36 @@
+// Glaze Library
+// For the license information refer to glaze.hpp
+
+#pragma once
+
+#include <cstdint>
+
+namespace glz
+{
+   /**
+    * @struct version_t
+    * @brief Represents the version of the Glaze Library
+    *
+    * Provides version information and comparison operators to check version compatibility.
+    */
+   struct version_t
+   {
+      uint8_t major = 5;
+      uint8_t minor = 5;
+      uint8_t patch = 4;
+
+      constexpr auto operator<=>(const version_t& other) const noexcept = default;
+
+      // In C++23, this is optional when we have a custom <=> operator,
+      // but included for clarity
+      constexpr bool operator==(const version_t& other) const noexcept = default;
+   };
+
+   /**
+    * @var version
+    * @brief Global constant instance of the current library version
+    *
+    * Provides access to the current version of the Glaze Library.
+    */
+   inline constexpr version_t version{};
+}
diff --git a/src/client/component/iidx/custom_resolution.cpp b/src/client/component/iidx/custom_resolution.cpp
index 55a1402..b4237c7 100644
--- a/src/client/component/iidx/custom_resolution.cpp
+++ b/src/client/component/iidx/custom_resolution.cpp
@@ -2,6 +2,7 @@
 #include "loader/component_loader.hpp"
 
 #include "d3d9_proxy/interface_ex.hpp"
+#include "wasapi_proxy/mmdevice_enumerator.hpp"
 
 #include "custom_resolution.hpp"
 
@@ -150,6 +151,25 @@ namespace iidx::custom_resolution
 
 			return SetWindowPos(hWnd, hWndInsertAfter, X, Y, cx, cy, uFlags);
 		}
+
+		HRESULT WINAPI co_create_instance(REFCLSID rclsid, LPUNKNOWN pUnkOuter, DWORD dwClsContext, REFIID riid, LPVOID* ppv) 
+		{
+			if (IsEqualCLSID(rclsid, __uuidof(MMDeviceEnumerator)) && IsEqualIID(riid, __uuidof(IMMDeviceEnumerator)))
+			{
+				IMMDeviceEnumerator* enumerator = nullptr;
+				auto hr = CoCreateInstance(rclsid, pUnkOuter, dwClsContext, riid, ppv);
+				if (SUCCEEDED(hr))
+				{
+					enumerator = reinterpret_cast<IMMDeviceEnumerator*>(*ppv);
+					*ppv = new mmdevice_enumerator_proxy(enumerator);
+				}
+				return hr;
+			}
+			else
+			{
+				return CoCreateInstance(rclsid, pUnkOuter, dwClsContext, riid, ppv);
+			}
+		}
 	}
 
 	class component final : public component_interface
@@ -174,6 +194,10 @@ namespace iidx::custom_resolution
 			{
 				return set_window_pos;
 			}
+			else if(function == "CoCreateInstance")
+			{
+				return co_create_instance;
+			}
 
 			return nullptr;
 		}
diff --git a/src/client/component/iidx/wasapi_proxy/audio_client.cpp b/src/client/component/iidx/wasapi_proxy/audio_client.cpp
new file mode 100644
index 0000000..b1ad8ce
--- /dev/null
+++ b/src/client/component/iidx/wasapi_proxy/audio_client.cpp
@@ -0,0 +1,129 @@
+#include <std_include.hpp>
+#include <utils/nt.hpp>
+#include "audio_client.hpp"
+
+audio_client_proxy::audio_client_proxy(IAudioClient* orig) : client_(orig)
+{
+}
+
+HRESULT __stdcall audio_client_proxy::QueryInterface(REFIID riid, void** ppvObj)
+{
+	*ppvObj = nullptr;
+
+	auto hr = client_->QueryInterface(riid, ppvObj);
+	if (hr == NOERROR) *ppvObj = this;
+
+	return hr;
+}
+
+ULONG __stdcall audio_client_proxy::AddRef(void)
+{
+	return client_->AddRef();
+}
+
+ULONG __stdcall audio_client_proxy::Release(void)
+{
+	auto count = client_->Release();
+
+	if (!count)
+	{
+		delete this;
+	}
+
+	return count;
+}
+
+HRESULT __stdcall audio_client_proxy::Initialize__(AUDCLNT_SHAREMODE ShareMode, DWORD StreamFlags, REFERENCE_TIME hnsBufferDuration, REFERENCE_TIME hnsPeriodicity, const WAVEFORMATEX* pFormat, LPCGUID AudioSessionGuid)
+{
+	static const bool can_set_lowlatency_mode = [] {
+		utils::nt::library ntdll{ "ntdll.dll" };
+
+		OSVERSIONINFOEXW info;
+		ntdll.invoke_pascal<NTSTATUS>("RtlGetVersion", &info);
+
+		return info.dwMajorVersion >= 10;
+		}();
+	if (ShareMode != AUDCLNT_SHAREMODE_SHARED || !can_set_lowlatency_mode) return -1;
+	auto INVALID_STREAM_FLAGS = AUDCLNT_STREAMFLAGS_CROSSPROCESS | AUDCLNT_STREAMFLAGS_LOOPBACK | AUDCLNT_STREAMFLAGS_NOPERSIST | AUDCLNT_STREAMFLAGS_RATEADJUST | AUDCLNT_STREAMFLAGS_AUTOCONVERTPCM | AUDCLNT_STREAMFLAGS_SRC_DEFAULT_QUALITY;
+	StreamFlags &= ~INVALID_STREAM_FLAGS;
+	IAudioClient3* client3 = nullptr;
+	UINT32 defaultPeriodInFrames;
+	UINT32 fundamentalPeriodInFrames;
+	UINT32 minPeriodInFrames;
+	UINT32 maxPeriodInFrames;
+	auto hr = client_->QueryInterface(__uuidof(IAudioClient3), reinterpret_cast<void**>(&client3));
+	if (FAILED(hr)) return hr;
+	hr = client3->GetSharedModeEnginePeriod(pFormat, &defaultPeriodInFrames, &fundamentalPeriodInFrames, &minPeriodInFrames, &maxPeriodInFrames);
+	if (FAILED(hr)) return hr;
+	hr = client3->InitializeSharedAudioStream(StreamFlags, minPeriodInFrames, pFormat, AudioSessionGuid);
+	client3->Release();
+	return hr;
+}
+
+HRESULT __stdcall audio_client_proxy::Initialize(AUDCLNT_SHAREMODE ShareMode, DWORD StreamFlags, REFERENCE_TIME hnsBufferDuration, REFERENCE_TIME hnsPeriodicity, const WAVEFORMATEX* pFormat, LPCGUID AudioSessionGuid)
+{
+	auto hr = audio_client_proxy::Initialize__(ShareMode, StreamFlags, hnsBufferDuration, hnsPeriodicity, pFormat, AudioSessionGuid);
+	if (SUCCEEDED(hr))
+	{
+		return hr;
+	}
+	else
+	{
+		return client_->Initialize(ShareMode, StreamFlags, hnsBufferDuration, hnsPeriodicity, pFormat, AudioSessionGuid);
+	}
+}
+
+HRESULT __stdcall audio_client_proxy::GetBufferSize(UINT32* pNumBufferFrames)
+{
+	return client_->GetBufferSize(pNumBufferFrames);
+}
+
+HRESULT __stdcall audio_client_proxy::GetStreamLatency(REFERENCE_TIME* phnsLatency) 
+{
+	return client_->GetStreamLatency(phnsLatency);
+}
+
+HRESULT __stdcall audio_client_proxy::GetCurrentPadding(UINT32* pNumPaddingFrames)
+{
+	return client_->GetCurrentPadding(pNumPaddingFrames);
+}
+
+HRESULT __stdcall audio_client_proxy::IsFormatSupported(AUDCLNT_SHAREMODE ShareMode, const WAVEFORMATEX* pFormat, WAVEFORMATEX** ppClosestMatch)
+{
+	return client_->IsFormatSupported(ShareMode, pFormat, ppClosestMatch);
+}
+
+HRESULT __stdcall audio_client_proxy::GetMixFormat(WAVEFORMATEX** ppDeviceFormat) 
+{
+	return client_->GetMixFormat(ppDeviceFormat);
+}
+
+HRESULT __stdcall audio_client_proxy::GetDevicePeriod(REFERENCE_TIME* phnsDefaultDevicePeriod, REFERENCE_TIME* phnsMinimumDevicePeriod)
+{
+	return client_->GetDevicePeriod(phnsDefaultDevicePeriod, phnsMinimumDevicePeriod);
+}
+
+HRESULT __stdcall audio_client_proxy::Start(void) 
+{
+	return client_->Start();
+}
+
+HRESULT __stdcall audio_client_proxy::Stop(void) 
+{
+	return client_->Stop();
+}
+
+HRESULT __stdcall audio_client_proxy::Reset(void) 
+{
+	return client_->Reset();
+}
+
+HRESULT __stdcall audio_client_proxy::SetEventHandle(HANDLE eventHandle)
+{
+	return client_->SetEventHandle(eventHandle);
+}
+
+HRESULT __stdcall audio_client_proxy::GetService(REFIID riid, void** ppv) 
+{
+	return client_->GetService(riid, ppv);
+}
\ No newline at end of file
diff --git a/src/client/component/iidx/wasapi_proxy/audio_client.hpp b/src/client/component/iidx/wasapi_proxy/audio_client.hpp
new file mode 100644
index 0000000..fa99d43
--- /dev/null
+++ b/src/client/component/iidx/wasapi_proxy/audio_client.hpp
@@ -0,0 +1,27 @@
+#pragma once
+
+class audio_client_proxy : public IAudioClient
+{
+public:
+	audio_client_proxy(IAudioClient* orig);
+
+private:
+	IAudioClient* client_;
+	HRESULT __stdcall Initialize__(AUDCLNT_SHAREMODE ShareMode, DWORD StreamFlags, REFERENCE_TIME hnsBufferDuration, REFERENCE_TIME hnsPeriodicity, const WAVEFORMATEX* pFormat, LPCGUID AudioSessionGuid);
+public:
+	virtual HRESULT __stdcall QueryInterface(REFIID riid, void** ppvObj) override;
+	virtual ULONG __stdcall AddRef(void) override;
+	virtual ULONG __stdcall Release(void) override;
+	virtual HRESULT __stdcall Initialize(AUDCLNT_SHAREMODE ShareMode, DWORD StreamFlags, REFERENCE_TIME hnsBufferDuration, REFERENCE_TIME hnsPeriodicity, const WAVEFORMATEX* pFormat, LPCGUID AudioSessionGuid) override;
+	virtual HRESULT __stdcall GetBufferSize(UINT32* pNumBufferFrames) override;
+	virtual HRESULT __stdcall GetStreamLatency(REFERENCE_TIME* phnsLatency) override;
+	virtual HRESULT __stdcall GetCurrentPadding(UINT32* pNumPaddingFrames) override;
+	virtual HRESULT __stdcall IsFormatSupported(AUDCLNT_SHAREMODE ShareMode, const WAVEFORMATEX* pFormat, WAVEFORMATEX** ppClosestMatch) override;
+	virtual HRESULT __stdcall GetMixFormat(WAVEFORMATEX** ppDeviceFormat) override;
+	virtual HRESULT __stdcall GetDevicePeriod(REFERENCE_TIME* phnsDefaultDevicePeriod, REFERENCE_TIME* phnsMinimumDevicePeriod) override;
+	virtual HRESULT __stdcall Start(void) override;
+	virtual HRESULT __stdcall Stop(void) override;
+	virtual HRESULT __stdcall Reset(void) override;
+	virtual HRESULT __stdcall SetEventHandle(HANDLE eventHandle) override;
+	virtual HRESULT __stdcall GetService(REFIID riid, void** ppv) override;
+};
\ No newline at end of file
diff --git a/src/client/component/iidx/wasapi_proxy/mmdevice.cpp b/src/client/component/iidx/wasapi_proxy/mmdevice.cpp
new file mode 100644
index 0000000..f0a9e1f
--- /dev/null
+++ b/src/client/component/iidx/wasapi_proxy/mmdevice.cpp
@@ -0,0 +1,59 @@
+#include <std_include.hpp>
+#include "mmdevice.hpp"
+#include "audio_client.hpp"
+
+mmdevice_proxy::mmdevice_proxy(IMMDevice* orig) : device_(orig)
+{
+}
+
+HRESULT __stdcall mmdevice_proxy::QueryInterface(REFIID riid, void** ppvObj)
+{
+	*ppvObj = nullptr;
+
+	auto hr = device_->QueryInterface(riid, ppvObj);
+	if (hr == NOERROR) *ppvObj = this;
+
+	return hr;
+}
+
+ULONG __stdcall mmdevice_proxy::AddRef(void)
+{
+	return device_->AddRef();
+}
+
+ULONG __stdcall mmdevice_proxy::Release(void)
+{
+	auto count = device_->Release();
+
+	if (!count)
+	{
+		delete this;
+	}
+
+	return count;
+}
+
+HRESULT __stdcall mmdevice_proxy::Activate(REFIID iid, DWORD dwClsCtx, PROPVARIANT* pActivationParams, void** ppInterface) 
+{
+	auto hr = device_->Activate(iid, dwClsCtx, pActivationParams, ppInterface);
+	if (SUCCEEDED(hr) && IsEqualIID(iid, __uuidof(IAudioClient)))
+	{
+		*ppInterface = new audio_client_proxy(reinterpret_cast<IAudioClient*>(*ppInterface));
+	}
+	return hr;
+}
+
+HRESULT __stdcall mmdevice_proxy::OpenPropertyStore(DWORD stgmAccess, IPropertyStore** ppProperties) 
+{
+	return device_->OpenPropertyStore(stgmAccess, ppProperties);
+}
+
+HRESULT __stdcall mmdevice_proxy::GetId(LPWSTR* ppstrId) 
+{
+	return device_->GetId(ppstrId);
+}
+
+HRESULT __stdcall mmdevice_proxy::GetState(DWORD* pdwState) 
+{
+	return device_->GetState(pdwState);
+}
\ No newline at end of file
diff --git a/src/client/component/iidx/wasapi_proxy/mmdevice.hpp b/src/client/component/iidx/wasapi_proxy/mmdevice.hpp
new file mode 100644
index 0000000..990d39f
--- /dev/null
+++ b/src/client/component/iidx/wasapi_proxy/mmdevice.hpp
@@ -0,0 +1,18 @@
+#pragma once
+
+class mmdevice_proxy : public IMMDevice
+{
+public:
+	mmdevice_proxy(IMMDevice* orig);
+
+private:
+	IMMDevice* device_;
+public:
+	virtual HRESULT __stdcall QueryInterface(REFIID riid, void** ppvObj) override;
+	virtual ULONG __stdcall AddRef(void) override;
+	virtual ULONG __stdcall Release(void) override;
+	virtual HRESULT __stdcall Activate(REFIID iid, DWORD dwClsCtx, PROPVARIANT* pActivationParams, void** ppInterface) override;
+	virtual HRESULT __stdcall OpenPropertyStore(DWORD stgmAccess, IPropertyStore** ppProperties) override;
+	virtual HRESULT __stdcall GetId(LPWSTR* ppstrId) override;
+	virtual HRESULT __stdcall GetState(DWORD* pdwState) override;
+};
\ No newline at end of file
diff --git a/src/client/component/iidx/wasapi_proxy/mmdevice_collection.cpp b/src/client/component/iidx/wasapi_proxy/mmdevice_collection.cpp
new file mode 100644
index 0000000..3c47032
--- /dev/null
+++ b/src/client/component/iidx/wasapi_proxy/mmdevice_collection.cpp
@@ -0,0 +1,48 @@
+#include <std_include.hpp>
+#include "mmdevice_collection.hpp"
+#include "mmdevice.hpp"
+
+mmdevice_collection_proxy::mmdevice_collection_proxy(IMMDeviceCollection* orig) : collection_(orig)
+{
+}
+
+HRESULT __stdcall mmdevice_collection_proxy::QueryInterface(REFIID riid, void** ppvObj)
+{
+	*ppvObj = nullptr;
+
+	auto hr = collection_->QueryInterface(riid, ppvObj);
+	if (hr == NOERROR) *ppvObj = this;
+
+	return hr;
+}
+
+ULONG __stdcall mmdevice_collection_proxy::AddRef(void)
+{
+	return collection_->AddRef();
+}
+
+ULONG __stdcall mmdevice_collection_proxy::Release(void)
+{
+	auto count = collection_->Release();
+
+	if (!count)
+	{
+		delete this;
+	}
+
+	return count;
+}
+
+HRESULT __stdcall mmdevice_collection_proxy::GetCount(UINT* pcDevices)
+{
+	return collection_->GetCount(pcDevices);
+}
+HRESULT __stdcall mmdevice_collection_proxy::Item(UINT nDevice, IMMDevice** ppDevice)
+{
+	auto hr = collection_->Item(nDevice, ppDevice);
+	if (SUCCEEDED(hr))
+	{
+		*ppDevice = new mmdevice_proxy(*ppDevice);
+	}
+	return hr;
+}
\ No newline at end of file
diff --git a/src/client/component/iidx/wasapi_proxy/mmdevice_collection.hpp b/src/client/component/iidx/wasapi_proxy/mmdevice_collection.hpp
new file mode 100644
index 0000000..b7696c2
--- /dev/null
+++ b/src/client/component/iidx/wasapi_proxy/mmdevice_collection.hpp
@@ -0,0 +1,16 @@
+#pragma once
+
+class mmdevice_collection_proxy : public IMMDeviceCollection
+{
+public:
+	mmdevice_collection_proxy(IMMDeviceCollection* orig);
+
+private:
+	IMMDeviceCollection* collection_;
+public:
+	virtual HRESULT __stdcall QueryInterface(REFIID riid, void** ppvObj) override;
+	virtual ULONG __stdcall AddRef(void) override;
+	virtual ULONG __stdcall Release(void) override;
+	virtual HRESULT __stdcall GetCount(UINT* pcDevices) override;
+	virtual HRESULT __stdcall Item(UINT nDevice, IMMDevice** ppDevice) override;
+};
diff --git a/src/client/component/iidx/wasapi_proxy/mmdevice_enumerator.cpp b/src/client/component/iidx/wasapi_proxy/mmdevice_enumerator.cpp
new file mode 100644
index 0000000..f5d4e41
--- /dev/null
+++ b/src/client/component/iidx/wasapi_proxy/mmdevice_enumerator.cpp
@@ -0,0 +1,75 @@
+#include <std_include.hpp>
+#include "mmdevice_enumerator.hpp"
+#include "mmdevice_collection.hpp"
+#include "mmdevice.hpp"
+
+mmdevice_enumerator_proxy::mmdevice_enumerator_proxy(IMMDeviceEnumerator* orig) : enumerator_(orig)
+{
+}
+
+HRESULT __stdcall mmdevice_enumerator_proxy::QueryInterface(REFIID riid, void** ppvObj)
+{
+	*ppvObj = nullptr;
+
+	auto hr = enumerator_->QueryInterface(riid, ppvObj);
+	if (hr == NOERROR) *ppvObj = this;
+
+	return hr;
+}
+
+ULONG __stdcall mmdevice_enumerator_proxy::AddRef(void)
+{
+	return enumerator_->AddRef();
+}
+
+ULONG __stdcall mmdevice_enumerator_proxy::Release(void)
+{
+	auto count = enumerator_->Release();
+
+	if (!count)
+	{
+		delete this;
+	}
+
+	return count;
+}
+
+HRESULT __stdcall mmdevice_enumerator_proxy::EnumAudioEndpoints(EDataFlow dataFlow, DWORD dwStateMask, IMMDeviceCollection** ppDevices)
+{
+	auto hr = enumerator_->EnumAudioEndpoints(dataFlow, dwStateMask, ppDevices);
+	if (SUCCEEDED(hr))
+	{
+		*ppDevices = new mmdevice_collection_proxy(*ppDevices);
+	}
+	return hr;
+}
+
+HRESULT __stdcall mmdevice_enumerator_proxy::GetDefaultAudioEndpoint(EDataFlow dataFlow, ERole role, IMMDevice** ppEndpoint)
+{
+	auto hr = enumerator_->GetDefaultAudioEndpoint(dataFlow, role, ppEndpoint);
+	if (SUCCEEDED(hr))
+	{
+		*ppEndpoint = new mmdevice_proxy(*ppEndpoint);
+	}
+	return hr;
+}
+
+HRESULT __stdcall mmdevice_enumerator_proxy::GetDevice(LPCWSTR pwstrId, IMMDevice** ppDevice)
+{
+	auto hr = enumerator_->GetDevice(pwstrId, ppDevice);
+	if (SUCCEEDED(hr))
+	{
+		*ppDevice = new mmdevice_proxy(*ppDevice);
+	}
+	return hr;
+}
+
+HRESULT __stdcall mmdevice_enumerator_proxy::RegisterEndpointNotificationCallback(IMMNotificationClient* pClient)
+{
+	return enumerator_->RegisterEndpointNotificationCallback(pClient);
+}
+
+HRESULT __stdcall mmdevice_enumerator_proxy::UnregisterEndpointNotificationCallback(IMMNotificationClient* pClient)
+{
+	return enumerator_->UnregisterEndpointNotificationCallback(pClient);
+}
\ No newline at end of file
diff --git a/src/client/component/iidx/wasapi_proxy/mmdevice_enumerator.hpp b/src/client/component/iidx/wasapi_proxy/mmdevice_enumerator.hpp
new file mode 100644
index 0000000..f210613
--- /dev/null
+++ b/src/client/component/iidx/wasapi_proxy/mmdevice_enumerator.hpp
@@ -0,0 +1,19 @@
+#pragma once
+
+class mmdevice_enumerator_proxy : public IMMDeviceEnumerator
+{
+public:
+	mmdevice_enumerator_proxy(IMMDeviceEnumerator* orig);
+
+private:
+	IMMDeviceEnumerator* enumerator_;
+public:
+	virtual HRESULT __stdcall QueryInterface(REFIID riid, void** ppvObj) override;
+	virtual ULONG __stdcall AddRef(void) override;
+	virtual ULONG __stdcall Release(void) override;
+	virtual HRESULT __stdcall EnumAudioEndpoints(EDataFlow dataFlow, DWORD dwStateMask, IMMDeviceCollection** ppDevices) override;
+	virtual HRESULT __stdcall GetDefaultAudioEndpoint(EDataFlow dataFlow, ERole role, IMMDevice** ppEndpoint) override;
+	virtual HRESULT __stdcall GetDevice(LPCWSTR pwstrId, IMMDevice** ppDevice) override;
+	virtual HRESULT __stdcall RegisterEndpointNotificationCallback(IMMNotificationClient* pClient) override;
+	virtual HRESULT __stdcall UnregisterEndpointNotificationCallback(IMMNotificationClient* pClient) override;
+};
diff --git a/src/client/main.cpp b/src/client/main.cpp
index 5fcc608..d48887b 100644
--- a/src/client/main.cpp
+++ b/src/client/main.cpp
@@ -180,7 +180,7 @@ static void set_qos_mode(bool high)
 
 	SetProcessInformation(self, ProcessPowerThrottling, &priority_info, sizeof(PROCESS_POWER_THROTTLING_STATE));
 	SetProcessInformation(self, ProcessMemoryPriority, &power_state, sizeof(MEMORY_PRIORITY_INFORMATION));
-	SetPriorityClass(self, IDLE_PRIORITY_CLASS);
+	SetPriorityClass(self, high ? HIGH_PRIORITY_CLASS : IDLE_PRIORITY_CLASS);
 }
 
 int main()
diff --git a/src/client/std_include.hpp b/src/client/std_include.hpp
index ccf3bcc..f07e140 100644
--- a/src/client/std_include.hpp
+++ b/src/client/std_include.hpp
@@ -50,6 +50,8 @@
 #include <d3d9.h>
 #include <d3d9on12.h>
 #include <d3d12.h>
+#include <mmdeviceapi.h>
+#include <Audioclient.h>
 #include <dwmapi.h>
 
 // min and max is required by gdi, therefore NOMINMAX won't work