diff --git a/src/core/include/battery/application.hpp b/src/core/include/battery/application.hpp
index 83aa1380..8cc2a38c 100644
--- a/src/core/include/battery/application.hpp
+++ b/src/core/include/battery/application.hpp
@@ -8,6 +8,7 @@
 #include "eventbus.hpp"
 #include "events.hpp"
 #include "renderer.hpp"
+#include <optional>
 
 extern std::unique_ptr<b::Application> CreateApp();
 
diff --git a/src/core/include/battery/thread.hpp b/src/core/include/battery/thread.hpp
index 967c4c75..b3a8dd37 100644
--- a/src/core/include/battery/thread.hpp
+++ b/src/core/include/battery/thread.hpp
@@ -140,11 +140,11 @@ namespace b {
           : std::jthread([func = std::forward<Fn>(func), ...args = std::forward<Args>(args), this]() mutable {
                 m_waitRunningPromise.set_value();
                 if constexpr (std::is_invocable_v<std::decay_t<Fn>, std::stop_token, std::decay_t<Args>...>) {
-                    if (!catchCommonExceptions(std::move(func), get_stop_token(), std::move(args)...)) {
+                    if (!CatchCommonExceptions(std::move(func), get_stop_token(), std::move(args)...)) {
                         closeApplicationIfExists();
                     }
                 } else {
-                    if (!catchCommonExceptions(std::move(func), std::move(args)...)) {
+                    if (!CatchCommonExceptions(std::move(func), std::move(args)...)) {
                         closeApplicationIfExists();
                     }
                 }
diff --git a/src/core/include/glaze/api/impl.hpp b/src/core/include/glaze/api/impl.hpp
index 53386f93..44b95c19 100644
--- a/src/core/include/glaze/api/impl.hpp
+++ b/src/core/include/glaze/api/impl.hpp
@@ -91,8 +91,9 @@ namespace glz
       }
 
       template <class Arg_tuple, class F, class Parent, size_t... Is>
-         requires std::invocable<F, Parent, ref_t<std::tuple_element_t<Is, Arg_tuple>>...> decltype(auto)
-      call_args(F&& f, Parent&& parent, [[maybe_unused]] std::span<void*> args, std::index_sequence<Is...>)
+         requires std::invocable<F, Parent, ref_t<std::tuple_element_t<Is, Arg_tuple>>...>
+      decltype(auto) call_args(F&& f, Parent&& parent, [[maybe_unused]] std::span<void*> args,
+                               std::index_sequence<Is...>)
       {
          return f(parent, to_ref<std::tuple_element_t<Is, Arg_tuple>>(args[Is])...);
       }
@@ -245,8 +246,8 @@ namespace glz
                            static constexpr auto h = glz::hash<F>();
                            if (h == type_hash) [[likely]] {
                               auto* f = new F{};
-                              *f = [parent = &parent, val = &val](auto&&... args) -> decltype(auto) {
-                                 return ((*parent).*(*val))(std::forward<decltype(args)>(args)...);
+                              *f = [=, parent = &parent](auto&&... args) -> decltype(auto) {
+                                 return ((*parent).*(val))(std::forward<decltype(args)>(args)...);
                               };
                               result = std::unique_ptr<void, void (*)(void*)>{
                                  f, [](void* ptr) { delete static_cast<F*>(ptr); }};
diff --git a/src/core/include/glaze/api/lib.hpp b/src/core/include/glaze/api/lib.hpp
index ca97d3e4..55c833c2 100644
--- a/src/core/include/glaze/api/lib.hpp
+++ b/src/core/include/glaze/api/lib.hpp
@@ -29,7 +29,7 @@
 #include <dlfcn.h>
 #define SHARED_LIBRARY_EXTENSION ".dylib"
 #define SHARED_LIBRARY_PREFIX "lib"
-#elif __linux__
+#elif __has_include(<dlfcn.h>)
 #include <dlfcn.h>
 #define SHARED_LIBRARY_EXTENSION ".so"
 #define SHARED_LIBRARY_PREFIX "lib"
diff --git a/src/core/include/glaze/binary/read.hpp b/src/core/include/glaze/binary/read.hpp
index 509845e6..a1338a04 100644
--- a/src/core/include/glaze/binary/read.hpp
+++ b/src/core/include/glaze/binary/read.hpp
@@ -8,6 +8,7 @@
 #include "glaze/core/format.hpp"
 #include "glaze/core/read.hpp"
 #include "glaze/file/file_ops.hpp"
+#include "glaze/reflection/reflect.hpp"
 #include "glaze/util/dump.hpp"
 
 namespace glz
@@ -19,11 +20,10 @@ namespace glz
       {};
 
       template <auto Opts, class T, class Ctx, class It0, class It1>
-      concept read_binary_invocable =
-         requires(T&& value, Ctx&& ctx, It0&& it, It1&& end) {
-            from_binary<std::remove_cvref_t<T>>::template op<Opts>(std::forward<T>(value), std::forward<Ctx>(ctx),
-                                                                   std::forward<It0>(it), std::forward<It1>(end));
-         };
+      concept read_binary_invocable = requires(T&& value, Ctx&& ctx, It0&& it, It1&& end) {
+         from_binary<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 <>
       struct read<binary>
@@ -65,6 +65,37 @@ namespace glz
          }
       };
 
+      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;
+
+            const auto n = int_from_compressed(it, end);
+
+            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>
       {
@@ -90,9 +121,9 @@ namespace glz
             std::advance(it, Length);
 
             for_each<N>([&](auto I) {
-               static constexpr auto item = glz::tuplet::get<I>(meta_v<T>);
+               static constexpr auto item = glz::get<I>(meta_v<T>);
 
-               get_member(value, glz::tuplet::get<1>(item)) = data[I / 8] & (uint8_t{1} << (7 - (I % 8)));
+               get_member(value, glz::get<1>(item)) = data[I / 8] & (uint8_t{1} << (7 - (I % 8)));
             });
          }
       };
@@ -122,7 +153,7 @@ namespace glz
 
                ++it;
 
-               using V = std::decay_t<T>;
+               using V = std::decay_t<decltype(value)>;
                std::memcpy(&value, &(*it), sizeof(V));
                std::advance(it, sizeof(V));
             }
@@ -182,7 +213,7 @@ namespace glz
                return;
             }
 
-            value = tag >> 3;
+            value = tag >> 4;
             ++it;
          }
       };
@@ -272,6 +303,115 @@ namespace glz
          }
       };
 
+      // for set types
+      template <class T>
+         requires(readable_array_t<T> && !emplace_backable<T> && !resizeable<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(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(it, end);
+
+               value.clear();
+
+               for (size_t i = 0; i < n; ++i) {
+                  V x;
+                  std::memcpy(&x, &*it, sizeof(V));
+                  std::advance(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(it, end);
+
+               value.clear();
+
+               for (size_t i = 0; i < n; ++i) {
+                  const auto length = int_from_compressed(it, end);
+                  V str;
+                  str.resize(length);
+                  std::memcpy(str.data(), &*it, length);
+                  std::advance(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(it, end);
+
+               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
       {
@@ -553,19 +693,67 @@ namespace glz
          }
       };
 
-      template <class T>
-      struct from_binary<includer<T>>
+      template <is_includer T>
+      struct from_binary<T>
       {
          template <auto Opts>
-         GLZ_ALWAYS_INLINE static void op(auto&&, is_context auto&&, auto&&, auto&&) noexcept
-         {}
+         GLZ_ALWAYS_INLINE static void op(auto&&, is_context auto&& ctx, auto&& it, auto&& end) noexcept
+         {
+            if constexpr (Opts.no_header) {
+               std::ignore = int_from_compressed(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;
+
+               std::ignore = int_from_compressed(it, end);
+            }
+         }
       };
 
       template <class T>
-         requires glaze_object_t<T>
+         requires glaze_object_t<T> || reflectable<T>
       struct from_binary<T> final
       {
          template <auto Opts>
+            requires(Opts.structs_as_arrays == true)
+         GLZ_FLATTEN 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>;
+               static constexpr auto N = std::tuple_size_v<meta_t<V>>;
+               skip_compressed_int(it, end);
+
+               for_each<N>([&](auto I) {
+                  static constexpr auto item = get<I>(meta_v<V>);
+                  using T0 = std::decay_t<decltype(get<0>(item))>;
+                  static constexpr bool use_reflection = std::is_member_object_pointer_v<T0>;
+                  static 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)
          GLZ_FLATTEN static void op(auto&& value, is_context auto&& ctx, auto&& it, auto&& end) noexcept
          {
             constexpr uint8_t type = 0; // string key
@@ -581,7 +769,17 @@ namespace glz
 
             const auto n_keys = int_from_compressed(it, end);
 
-            static constexpr auto storage = detail::make_map<T, Opts.use_hash_comparison>();
+            decltype(auto) storage = [&] {
+               if constexpr (reflectable<T>) {
+                  static constinit auto cmap = make_map<T, Opts.use_hash_comparison>();
+                  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) {
                const auto length = int_from_compressed(it, end);
@@ -590,9 +788,7 @@ namespace glz
 
                std::advance(it, length);
 
-               const auto& p = storage.find(key);
-
-               if (p != storage.end()) [[likely]] {
+               if (const auto& p = storage.find(key); p != storage.end()) [[likely]] {
                   std::visit(
                      [&](auto&& member_ptr) { read<binary>::op<Opts>(get_member(value, member_ptr), ctx, it, end); },
                      p->second);
@@ -633,9 +829,8 @@ namespace glz
             skip_compressed_int(it, end);
 
             using V = std::decay_t<T>;
-            for_each<std::tuple_size_v<meta_t<V>>>([&](auto I) {
-               read<binary>::op<Opts>(get_member(value, glz::tuplet::get<I>(meta_v<V>)), ctx, it, end);
-            });
+            for_each<std::tuple_size_v<meta_t<V>>>(
+               [&](auto I) { read<binary>::op<Opts>(get_member(value, glz::get<I>(meta_v<V>)), ctx, it, end); });
          }
       };
 
@@ -678,7 +873,7 @@ namespace glz
       return value;
    }
 
-   template <class T>
+   template <opts Opts = opts{}, class T>
    [[nodiscard]] inline parse_error read_file_binary(T& value, const sv file_name, auto&& buffer) noexcept
    {
       context ctx{};
@@ -690,6 +885,31 @@ namespace glz
          return parse_error{file_error};
       }
 
-      return read<opts{.format = binary}>(value, buffer, ctx);
+      return read<set_binary<Opts>()>(value, buffer, ctx);
+   }
+
+   template <class T, class Buffer>
+   [[nodiscard]] inline parse_error 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 <class T, class Buffer>
+   [[nodiscard]] inline expected<T, parse_error> 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{}, class T>
+   [[nodiscard]] inline parse_error 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/src/core/include/glaze/binary/write.hpp b/src/core/include/glaze/binary/write.hpp
index e8c10843..ac2eea96 100644
--- a/src/core/include/glaze/binary/write.hpp
+++ b/src/core/include/glaze/binary/write.hpp
@@ -11,17 +11,22 @@
 #include "glaze/json/json_ptr.hpp"
 #include "glaze/util/dump.hpp"
 #include "glaze/util/for_each.hpp"
-#include "glaze/util/murmur.hpp"
 #include "glaze/util/variant.hpp"
 
 namespace glz
 {
    namespace detail
    {
-      template <class... Args>
-      GLZ_ALWAYS_INLINE void dump_type(auto&& value, Args&&... args) noexcept
+      GLZ_ALWAYS_INLINE void dump_type(auto&& value, auto&& b, auto&& ix) noexcept
       {
-         dump(std::as_bytes(std::span{&value, 1}), std::forward<Args>(args)...);
+         assert(ix <= b.size());
+         constexpr auto n = sizeof(std::decay_t<decltype(value)>);
+         if (ix + n > b.size()) [[unlikely]] {
+            b.resize((std::max)(b.size() * 2, ix + n));
+         }
+
+         std::memcpy(b.data() + ix, &value, n);
+         ix += n;
       }
 
       template <uint64_t i, class... Args>
@@ -77,11 +82,10 @@ namespace glz
       {};
 
       template <auto Opts, class T, class Ctx, class B, class IX>
-      concept write_binary_invocable =
-         requires(T&& value, Ctx&& ctx, B&& b, IX&& ix) {
-            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));
-         };
+      concept write_binary_invocable = requires(T&& value, Ctx&& ctx, B&& b, IX&& ix) {
+         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 <>
       struct write<binary>
@@ -117,6 +121,32 @@ namespace glz
          }
       };
 
+      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...);
+            dump(std::as_bytes(std::span{bytes}), args...);
+         }
+      };
+
       template <glaze_flags_t T>
       struct to_binary<T>
       {
@@ -128,9 +158,9 @@ namespace glz
             std::array<uint8_t, byte_length<T>()> data{};
 
             for_each<N>([&](auto I) {
-               static constexpr auto item = glz::tuplet::get<I>(meta_v<T>);
+               static constexpr auto item = glz::get<I>(meta_v<T>);
 
-               data[I / 8] |= static_cast<uint8_t>(get_member(value, glz::tuplet::get<1>(item))) << (7 - (I % 8));
+               data[I / 8] |= static_cast<uint8_t>(get_member(value, glz::get<1>(item))) << (7 - (I % 8));
             });
 
             dump(data, b, ix);
@@ -145,12 +175,18 @@ namespace glz
          {}
       };
 
-      template <class T>
-      struct to_binary<includer<T>>
+      // // 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&&...) noexcept
-         {}
+         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>
@@ -181,19 +217,28 @@ namespace glz
          }
       };
 
+      template <class T, class V, size_t... Is>
+      constexpr std::size_t variant_index_impl(std::index_sequence<Is...>)
+      {
+         return ((std::is_same_v<T, std::variant_alternative_t<Is, V>> * Is) + ...);
+      }
+
+      template <class T, class V>
+      constexpr size_t variant_index_v = variant_index_impl<T, V>(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 auto index = []() {
-                     T var = V{};
-                     return var.index();
-                  }();
+
+                  static constexpr uint64_t index = variant_index_v<V, Variant>;
 
                   constexpr uint8_t tag = tag::extensions | 0b00001'000;
 
@@ -256,20 +301,36 @@ namespace glz
       struct to_binary<T> final
       {
          template <auto Opts>
-         GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&&, auto&&... args) noexcept
+         GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&&, auto&& b, auto&& ix) noexcept
          {
             constexpr uint8_t tag = tag::string;
 
-            dump_type(tag, args...);
-            dump_compressed_int<Opts>(value.size(), args...);
-            dump(std::as_bytes(std::span{value.data(), value.size()}), args...);
+            dump_type(tag, b, ix);
+            const auto n = value.size();
+            dump_compressed_int<Opts>(n, b, ix);
+
+            assert(ix <= b.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 <auto Opts>
-         GLZ_ALWAYS_INLINE static void no_header(auto&& value, is_context auto&&, auto&&... args) noexcept
+         GLZ_ALWAYS_INLINE static void no_header(auto&& value, is_context auto&&, auto&& b, auto&& ix) noexcept
          {
-            dump_compressed_int<Opts>(value.size(), args...);
-            dump(std::as_bytes(std::span{value.data(), value.size()}), args...);
+            dump_compressed_int<Opts>(value.size(), b, ix);
+
+            assert(ix <= b.size());
+            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;
          }
       };
 
@@ -291,14 +352,14 @@ namespace glz
                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 - 1; ++byte_i) {
+                  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 {
+               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{};
@@ -308,6 +369,9 @@ namespace glz
                      dump_type(byte, args...);
                   }
                }
+               else {
+                  static_assert(false_v<T>);
+               }
             }
             else if constexpr (num_t<V>) {
                constexpr uint8_t type =
@@ -317,7 +381,18 @@ namespace glz
                dump_compressed_int<Opts>(value.size(), args...);
 
                if constexpr (contiguous<T>) {
-                  dump(std::as_bytes(std::span{value.data(), static_cast<size_t>(value.size())}), args...);
+                  auto dump_array = [&](auto&& b, auto&& ix) {
+                     assert(ix <= b.size());
+                     const auto n = value.size() * sizeof(V);
+                     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;
+                  };
+
+                  dump_array(args...);
                }
                else {
                   for (auto& x : value) {
@@ -334,7 +409,19 @@ namespace glz
 
                for (auto& x : value) {
                   dump_compressed_int<Opts>(x.size(), args...);
-                  dump(std::as_bytes(std::span{x.data(), x.size()}), args...);
+
+                  auto dump_array = [&](auto&& b, auto&& ix) {
+                     assert(ix <= b.size());
+                     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>) {
@@ -390,7 +477,7 @@ namespace glz
       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
+         GLZ_FLATTEN static auto op(auto&& value, is_context auto&& ctx, Args&&... args) noexcept
          {
             using Key = typename T::key_type;
 
@@ -423,25 +510,99 @@ namespace glz
       };
 
       template <class T>
-         requires glaze_object_t<T>
+         requires is_specialization_v<T, glz::obj> || is_specialization_v<T, glz::obj_copy>
+      struct to_binary<T>
+      {
+         template <auto Opts>
+         GLZ_FLATTEN static void op(auto&& value, is_context auto&& ctx, auto&&... args) noexcept
+         {
+            constexpr uint8_t type = 0; // string key
+            constexpr uint8_t tag = tag::object | type;
+            dump_type(tag, args...);
+
+            using V = std::decay_t<decltype(value.value)>;
+            static constexpr auto N = std::tuple_size_v<V> / 2;
+            dump_compressed_int<N>(args...);
+
+            for_each<N>([&](auto I) {
+               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 glaze_object_t<T> || reflectable<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
+            requires(Opts.structs_as_arrays == true)
+         GLZ_FLATTEN static void op(auto&& value, is_context auto&& ctx, Args&&... args) noexcept
+         {
+            if constexpr (reflectable<T>) {
+               const auto t = to_tuple(value);
+               write<binary>::op<Opts>(t, ctx, args...);
+            }
+            else {
+               dump<std::byte(tag::generic_array)>(args...);
+
+               using V = std::decay_t<T>;
+               static constexpr auto N = std::tuple_size_v<meta_t<V>>;
+               dump_compressed_int<N>(args...);
+
+               for_each<N>([&](auto I) {
+                  static constexpr auto item = get<I>(meta_v<V>);
+                  using T0 = std::decay_t<decltype(get<0>(item))>;
+                  static constexpr bool use_reflection = std::is_member_object_pointer_v<T0>;
+                  static constexpr auto member_index = use_reflection ? 0 : 1;
+                  write<binary>::op<Opts>(get_member(value, get<member_index>(item)), ctx, args...);
+               });
+            }
+         }
+
+         template <auto Opts, class... Args>
+            requires(Opts.structs_as_arrays == false)
+         GLZ_FLATTEN static void op(auto&& value, is_context auto&& ctx, Args&&... args) noexcept
          {
             constexpr uint8_t type = 0; // string key
             constexpr uint8_t tag = tag::object | type;
             dump_type(tag, args...);
 
             using V = std::decay_t<T>;
-            static constexpr auto N = std::tuple_size_v<meta_t<V>>;
+            static constexpr auto N = [] {
+               if constexpr (reflectable<T>) {
+                  return count_members<T>;
+               }
+               else {
+                  return std::tuple_size_v<meta_t<V>>;
+               }
+            }();
+
             dump_compressed_int<N>(args...);
 
-            for_each<N>([&](auto I) {
-               static constexpr auto item = glz::tuplet::get<I>(meta_v<V>);
-               write<binary>::no_header<Opts>(glz::tuplet::get<0>(item), ctx, args...);
-               write<binary>::op<Opts>(get_member(value, glz::tuplet::get<1>(item)), ctx, args...);
-            });
+            if constexpr (reflectable<T>) {
+               static constexpr auto members = member_names<T>;
+               const auto t = to_tuple(value);
+               for_each<N>([&](auto I) {
+                  write<binary>::no_header<Opts>(get<I>(members), ctx, args...);
+                  write<binary>::op<Opts>(std::get<I>(t), ctx, args...);
+               });
+            }
+            else {
+               for_each<N>([&](auto I) {
+                  static constexpr auto item = get<I>(meta_v<V>);
+                  using T0 = std::decay_t<decltype(get<0>(item))>;
+                  static constexpr bool use_reflection = std::is_member_object_pointer_v<T0>;
+                  static constexpr auto member_index = use_reflection ? 0 : 1;
+                  if constexpr (use_reflection) {
+                     write<binary>::no_header<Opts>(get_name<get<0>(item)>(), ctx, args...);
+                  }
+                  else {
+                     write<binary>::no_header<Opts>(get<0>(item), ctx, args...);
+                  }
+                  write<binary>::op<Opts>(get_member(value, get<member_index>(item)), ctx, args...);
+               });
+            }
          }
       };
 
@@ -458,9 +619,8 @@ namespace glz
             dump_compressed_int<N>(args...);
 
             using V = std::decay_t<T>;
-            for_each<std::tuple_size_v<meta_t<V>>>([&](auto I) {
-               write<binary>::op<Opts>(get_member(value, glz::tuplet::get<I>(meta_v<V>)), ctx, args...);
-            });
+            for_each<std::tuple_size_v<meta_t<V>>>(
+               [&](auto I) { write<binary>::op<Opts>(get_member(value, glz::get<I>(meta_v<V>)), ctx, args...); });
          }
       };
 
@@ -483,16 +643,16 @@ namespace glz
    }
 
    template <class T, class Buffer>
-   inline void write_binary(T&& value, Buffer&& buffer)
+   inline void write_binary(T&& value, Buffer&& buffer) noexcept
    {
       write<opts{.format = binary}>(std::forward<T>(value), std::forward<Buffer>(buffer));
    }
 
-   template <class T>
-   inline auto write_binary(T&& value)
+   template <opts Opts = opts{}, class T>
+   inline auto write_binary(T&& value) noexcept
    {
       std::string buffer{};
-      write<opts{.format = binary}>(std::forward<T>(value), buffer);
+      write<set_binary<Opts>()>(std::forward<T>(value), buffer);
       return buffer;
    }
 
@@ -523,7 +683,7 @@ namespace glz
 
          if constexpr (detail::glaze_object_t<std::decay_t<T>>) {
             for_each<N>([&](auto I) {
-               static constexpr auto group = glz::tuplet::get<I>(groups);
+               static constexpr auto group = glz::get<I>(groups);
 
                static constexpr auto key = std::get<0>(group);
                static constexpr auto sub_partial = std::get<1>(group);
@@ -539,7 +699,7 @@ namespace glz
          }
          else if constexpr (detail::writable_map_t<std::decay_t<T>>) {
             for_each<N>([&](auto I) {
-               static constexpr auto group = glz::tuplet::get<I>(groups);
+               static constexpr auto group = glz::get<I>(groups);
 
                static constexpr auto key_value = std::get<0>(group);
                static constexpr auto sub_partial = std::get<1>(group);
@@ -590,16 +750,18 @@ namespace glz
    }
 
    template <auto& Partial, class T, class Buffer>
-   inline auto write_binary(T&& value, Buffer&& buffer)
+   inline auto write_binary(T&& value, Buffer&& buffer) noexcept
    {
       return write<Partial, opts{.format = binary}>(std::forward<T>(value), std::forward<Buffer>(buffer));
    }
 
    // std::string file_name needed for std::ofstream
-   template <class T>
+   template <opts Opts = opts{}, class T>
    [[nodiscard]] inline write_error write_file_binary(T&& value, const std::string& file_name, auto&& buffer) noexcept
    {
-      write<opts{.format = binary}>(std::forward<T>(value), buffer);
+      static_assert(sizeof(decltype(*buffer.data())) == 1);
+
+      write<set_binary<Opts>()>(std::forward<T>(value), buffer);
 
       std::ofstream file(file_name, std::ios::binary);
 
@@ -612,4 +774,25 @@ namespace glz
 
       return {};
    }
+
+   template <class T, class Buffer>
+   inline void write_binary_untagged(T&& value, Buffer&& buffer) noexcept
+   {
+      write<opts{.format = binary, .structs_as_arrays = true}>(std::forward<T>(value), std::forward<Buffer>(buffer));
+   }
+
+   template <class T>
+   inline auto write_binary_untagged(T&& value) noexcept
+   {
+      std::string buffer{};
+      write<opts{.format = binary, .structs_as_arrays = true}>(std::forward<T>(value), buffer);
+      return buffer;
+   }
+
+   template <opts Opts = opts{}, class T>
+   [[nodiscard]] inline write_error 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/src/core/include/glaze/compare/approx.hpp b/src/core/include/glaze/compare/approx.hpp
new file mode 100644
index 00000000..5ea8434a
--- /dev/null
+++ b/src/core/include/glaze/compare/approx.hpp
@@ -0,0 +1,38 @@
+// Glaze Library
+// For the license information refer to glaze.hpp
+
+#pragma once
+
+#include "glaze/core/common.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>
+      constexpr bool operator()(T&& lhs, T&& rhs) noexcept
+      {
+         constexpr auto N = std::tuple_size_v<meta_t<T>>;
+
+         bool equal = true;
+         for_each<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>)));
+            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) {
+                  equal = false;
+               }
+            }
+            else {
+               if (l != r) {
+                  equal = false;
+               }
+            }
+         });
+
+         return equal;
+      }
+   };
+}
diff --git a/src/core/include/glaze/compare/compare.hpp b/src/core/include/glaze/compare/compare.hpp
new file mode 100644
index 00000000..028c63d8
--- /dev/null
+++ b/src/core/include/glaze/compare/compare.hpp
@@ -0,0 +1,116 @@
+// Glaze Library
+// For the license information refer to glaze.hpp
+
+#pragma once
+
+#include <functional>
+
+#include "glaze/core/common.hpp"
+
+namespace glz
+{
+   struct equal_to final
+   {
+      template <detail::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 = std::tuple_size_v<meta_t<T>>;
+
+            bool equal = true;
+            for_each<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>)));
+               if (!std::equal_to{}(l, r)) {
+                  equal = false;
+               }
+            });
+
+            return equal;
+         }
+      }
+   };
+
+   struct less final
+   {
+      template <detail::glaze_object_t T>
+      constexpr bool operator()(T&& lhs, T&& rhs) noexcept
+      {
+         constexpr auto N = std::tuple_size_v<meta_t<T>>;
+
+         bool less_than = true;
+         for_each<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>)));
+            if (!std::less{}(l, r)) {
+               less_than = false;
+            }
+         });
+
+         return less_than;
+      }
+   };
+
+   struct less_equal final
+   {
+      template <detail::glaze_object_t T>
+      constexpr bool operator()(T&& lhs, T&& rhs) noexcept
+      {
+         constexpr auto N = std::tuple_size_v<meta_t<T>>;
+
+         bool less_than = true;
+         for_each<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>)));
+            if (!std::less_equal{}(l, r)) {
+               less_than = false;
+            }
+         });
+
+         return less_than;
+      }
+   };
+
+   struct greater final
+   {
+      template <detail::glaze_object_t T>
+      constexpr bool operator()(T&& lhs, T&& rhs) noexcept
+      {
+         constexpr auto N = std::tuple_size_v<meta_t<T>>;
+
+         bool greater_than = true;
+         for_each<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>)));
+            if (!std::greater{}(l, r)) {
+               greater_than = false;
+            }
+         });
+
+         return greater_than;
+      }
+   };
+
+   struct greater_equal final
+   {
+      template <detail::glaze_object_t T>
+      constexpr bool operator()(T&& lhs, T&& rhs) noexcept
+      {
+         constexpr auto N = std::tuple_size_v<meta_t<T>>;
+
+         bool greater_than = true;
+         for_each<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>)));
+            if (!std::greater_equal{}(l, r)) {
+               greater_than = false;
+            }
+         });
+
+         return greater_than;
+      }
+   };
+}
diff --git a/src/core/include/glaze/core/common.hpp b/src/core/include/glaze/core/common.hpp
index 06677598..5289fb7d 100644
--- a/src/core/include/glaze/core/common.hpp
+++ b/src/core/include/glaze/core/common.hpp
@@ -19,10 +19,8 @@
 #include "glaze/core/meta.hpp"
 #include "glaze/util/bit_array.hpp"
 #include "glaze/util/expected.hpp"
-#include "glaze/util/fixed_string.hpp"
 #include "glaze/util/for_each.hpp"
 #include "glaze/util/hash_map.hpp"
-#include "glaze/util/murmur.hpp"
 #include "glaze/util/string_view.hpp"
 #include "glaze/util/tuple.hpp"
 #include "glaze/util/type_traits.hpp"
@@ -50,6 +48,7 @@ namespace glz
    struct obj final
    {
       glz::tuplet::tuple<std::conditional_t<std::is_convertible_v<std::decay_t<T>, sv>, sv, T>...> value;
+      static constexpr auto glaze_reflect = false;
    };
 
    template <class... T>
@@ -59,6 +58,7 @@ namespace glz
    struct obj_copy final
    {
       glz::tuplet::tuple<T...> value;
+      static constexpr auto glaze_reflect = false;
    };
 
    template <class... T>
@@ -68,6 +68,7 @@ namespace glz
    struct arr final
    {
       glz::tuplet::tuple<std::conditional_t<std::is_convertible_v<std::decay_t<T>, sv>, sv, T>...> value;
+      static constexpr auto glaze_reflect = false;
    };
 
    template <class... T>
@@ -87,6 +88,7 @@ namespace glz
    struct merge final
    {
       glz::tuplet::tuple<std::conditional_t<std::is_convertible_v<std::decay_t<T>, sv>, sv, T>...> value;
+      static constexpr auto glaze_reflect = false;
    };
 
    template <class... T>
@@ -126,6 +128,9 @@ namespace glz
    struct includer
    {
       T& value;
+
+      static constexpr auto glaze_includer = true;
+      static constexpr auto glaze_reflect = false;
    };
 
    template <class T>
@@ -135,17 +140,27 @@ namespace glz
    };
 
    // Register this with an object to allow file including (direct writes) to the meta object
-   struct file_include
+   struct file_include final
    {
-      constexpr decltype(auto) operator()(auto&& value) const { return includer<std::decay_t<decltype(value)>>{value}; }
+      bool reflection_helper{}; // needed for count_members
+      static constexpr auto glaze_includer = true;
+      static constexpr auto glaze_reflect = false;
+
+      constexpr decltype(auto) operator()(auto&& value) const noexcept
+      {
+         return includer<std::decay_t<decltype(value)>>{value};
+      }
    };
 
+   template <class T>
+   concept is_includer = requires(T t) { requires T::glaze_includer == true; };
+
    template <class T>
    concept range = requires(T& t) {
-                      requires !std::same_as<void, decltype(t.begin())>;
-                      requires !std::same_as<void, decltype(t.end())>;
-                      requires std::input_iterator<decltype(t.begin())>;
-                   };
+      requires !std::same_as<void, decltype(t.begin())>;
+      requires !std::same_as<void, decltype(t.end())>;
+      requires std::input_iterator<decltype(t.begin())>;
+   };
 
    // range like
    template <class T>
@@ -155,26 +170,30 @@ namespace glz
    using range_value_t = std::iter_value_t<iterator_t<R>>;
 
    template <range R>
-   [[nodiscard]] bool empty_range(const R& rng)
+   [[nodiscard]] constexpr bool empty_range(R&& rng)
    {
+#ifdef __cpp_lib_ranges
+      return std::ranges::empty(rng);
+#else
       // in lieu of std::ranges::empty
       if constexpr (requires() {
                        {
                           rng.empty()
-                          } -> std::convertible_to<bool>;
+                       } -> std::convertible_to<bool>;
                     }) {
          return rng.empty();
       }
       else if constexpr (requires() {
                             {
                                rng.size()
-                               } -> std::same_as<std::size_t>;
+                            } -> std::same_as<std::size_t>;
                          }) {
-         return rng.size() == 0;
+         return rng.size() == std::size_t{0};
       }
       else {
          return std::cbegin(rng) == std::cend(rng);
       }
+#endif
    }
 
    template <class T>
@@ -292,36 +311,35 @@ namespace glz
          std::same_as<std::decay_t<T>, bool> || std::same_as<std::decay_t<T>, std::vector<bool>::reference>;
 
       template <class T>
-      concept int_t = std::integral<std::decay_t<T>> && !
-      char_t<std::decay_t<T>> && !bool_t<T>;
+      concept int_t = std::integral<std::decay_t<T>> && !char_t<std::decay_t<T>> && !bool_t<T>;
 
       template <class T>
       concept num_t = std::floating_point<std::decay_t<T>> || int_t<T>;
 
       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 constructible = requires { meta<std::decay_t<T>>::construct; } || local_construct_t<std::decay_t<T>>;
@@ -330,16 +348,17 @@ namespace glz
       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>;
+      concept str_t = !std::same_as<std::nullptr_t, T> && std::convertible_to<std::decay_t<T>, std::string_view>;
 
       template <class T>
       concept has_push_back = requires(T t, typename T::value_type v) { t.push_back(v); };
 
+      template <class T>
+      concept has_reserve = requires(T t) { t.reserve(size_t(1)); };
+
       // 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>;
+      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>>>;
@@ -350,39 +369,39 @@ namespace glz
 
       template <class T>
       concept pair_t = requires(T pair) {
-                          {
-                             pair.first
-                             } -> std::same_as<typename T::first_type&>;
-                          {
-                             pair.second
-                             } -> std::same_as<typename T::second_type&>;
-                       };
+         {
+            pair.first
+         } -> std::same_as<typename T::first_type&>;
+         {
+            pair.second
+         } -> std::same_as<typename T::second_type&>;
+      };
 
       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>()]
+         } -> std::same_as<typename T::mapped_type&>;
+      };
 
       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>;
+      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 writable_map_t = !
-      custom_write<T> && !meta_value_t<T> && !str_t<T> && range<T> && pair_t<range_value_t<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; });
-                                  };
+         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 array_t = (!meta_value_t<T> && !str_t<T> && !(readable_map_t<T> || writable_map_t<T>) && range<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 readable_array_t = (!custom_read<T> && array_t<T>);
@@ -392,24 +411,24 @@ namespace glz
 
       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 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 resizeable = requires(T container) { container.resize(0); };
@@ -418,18 +437,18 @@ namespace glz
       concept erasable = requires(T container) { container.erase(container.cbegin(), container.cend()); };
 
       template <class T>
-      concept fixed_array_value_t = array_t<std::decay_t<decltype(std::declval<T>()[0])>> && !
-      resizeable<std::decay_t<decltype(std::declval<T>()[0])>>;
+      concept fixed_array_value_t = array_t<std::decay_t<decltype(std::declval<T>()[0])>> &&
+                                    !resizeable<std::decay_t<decltype(std::declval<T>()[0])>>;
 
       template <class T>
       concept has_size = requires(T container) { container.size(); };
 
       template <class T>
       concept has_empty = requires(T container) {
-                             {
-                                container.empty()
-                                } -> std::convertible_to<bool>;
-                          };
+         {
+            container.empty()
+         } -> std::convertible_to<bool>;
+      };
 
       template <class T>
       concept has_data = requires(T container) { container.data(); };
@@ -439,10 +458,10 @@ namespace glz
 
       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 boolean_like = std::same_as<T, bool> || std::same_as<T, std::vector<bool>::reference> ||
@@ -453,20 +472,40 @@ namespace glz
 
       template <class T>
       concept is_span = requires(T t) {
-                           T::extent;
-                           typename T::element_type;
-                        };
+         T::extent;
+         typename T::element_type;
+      };
+
+      template <class T>
+      concept is_no_reflect = requires(T t) { requires T::glaze_reflect == false; };
 
       template <class T>
       concept is_dynamic_span = T::extent == static_cast<size_t>(-1);
 
       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);
+      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);
+
+      template <typename T>
+      concept is_bitset = requires(T bitset) {
+         bitset.flip();
+         bitset.set(0);
+         {
+            bitset.to_string()
+         } -> std::same_as<std::string>;
+         {
+            bitset.count()
+         } -> std::same_as<std::size_t>;
+      };
+
+      template <class T>
+      concept is_float128 = requires(T x) {
+         requires sizeof(x) == 16;
+         requires std::floating_point<T>;
+      };
 
       template <class T>
       constexpr size_t get_size() noexcept
@@ -484,23 +523,21 @@ namespace glz
 
       template <class T>
       concept tuple_t = requires(T t) {
-                           std::tuple_size<T>::value;
-                           glz::tuplet::get<0>(t);
-                        } && !
-      meta_value_t<T> && !range<T>;
+         std::tuple_size<T>::value;
+         glz::get<0>(t);
+      } && !meta_value_t<T> && !range<T>;
 
       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 nullable_t = !
-      meta_value_t<T> && !str_t<T> && requires(T t) {
-                                         bool(t);
-                                         {
-                                            *t
-                                         };
-                                      };
+      concept nullable_t = !meta_value_t<T> && !str_t<T> && requires(T t) {
+         bool(t);
+         {
+            *t
+         };
+      };
 
       template <class T>
       concept raw_nullable = is_specialization_v<T, raw_t> && requires { requires nullable_t<typename T::value_type>; };
@@ -510,10 +547,9 @@ namespace glz
 
       template <class T>
       concept func_t = requires(T t) {
-                          typename T::result_type;
-                          std::function(t);
-                       } && !
-      glaze_t<T>;
+         typename T::result_type;
+         std::function(t);
+      } && !glaze_t<T>;
 
       template <class T>
       concept glaze_array_t = glaze_t<T> && is_specialization_v<meta_wrapper_t<T>, Array>;
@@ -531,15 +567,24 @@ namespace glz
       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 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 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 From, class To>
       concept non_narrowing_convertable = requires(From from, To to) {
 #if __GNUC__
-                                             // TODO: guard gcc against narrowing conversions when fixed
-                                             to = from;
+         // TODO: guard gcc against narrowing conversions when fixed
+         to = from;
 #else
-                                             To{from};
+         To{from};
 #endif
-                                          };
+      };
 
       // from
       // https://stackoverflow.com/questions/55941964/how-to-filter-duplicate-types-from-tuple-c
@@ -579,11 +624,18 @@ namespace glz
       template <class Tuple, class = std::make_index_sequence<std::tuple_size<Tuple>::value>>
       struct value_tuple_variant;
 
+      template <class Tuple, size_t I>
+      struct member_type
+      {
+         using T0 = std::decay_t<std::tuple_element_t<0, std::tuple_element_t<I, Tuple>>>;
+         using type = std::tuple_element_t<std::is_member_object_pointer_v<T0> ? 0 : 1, std::tuple_element_t<I, Tuple>>;
+      };
+
       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<glz::tuplet::tuple<std::tuple_element_t<1, std::tuple_element_t<I, Tuple>>>>()...))>::type;
+            std::declval<tuplet::tuple<typename member_type<Tuple, I>::type>>()...))>::type;
       };
 
       template <class Tuple>
@@ -593,7 +645,7 @@ namespace glz
       inline constexpr auto make_array_impl(std::index_sequence<I...>)
       {
          using value_t = typename tuple_variant<meta_t<T>>::type;
-         return std::array<value_t, std::tuple_size_v<meta_t<T>>>{glz::tuplet::get<I>(meta_v<T>)...};
+         return std::array<value_t, std::tuple_size_v<meta_t<T>>>{glz::get<I>(meta_v<T>)...};
       }
 
       template <class T>
@@ -614,7 +666,7 @@ namespace glz
                return &std::get<Is>(t);
             }
             else {
-               return &glz::tuplet::get<Is>(t);
+               return &glz::get<Is>(t);
             }
          }...};
       }
@@ -628,10 +680,63 @@ namespace glz
          return runtime_getter[index](t);
       }
 
+      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_object_pointer_v<T0>) {
+            return std::pair<sv, value_t>{get_name<first>(), first};
+         }
+         else {
+            return std::pair<sv, value_t>{sv(first), get<1>(get<I>(meta_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_object_pointer_v<T0>) {
+            return get_name<first>();
+         }
+         else {
+            return {first};
+         }
+      }
+
+      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};
+         }
+      }
+
+      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>));
+         }
+      }
+
       template <class T, size_t I>
       struct meta_sv
       {
-         static constexpr sv value = glz::tuplet::get<0>(glz::tuplet::get<I>(meta_v<T>));
+         static constexpr sv value = get_key<T, I>();
       };
 
       template <class T, bool use_hash_comparison, size_t... I>
@@ -640,74 +745,62 @@ namespace glz
          using value_t = value_tuple_variant_t<meta_t<T>>;
          constexpr auto n = std::tuple_size_v<meta_t<T>>;
 
-         auto naive_or_normal_hash = [&] {
-            if constexpr (n <= 20) {
-               return glz::detail::naive_map<value_t, n, use_hash_comparison>(
-                  {std::pair<sv, value_t>{sv(glz::tuplet::get<0>(glz::tuplet::get<I>(meta_v<T>))),
-                                          glz::tuplet::get<1>(glz::tuplet::get<I>(meta_v<T>))}...});
-            }
-            else {
-               return glz::detail::normal_map<sv, value_t, n, use_hash_comparison>(
-                  {std::pair<sv, value_t>{sv(glz::tuplet::get<0>(glz::tuplet::get<I>(meta_v<T>))),
-                                          glz::tuplet::get<1>(glz::tuplet::get<I>(meta_v<T>))}...});
-            }
-         };
-
          if constexpr (n == 0) {
-            static_assert(false_v<T>, "Empty object map is illogical. Handle empty upstream.");
+            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...>{
-               std::make_pair<sv, value_t>(sv(glz::tuplet::get<0>(glz::tuplet::get<I>(meta_v<T>))),
-                                           glz::tuplet::get<1>(glz::tuplet::get<I>(meta_v<T>)))...};
+            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...>{
-               std::make_pair<sv, value_t>(sv(glz::tuplet::get<0>(glz::tuplet::get<I>(meta_v<T>))),
-                                           glz::tuplet::get<1>(glz::tuplet::get<I>(meta_v<T>)))...};
+            return micro_map2<value_t, meta_sv<T, I>::value...>{key_value<T, I>()...};
          }
-         else if constexpr (n < 128) // don't even attempt a first character hash if we have too many keys
+         else if constexpr (n < 64) // don't even attempt a first character hash if we have too many keys
          {
-            constexpr auto front_desc =
-               single_char_hash<n>(std::array<sv, n>{sv{glz::tuplet::get<0>(glz::tuplet::get<I>(meta_v<T>))}...});
+            constexpr auto front_desc = single_char_hash<n>(std::array<sv, n>{get_key<T, I>()...});
 
             if constexpr (front_desc.valid) {
-               return make_single_char_map<value_t, front_desc>(
-                  {std::make_pair<sv, value_t>(sv(glz::tuplet::get<0>(glz::tuplet::get<I>(meta_v<T>))),
-                                               glz::tuplet::get<1>(glz::tuplet::get<I>(meta_v<T>)))...});
+               return make_single_char_map<value_t, front_desc>({key_value<T, I>()...});
             }
             else {
-               constexpr auto back_desc = single_char_hash<n, false>(
-                  std::array<sv, n>{sv{glz::tuplet::get<0>(glz::tuplet::get<I>(meta_v<T>))}...});
+               constexpr auto back_desc = single_char_hash<n, false>(std::array<sv, n>{get_key<T, I>()...});
 
                if constexpr (back_desc.valid) {
-                  return make_single_char_map<value_t, back_desc>(
-                     {std::make_pair<sv, value_t>(sv(glz::tuplet::get<0>(glz::tuplet::get<I>(meta_v<T>))),
-                                                  glz::tuplet::get<1>(glz::tuplet::get<I>(meta_v<T>)))...});
+                  return make_single_char_map<value_t, back_desc>({key_value<T, I>()...});
                }
                else {
-                  return naive_or_normal_hash();
+                  if constexpr (n <= 20) {
+                     return glz::detail::naive_map<value_t, n, use_hash_comparison>({key_value<T, I>()...});
+                  }
+                  else {
+                     return glz::detail::normal_map<sv, value_t, n, use_hash_comparison>({key_value<T, I>()...});
+                  }
                }
             }
          }
          else {
-            return naive_or_normal_hash();
+            if constexpr (n <= 20) {
+               return glz::detail::naive_map<value_t, n, use_hash_comparison>({key_value<T, I>()...});
+            }
+            else {
+               return glz::detail::normal_map<sv, value_t, n, use_hash_comparison>({key_value<T, I>()...});
+            }
          }
       }
 
       template <class T, bool use_hash_comparison = false>
+         requires(!reflectable<T>)
       constexpr auto make_map()
       {
          constexpr auto indices = std::make_index_sequence<std::tuple_size_v<meta_t<T>>>{};
          return make_map_impl<std::decay_t<T>, use_hash_comparison>(indices);
       }
 
-      template <class T, size_t... I>
+      /*template <class T, size_t... I>
       constexpr auto make_int_storage_impl(std::index_sequence<I...>)
       {
          using value_t = value_tuple_variant_t<meta_t<T>>;
-         return std::array<value_t, std::tuple_size_v<meta_t<T>>>(
-            {glz::tuplet::get<1>(glz::tuplet::get<I>(meta_v<T>))...});
+         return std::array<value_t, std::tuple_size_v<meta_t<T>>>({glz::get<1>(glz::get<I>(meta_v<T>))...});
       }
 
       template <class T>
@@ -715,13 +808,13 @@ namespace glz
       {
          constexpr auto indices = std::make_index_sequence<std::tuple_size_v<meta_t<T>>>{};
          return make_int_storage_impl<T>(indices);
-      }
+      }*/
 
       template <class T, size_t... I>
       constexpr auto make_key_int_map_impl(std::index_sequence<I...>)
       {
          return normal_map<sv, size_t, std::tuple_size_v<meta_t<T>>>(
-            {std::make_pair<sv, size_t>(glz::tuplet::get<0>(glz::tuplet::get<I>(meta_v<T>)), I)...});
+            {std::make_pair<sv, size_t>(get_enum_key<T, I>(), I)...});
       }
 
       template <class T>
@@ -731,31 +824,12 @@ namespace glz
          return make_key_int_map_impl<T>(indices);
       }
 
-      template <class T, size_t... I>
-      constexpr auto make_crusher_map_impl(std::index_sequence<I...>)
-      {
-         using value_t = value_tuple_variant_t<meta_t<T>>;
-         constexpr auto n = std::tuple_size_v<meta_t<T>>;
-
-         return normal_map<uint32_t, value_t, n>(
-            {std::make_pair<uint32_t, value_t>(murmur3_32(glz::tuplet::get<0>(glz::tuplet::get<I>(meta_v<T>))),
-                                               glz::tuplet::get<1>(glz::tuplet::get<I>(meta_v<T>)))...});
-      }
-
-      template <class T>
-      constexpr auto make_crusher_map()
-      {
-         constexpr auto indices = std::make_index_sequence<std::tuple_size_v<meta_t<T>>>{};
-         return make_crusher_map_impl<T>(indices);
-      }
-
       template <class T, size_t... I>
       constexpr auto make_enum_to_string_map_impl(std::index_sequence<I...>)
       {
          using key_t = std::underlying_type_t<T>;
          return normal_map<key_t, sv, std::tuple_size_v<meta_t<T>>>(
-            {std::make_pair<key_t, sv>(static_cast<key_t>(glz::tuplet::get<1>(glz::tuplet::get<I>(meta_v<T>))),
-                                       sv(glz::tuplet::get<0>(glz::tuplet::get<I>(meta_v<T>))))...});
+            {std::make_pair<key_t, sv>(static_cast<key_t>(get_enum_value<T, I>()), get_enum_key<T, I>())...});
       }
 
       template <class T>
@@ -770,8 +844,7 @@ namespace glz
       constexpr auto make_enum_to_string_array()
       {
          std::array<sv, std::tuple_size_v<meta_t<T>>> arr;
-         for_each<std::tuple_size_v<meta_t<T>>>(
-            [&](auto I) { arr[I] = enum_name_v<static_cast<T>(decltype(I)::value)>; });
+         for_each<std::tuple_size_v<meta_t<T>>>([&](auto I) { arr[I] = get_enum_key<T, I>(); });
          return arr;
       }
 
@@ -779,8 +852,7 @@ namespace glz
       constexpr auto make_string_to_enum_map_impl(std::index_sequence<I...>)
       {
          return normal_map<sv, T, std::tuple_size_v<meta_t<T>>>(
-            {std::make_pair<sv, T>(sv(glz::tuplet::get<0>(glz::tuplet::get<I>(meta_v<T>))),
-                                   T(glz::tuplet::get<1>(glz::tuplet::get<I>(meta_v<T>))))...});
+            {std::make_pair<sv, T>(get_enum_key<T, I>(), T(get_enum_value<T, I>()))...});
       }
 
       template <class T>
@@ -790,30 +862,67 @@ namespace glz
          return make_string_to_enum_map_impl<T>(indices);
       }
 
+      // 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 += std::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>;
-         constexpr size_t max_keys = []() {
-            size_t res{};
-            for_each<N>([&](auto I) {
-               using V = std::decay_t<std::variant_alternative_t<I, T>>;
-               res += std::tuple_size_v<meta_t<V>>;
-            });
-            return res;
-         }();
 
-         std::array<std::string_view, max_keys> data{};
+         std::array<std::string_view, get_max_keys<T, N>> data{};
+         auto* data_ptr =
+            &data; // This intermediate pointer is necessary for GCC 13 (otherwise segfaults with reflection logic)
          size_t index = 0;
          for_each<N>([&](auto I) {
             using V = std::decay_t<std::variant_alternative_t<I, T>>;
-            for_each<std::tuple_size_v<meta_t<V>>>(
-               [&](auto J) { data[index++] = glz::tuplet::get<0>(glz::tuplet::get<J>(meta_v<V>)); });
+            if constexpr (reflectable<V>) {
+               for_each<std::tuple_size_v<decltype(member_names<V>)>>(
+                  [&](auto J) { (*data_ptr)[index++] = glz::get<J>(member_names<V>); });
+            }
+            else {
+               for_each<std::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_object_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(data.data(), data.data() + max_keys);
-         const auto end = std::unique(data.data(), data.data() + max_keys);
-         const auto size = std::distance(data.data(), end);
+         std::sort(data.begin(), data.end());
+         const auto end = std::unique(data.begin(), data.end());
+         const auto size = std::distance(data.begin(), end);
 
          return std::pair{data, size};
       }
@@ -836,9 +945,25 @@ namespace glz
          constexpr auto N = std::variant_size_v<T>;
          for_each<N>([&](auto I) {
             using V = std::decay_t<std::variant_alternative_t<I, T>>;
-            for_each<std::tuple_size_v<meta_t<V>>>([&](auto J) {
-               deduction_map.find(glz::tuplet::get<0>(glz::tuplet::get<J>(meta_v<V>)))->second[I] = true;
-            });
+            if constexpr (reflectable<V>) {
+               for_each<std::tuple_size_v<decltype(member_names<V>)>>(
+                  [&](auto J) { deduction_map.find(get<J>(member_names<V>))->second[I] = true; });
+            }
+            else {
+               for_each<std::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_object_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;
@@ -858,7 +983,8 @@ namespace glz
          return make_variant_id_map_impl<T>(indices, ids_v<T>);
       }
 
-      inline decltype(auto) get_member(auto&& value, auto&& member_ptr)
+      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>) {
@@ -867,11 +993,16 @@ namespace glz
          else if constexpr (std::is_member_function_pointer_v<V>) {
             return member_ptr;
          }
-         else if constexpr (std::invocable<decltype(member_ptr), decltype(value)>) {
-            return std::invoke(member_ptr, value);
+         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>) {
-            return *member_ptr;
+            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;
@@ -901,8 +1032,7 @@ namespace glz
       inline constexpr auto members_from_meta_impl()
       {
          if constexpr (glaze_object_t<std::decay_t<T>>) {
-            return glz::tuplet::tuple<
-               std::decay_t<member_t<T, std::tuple_element_t<1, std::tuple_element_t<I, meta_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{};
@@ -933,21 +1063,6 @@ namespace glz
       {};
       template <class T>
       array_variant(T) -> array_variant<T>; // Only needed on older compilers until we move to template alias deduction
-
-      template <class T, auto Opts>
-      constexpr auto required_fields()
-      {
-         constexpr auto n = std::tuple_size_v<meta_t<T>>;
-         bit_array<n> fields{};
-         if constexpr (Opts.error_on_missing_keys) {
-            for_each<n>([&](auto I) constexpr {
-               fields[I] =
-                  !bool(Opts.skip_null_members) ||
-                  !null_t<std::decay_t<member_t<T, std::tuple_element_t<1, std::tuple_element_t<I, meta_t<T>>>>>>;
-            });
-         }
-         return fields;
-      }
    } // namespace detail
 
    constexpr decltype(auto) conv_sv(auto&& value) noexcept
@@ -1040,12 +1155,27 @@ struct glz::meta<glz::error_code>
                 "elements_not_convertible_to_design", glz::error_code::elements_not_convertible_to_design, //
                 "unknown_distribution", glz::error_code::unknown_distribution, //
                 "invalid_distribution_elements", glz::error_code::invalid_distribution_elements, //
-                "missing_key", glz::error_code::missing_key //
+                "missing_key", glz::error_code::missing_key, //
+                "hostname_failure", glz::error_code::hostname_failure //
       );
 };
 
 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 {
+         return "glz::unknown";
+      }
+   }();
+
    [[nodiscard]] inline std::string format_error(const parse_error& pe, const auto& buffer)
    {
       static constexpr auto arr = detail::make_enum_to_string_array<error_code>();
@@ -1058,3 +1188,127 @@ namespace glz
       return std::string(error_type_str);
    }
 }
+
+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;
+      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<std::tuple_element_t<0, Item>>;
+      static constexpr bool use_reflection = std::is_member_object_pointer_v<T0>;
+      static constexpr size_t member_index = use_reflection ? 0 : 1;
+      using mptr_t = std::decay_t<std::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;
+      static constexpr size_t member_index = 0;
+      using Item = decltype(to_tuple(std::declval<T>()));
+      using mptr_t = std::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
+   {
+      using V = std::decay_t<T>;
+
+      static constexpr auto N = [] {
+         if constexpr (reflectable<T>) {
+            return count_members<T>;
+         }
+         else {
+            return std::tuple_size_v<meta_t<V>>;
+         }
+      }();
+
+      // 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 val_t = glaze_tuple_element_t<0, N, T>;
+
+            if constexpr (null_t<val_t> && Opts.skip_null_members) {
+               return false;
+            }
+
+            // skip file_include
+            if constexpr (is_includer<val_t>) {
+               return false;
+            }
+            else if constexpr (std::is_same_v<val_t, hidden> || std::same_as<val_t, skip>) {
+               return false;
+            }
+            else {
+               return true;
+            }
+         }
+         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>))>();
+         }
+         else {
+            return get<0>(get<I>(meta_v<V>));
+         }
+      }
+   }();
+
+   template <class T, auto Opts>
+   constexpr auto required_fields()
+   {
+      constexpr auto N = [] {
+         if constexpr (reflectable<T>) {
+            return count_members<T>;
+         }
+         else {
+            return std::tuple_size_v<meta_t<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 fields;
+   }
+}
diff --git a/src/core/include/glaze/core/context.hpp b/src/core/include/glaze/core/context.hpp
index 62909781..146e8ae8 100644
--- a/src/core/include/glaze/core/context.hpp
+++ b/src/core/include/glaze/core/context.hpp
@@ -57,7 +57,8 @@ namespace glz
       elements_not_convertible_to_design,
       unknown_distribution,
       invalid_distribution_elements,
-      missing_key
+      missing_key,
+      hostname_failure
    };
 
    struct parse_error final
diff --git a/src/core/include/glaze/core/macros.hpp b/src/core/include/glaze/core/macros.hpp
index 826f9842..9061e856 100644
--- a/src/core/include/glaze/core/macros.hpp
+++ b/src/core/include/glaze/core/macros.hpp
@@ -23,8 +23,8 @@
 // Glaze specific macros
 
 #define GLZ_X(a) #a, &GLZ_T::a
-#define GLZ_QUOTED_X(a) #a, glz::quoted < &GLZ_T::a>
-#define GLZ_QUOTED_NUM_X(a) #a, glz::quoted_num < &GLZ_T::a>
+#define GLZ_QUOTED_X(a) #a, glz::quoted<&GLZ_T::a>
+#define GLZ_QUOTED_NUM_X(a) #a, glz::quoted_num<&GLZ_T::a>
 
 #define GLZ_META(C, ...)                                                      \
    template <>                                                                \
diff --git a/src/core/include/glaze/core/meta.hpp b/src/core/include/glaze/core/meta.hpp
index 21697af9..eba1e7b6 100644
--- a/src/core/include/glaze/core/meta.hpp
+++ b/src/core/include/glaze/core/meta.hpp
@@ -5,6 +5,7 @@
 
 #include <array>
 
+#include "glaze/reflection/get_name.hpp"
 #include "glaze/tuplet/tuple.hpp"
 #include "glaze/util/for_each.hpp"
 #include "glaze/util/type_traits.hpp"
@@ -68,6 +69,12 @@ namespace glz
 
       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_writer = requires { meta<T>::unknown_write; } || requires { T::glaze::unknown_write; };
+
+      template <class T>
+      concept has_unknown_reader = requires { meta<T>::unknown_read; } || requires { T::glaze::unknown_read; };
    }
 
    struct empty
@@ -110,6 +117,51 @@ namespace glz
    template <class T>
    using meta_wrapper_t = std::decay_t<decltype(meta_wrapper_v<std::decay_t<T>>)>;
 
+   template <class T>
+   struct remove_meta_wrapper
+   {
+      using type = T;
+   };
+   template <detail::glaze_t T>
+   struct remove_meta_wrapper<T>
+   {
+      using type = std::remove_pointer_t<std::remove_const_t<meta_wrapper_t<T>>>;
+   };
+   template <class T>
+   using remove_meta_wrapper_t = typename remove_meta_wrapper<T>::type;
+
+   template <class T>
+   inline constexpr auto meta_unknown_write_v = [] {
+      if constexpr (detail::local_meta_t<T>) {
+         return T::glaze::unknown_write;
+      }
+      else if constexpr (detail::global_meta_t<T>) {
+         return meta<T>::unknown_write;
+      }
+      else {
+         return empty{};
+      }
+   }();
+
+   template <class T>
+   using meta_unknown_write_t = std::decay_t<decltype(meta_unknown_write_v<std::decay_t<T>>)>;
+
+   template <class T>
+   inline constexpr auto meta_unknown_read_v = [] {
+      if constexpr (detail::local_meta_t<T>) {
+         return T::glaze::unknown_read;
+      }
+      else if constexpr (detail::global_meta_t<T>) {
+         return meta<T>::unknown_read;
+      }
+      else {
+         return empty{};
+      }
+   }();
+
+   template <class T>
+   using meta_unknown_read_t = std::decay_t<decltype(meta_unknown_read_v<std::decay_t<T>>)>;
+
    template <class T>
    concept named = requires { meta<T>::name; } || requires { T::glaze::name; };
 
@@ -138,7 +190,7 @@ namespace glz
          static_assert(false_v<T>, "name_v used on unnamed type");
       }
       else {
-         return "glz::unknown";
+         return type_name<std::decay_t<T>>;
       }
    }();
 
@@ -181,20 +233,6 @@ namespace glz
       }
    }();
 
-   template <auto Enum>
-      requires(std::is_enum_v<decltype(Enum)>)
-   inline constexpr std::string_view 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 glz::tuplet::get<0>(glz::tuplet::get<static_cast<U>(Enum)>(meta_v<T>));
-      }
-      else {
-         return "glz::unknown";
-      }
-   }();
-
    using version_t = std::array<uint32_t, 3>;
 
    template <class T>
diff --git a/src/core/include/glaze/core/opts.hpp b/src/core/include/glaze/core/opts.hpp
index a20ee608..e0761d2e 100644
--- a/src/core/include/glaze/core/opts.hpp
+++ b/src/core/include/glaze/core/opts.hpp
@@ -30,12 +30,17 @@ namespace glz
       bool number = false; // read numbers as strings and write these string as 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 to reflectable and
+                                      // glaze_object_t concepts
 
       // 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
+
+      [[nodiscard]] constexpr bool operator==(const opts&) const noexcept = default;
    };
 
    template <opts Opts>
@@ -109,4 +114,36 @@ namespace glz
 
    template <opts Opts, auto member_ptr>
    inline constexpr auto opt_false = opt_off<Opts, member_ptr>();
+
+   template <opts Opts>
+   constexpr auto write_unknown_off()
+   {
+      opts ret = Opts;
+      ret.write_unknown = false;
+      return ret;
+   }
+
+   template <opts Opts>
+   constexpr auto write_unknown_on()
+   {
+      opts ret = Opts;
+      ret.write_unknown = true;
+      return ret;
+   }
+
+   template <opts Opts>
+   constexpr auto set_binary()
+   {
+      opts ret = Opts;
+      ret.format = binary;
+      return ret;
+   }
+
+   template <opts Opts>
+   constexpr auto set_json()
+   {
+      opts ret = Opts;
+      ret.format = json;
+      return ret;
+   }
 }
diff --git a/src/core/include/glaze/core/ptr.hpp b/src/core/include/glaze/core/ptr.hpp
index e6d50ac2..034cbe25 100644
--- a/src/core/include/glaze/core/ptr.hpp
+++ b/src/core/include/glaze/core/ptr.hpp
@@ -13,7 +13,7 @@ namespace glz
 {
    // Given a JSON pointer path, reads from the buffer into the object
    template <opts Opts, class T, class B>
-   parse_error read_as(T&& root_value, const sv json_ptr, B&& buffer)
+   [[nodiscard]] parse_error read_as(T&& root_value, const sv json_ptr, B&& buffer)
    {
       parse_error pe{};
       bool b =
@@ -27,12 +27,17 @@ namespace glz
 
    // Given a JSON pointer path, writes into a buffer the specified value
    template <opts Opts, class T, class B>
-   bool write_as(T&& root_value, const sv json_ptr, B&& buffer)
+   [[nodiscard]] bool write_as(T&& root_value, const sv json_ptr, B&& buffer)
    {
       return detail::seek_impl(
          [&](auto&& val) {
-            // TODO: handle raw buffer length output
-            write<Opts>(val, buffer);
+            if constexpr (raw_buffer<B>) {
+               std::ignore = write<Opts>(
+                  val, buffer); // We assume the user has sufficient null characters at the end of the buffer
+            }
+            else {
+               write<Opts>(val, buffer);
+            }
          },
          std::forward<T>(root_value), json_ptr);
    }
diff --git a/src/core/include/glaze/core/read.hpp b/src/core/include/glaze/core/read.hpp
index 4c2207df..0f61db31 100644
--- a/src/core/include/glaze/core/read.hpp
+++ b/src/core/include/glaze/core/read.hpp
@@ -101,8 +101,7 @@ namespace glz
    }
 
    template <class T>
-   concept string_viewable = std::convertible_to<std::decay_t<T>, std::string_view> && !
-   detail::has_data<T>;
+   concept string_viewable = std::convertible_to<std::decay_t<T>, std::string_view> && !detail::has_data<T>;
 
    // for char array input
    template <opts Opts, class T, string_viewable Buffer>
diff --git a/src/core/include/glaze/core/write.hpp b/src/core/include/glaze/core/write.hpp
index 508559f5..10372513 100644
--- a/src/core/include/glaze/core/write.hpp
+++ b/src/core/include/glaze/core/write.hpp
@@ -18,7 +18,7 @@ namespace glz
    concept output_buffer = range<Buffer> && (sizeof(range_value_t<Buffer>) == sizeof(char));
 
    template <class T>
-   GLZ_ALWAYS_INLINE auto data_ptr(T& buffer) noexcept
+   [[nodiscard]] GLZ_ALWAYS_INLINE auto data_ptr(T& buffer) noexcept
    {
       if constexpr (detail::resizeable<T>) {
          return buffer.data();
@@ -51,8 +51,17 @@ namespace glz
       write<Opts>(std::forward<T>(value), buffer, ctx);
    }
 
+   template <opts Opts, class T>
+   [[nodiscard]] inline std::string write(T&& value) noexcept
+   {
+      std::string buffer{};
+      context ctx{};
+      write<Opts>(std::forward<T>(value), buffer, ctx);
+      return buffer;
+   }
+
    template <opts Opts, class T, raw_buffer Buffer>
-   inline size_t write(T&& value, Buffer&& buffer, is_context auto&& ctx) noexcept
+   [[nodiscard]] inline size_t write(T&& value, Buffer&& buffer, is_context auto&& ctx) noexcept
    {
       size_t ix = 0;
       detail::write<Opts.format>::template op<Opts>(std::forward<T>(value), ctx, buffer, ix);
@@ -60,7 +69,7 @@ namespace glz
    }
 
    template <opts Opts, class T, raw_buffer Buffer>
-   inline size_t write(T&& value, Buffer&& buffer) noexcept
+   [[nodiscard]] inline size_t write(T&& value, Buffer&& buffer) noexcept
    {
       context ctx{};
       return write<Opts>(std::forward<T>(value), std::forward<Buffer>(buffer), ctx);
diff --git a/src/core/include/glaze/core/write_chars.hpp b/src/core/include/glaze/core/write_chars.hpp
index bd571ba6..c83619e3 100644
--- a/src/core/include/glaze/core/write_chars.hpp
+++ b/src/core/include/glaze/core/write_chars.hpp
@@ -3,8 +3,10 @@
 
 #pragma once
 
+#include <charconv>
 #include <type_traits>
 
+#include "common.hpp"
 #include "glaze/core/common.hpp"
 #include "glaze/core/opts.hpp"
 #include "glaze/util/dtoa.hpp"
@@ -52,7 +54,7 @@ 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
+         // maximum length for a double should be 24 chars, we use 64 to be sufficient for float128_t
          if constexpr (detail::resizeable<B>) {
             if (ix + 64 > b.size()) [[unlikely]] {
                b.resize((std::max)(b.size() * 2, ix + 64));
@@ -66,6 +68,14 @@ namespace glz::detail
             auto end = glz::to_chars(start, value);
             ix += std::distance(start, end);
          }
+         else if constexpr (is_float128<V>) {
+            auto start = data_ptr(b) + ix;
+            auto [ptr, ec] = std::to_chars(start, data_ptr(b) + b.size(), value, std::chars_format::general);
+            if (ec != std::errc()) {
+               // TODO: Do we need to handle this error state?
+            }
+            ix += std::distance(start, ptr);
+         }
          else if constexpr (std::integral<V>) {
             using X = std::decay_t<decltype(sized_integer_conversion<V>())>;
             auto start = data_ptr(b) + ix;
diff --git a/src/core/include/glaze/csv/read.hpp b/src/core/include/glaze/csv/read.hpp
index bdda446d..0bb8afa8 100644
--- a/src/core/include/glaze/csv/read.hpp
+++ b/src/core/include/glaze/csv/read.hpp
@@ -8,6 +8,7 @@
 #include "glaze/core/format.hpp"
 #include "glaze/core/read.hpp"
 #include "glaze/file/file_ops.hpp"
+#include "glaze/reflection/reflect.hpp"
 #include "glaze/util/parse.hpp"
 #include "glaze/util/strod.hpp"
 
@@ -66,7 +67,7 @@ namespace glz
                      return;
                   }
 
-                  if (i > std::numeric_limits<V>::max()) [[unlikely]] {
+                  if (i > (std::numeric_limits<V>::max)()) [[unlikely]] {
                      ctx.error = error_code::parse_number_failure;
                      return;
                   }
@@ -85,7 +86,7 @@ namespace glz
                      return;
                   }
 
-                  if (i > std::numeric_limits<V>::max()) [[unlikely]] {
+                  if (i > (std::numeric_limits<V>::max)()) [[unlikely]] {
                      ctx.error = error_code::parse_number_failure;
                      return;
                   }
@@ -93,17 +94,11 @@ namespace glz
                }
             }
             else {
-               // TODO: fix this also, taken from json
-               using X =
-                  std::conditional_t<std::is_const_v<std::remove_pointer_t<std::remove_reference_t<decltype(it)>>>,
-                                     const uint8_t*, uint8_t*>;
-               auto cur = reinterpret_cast<X>(it);
-               auto s = parse_float<V, Opts.force_conformance>(value, cur);
+               auto s = parse_float<V, Opts.force_conformance>(value, it);
                if (!s) [[unlikely]] {
                   ctx.error = error_code::parse_number_failure;
                   return;
                }
-               it = reinterpret_cast<std::remove_reference_t<decltype(it)>>(cur);
             }
          }
       };
@@ -259,7 +254,7 @@ namespace glz
                      }
                   }
 
-                  match<','>(ctx, it, end);
+                  match<','>(ctx, it);
 
                   using key_type = typename std::decay_t<decltype(value)>::key_type;
                   auto& member = value[key_type(key)];
@@ -362,14 +357,37 @@ namespace glz
          }
       };
 
-      template <glaze_object_t T>
+      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)
          {
-            static constexpr auto frozen_map = detail::make_map<T, Opts.use_hash_comparison>();
-            // static constexpr auto N = std::tuple_size_v<meta_t<T>>;
+            static constexpr auto num_members = [] {
+               if constexpr (reflectable<T>) {
+                  return count_members<T>;
+               }
+               else {
+                  return std::tuple_size_v<meta_t<T>>;
+               }
+            }();
+
+            decltype(auto) frozen_map = [&] {
+               if constexpr (reflectable<T> && num_members > 0) {
+                  static constinit auto cmap = make_map<T, Opts.use_hash_comparison>();
+                  // 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;
+               }
+            }();
 
             if constexpr (Opts.layout == rowwise) {
                while (it != end) {
@@ -377,7 +395,7 @@ namespace glz
                   goto_delim<','>(it, end);
                   sv key{start, static_cast<size_t>(it - start)};
 
-                  size_t csv_index;
+                  size_t csv_index{};
 
                   const auto brace_pos = key.find('[');
                   if (brace_pos != sv::npos) {
@@ -385,13 +403,16 @@ namespace glz
                      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()) {
+                     if (ec != std::errc()) [[unlikely]] {
                         ctx.error = error_code::syntax_error;
                         return;
                      }
                   }
 
-                  match<','>(ctx, it, end);
+                  match<','>(ctx, it);
+                  if (bool(ctx.error)) [[unlikely]] {
+                     return;
+                  }
 
                   const auto& member_it = frozen_map.find(key);
 
@@ -414,11 +435,14 @@ namespace glz
                                     ++it;
                                     break;
                                  }
+                                 else if (it == end) {
+                                    return;
+                                 }
 
-                                 if (*it == ',') {
+                                 if (*it == ',') [[likely]] {
                                     ++it;
                                  }
-                                 else {
+                                 else [[unlikely]] {
                                     ctx.error = error_code::syntax_error;
                                     return;
                                  }
@@ -435,10 +459,10 @@ namespace glz
                                     break;
                                  }
 
-                                 if (*it == ',') {
+                                 if (*it == ',') [[likely]] {
                                     ++it;
                                  }
-                                 else {
+                                 else [[unlikely]] {
                                     ctx.error = error_code::syntax_error;
                                     return;
                                  }
@@ -446,6 +470,10 @@ namespace glz
                            }
                         },
                         member_it->second);
+
+                     if (bool(ctx.error)) [[unlikely]] {
+                        return;
+                     }
                   }
                   else [[unlikely]] {
                      ctx.error = error_code::unknown_key;
@@ -457,14 +485,14 @@ namespace glz
             {
                const auto keys = read_column_wise_keys(ctx, it, end);
 
-               if (bool(ctx.error)) {
+               if (bool(ctx.error)) [[unlikely]] {
                   return;
                }
 
-               if (*it == '\n') {
+               if (*it == '\n') [[likely]] {
                   ++it; // skip new line
                }
-               else {
+               else [[unlikely]] {
                   ctx.error = error_code::syntax_error;
                   return;
                }
@@ -517,13 +545,13 @@ namespace glz
    }
 
    template <uint32_t layout = rowwise, class T, class Buffer>
-   inline auto read_csv(T&& value, Buffer&& buffer) noexcept
+   [[nodiscard]] inline auto read_csv(T&& value, Buffer&& buffer) noexcept
    {
       return read<opts{.format = csv, .layout = layout}>(value, std::forward<Buffer>(buffer));
    }
 
    template <uint32_t layout = rowwise, class T, class Buffer>
-   inline auto read_csv(Buffer&& buffer) noexcept
+   [[nodiscard]] inline auto read_csv(Buffer&& buffer) noexcept
    {
       T value{};
       read<opts{.format = csv, .layout = rowwise}>(value, std::forward<Buffer>(buffer));
@@ -531,7 +559,7 @@ namespace glz
    }
 
    template <uint32_t layout = rowwise, class T>
-   inline parse_error read_file_csv(T& value, const sv file_name)
+   [[nodiscard]] inline parse_error read_file_csv(T& value, const sv file_name)
    {
       context ctx{};
       ctx.current_file = file_name;
diff --git a/src/core/include/glaze/csv/write.hpp b/src/core/include/glaze/csv/write.hpp
index 0a044b23..d6ba5b1b 100644
--- a/src/core/include/glaze/csv/write.hpp
+++ b/src/core/include/glaze/csv/write.hpp
@@ -173,25 +173,54 @@ namespace glz
          }
       };
 
-      template <glaze_object_t T>
+      template <class T>
+         requires(glaze_object_t<T> || reflectable<T>)
       struct to_csv<T>
       {
          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 = std::tuple_size_v<meta_t<V>>;
+
+            static constexpr auto N = [] {
+               if constexpr (reflectable<T>) {
+                  return count_members<T>;
+               }
+               else {
+                  return std::tuple_size_v<meta_t<T>>;
+               }
+            }();
+
+            [[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) {
-                  static constexpr auto item = glz::tuplet::get<I>(meta_v<V>);
-                  static constexpr sv key = glz::tuplet::get<0>(item);
+                  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;
+
+                  static constexpr sv key = key_name<I, T, Element::use_reflection>;
 
-                  using item_type = std::decay_t<decltype(get_member(value, glz::tuplet::get<1>(item)))>;
-                  using V = typename item_type::value_type;
+                  decltype(auto) mem = [&] {
+                     if constexpr (reflectable<T>) {
+                        return std::get<I>(t);
+                     }
+                     else {
+                        return get<member_index>(get<I>(meta_v<V>));
+                     }
+                  }();
 
-                  if constexpr (writable_array_t<V>) {
-                     auto&& member = get_member(value, glz::tuplet::get<1>(item));
+                  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) {
@@ -216,7 +245,7 @@ namespace glz
                   else {
                      dump<key>(b, ix);
                      dump<','>(b, ix);
-                     write<csv>::op<Opts>(get_member(value, glz::tuplet::get<1>(item)), ctx, b, ix);
+                     write<csv>::op<Opts>(get_member(value, mem), ctx, b, ix);
                      dump<'\n'>(b, ix);
                   }
                });
@@ -224,13 +253,23 @@ namespace glz
             else {
                // write titles
                for_each<N>([&](auto I) {
-                  static constexpr auto item = glz::tuplet::get<I>(meta_v<V>);
-                  static constexpr sv key = glz::tuplet::get<0>(item);
+                  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>;
 
-                  using X = std::decay_t<decltype(get_member(value, glz::tuplet::get<1>(item)))>;
+                  static constexpr sv key = key_name<I, T, Element::use_reflection>;
+
+                  decltype(auto) member = [&] {
+                     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>) {
-                     const auto size = get_member(value, glz::tuplet::get<1>(item))[0].size();
+                     const auto size = get_member(value, member)[0].size();
                      for (size_t i = 0; i < size; ++i) {
                         dump<key>(b, ix);
                         dump<'['>(b, ix);
@@ -257,12 +296,21 @@ namespace glz
 
                while (true) {
                   for_each<N>([&](auto I) {
-                     static constexpr auto item = glz::tuplet::get<I>(meta_v<V>);
+                     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>;
 
-                     using X = std::decay_t<decltype(get_member(value, glz::tuplet::get<1>(item)))>;
+                     decltype(auto) mem = [&] {
+                        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>) {
-                        auto&& member = get_member(value, glz::tuplet::get<1>(item));
+                        decltype(auto) member = get_member(value, mem);
                         if (row >= member.size()) {
                            end = true;
                            return;
@@ -277,7 +325,7 @@ namespace glz
                         }
                      }
                      else {
-                        auto&& member = get_member(value, glz::tuplet::get<1>(item));
+                        decltype(auto) member = get_member(value, mem);
                         if (row >= member.size()) {
                            end = true;
                            return;
@@ -304,17 +352,17 @@ namespace glz
       };
    }
 
-   template <class T, class Buffer>
+   template <uint32_t layout = rowwise, class T, class Buffer>
    GLZ_ALWAYS_INLINE auto write_csv(T&& value, Buffer&& buffer) noexcept
    {
-      return write<opts{.format = csv}>(std::forward<T>(value), std::forward<Buffer>(buffer));
+      return write<opts{.format = csv, .layout = layout}>(std::forward<T>(value), std::forward<Buffer>(buffer));
    }
 
-   template <class T>
+   template <uint32_t layout = rowwise, class T>
    GLZ_ALWAYS_INLINE auto write_csv(T&& value) noexcept
    {
       std::string buffer{};
-      write<opts{.format = csv}>(std::forward<T>(value), buffer);
+      write<opts{.format = csv, .layout = layout}>(std::forward<T>(value), buffer);
       return buffer;
    }
 
diff --git a/src/core/include/glaze/ext/eigen.hpp b/src/core/include/glaze/ext/eigen.hpp
index 7046b47e..c0311a3b 100644
--- a/src/core/include/glaze/ext/eigen.hpp
+++ b/src/core/include/glaze/ext/eigen.hpp
@@ -21,19 +21,18 @@ namespace glz
    {
       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>;
+         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)
diff --git a/src/core/include/glaze/ext/jsonrpc.hpp b/src/core/include/glaze/ext/jsonrpc.hpp
index 6b15d0da..45e00e6b 100644
--- a/src/core/include/glaze/ext/jsonrpc.hpp
+++ b/src/core/include/glaze/ext/jsonrpc.hpp
@@ -95,37 +95,37 @@ namespace glz::rpc
       struct glaze
       {
          using T = error;
-         static constexpr auto value = glz::object("code", &T::code, "message", &T::message, "data", &T::data);
+         static constexpr auto value = glz::object(&T::code, &T::message, &T::data);
       };
    };
 
-   template <class params_type>
+   template <class Params>
    struct request_t
    {
       id_t id{};
       std::string_view method{};
-      params_type params{};
+      Params params{};
       std::string_view version{rpc::supported_version};
 
       struct glaze
       {
          using T = request_t;
          static constexpr auto value = glz::object("jsonrpc", &T::version, //
-                                                   "method", &T::method, //
-                                                   "params", &T::params, //
-                                                   "id", &T::id);
+                                                   &T::method, //
+                                                   &T::params, //
+                                                   &T::id);
       };
    };
 
-   template <class params_type>
-   request_t(id_t&&, std::string_view, params_type&&) -> request_t<std::decay_t<params_type>>;
+   template <class Params>
+   request_t(id_t&&, std::string_view, Params&&) -> request_t<std::decay_t<Params>>;
 
    using generic_request_t = request_t<glz::raw_json_view>;
 
-   template <class result_type>
+   template <class Result>
    struct response_t
    {
-      using result_t = result_type;
+      using result_t = Result;
 
       response_t() = default;
       explicit response_t(rpc::error&& err) : error(std::move(err)) {}
@@ -140,31 +140,30 @@ namespace glz::rpc
       struct glaze
       {
          using T = response_t;
-         static constexpr auto value{
-            glz::object("jsonrpc", &T::version, "result", &T::result, "error", &T::error, "id", &T::id)};
+         static constexpr auto value{glz::object("jsonrpc", &T::version, &T::result, &T::error, &T::id)};
       };
    };
    using generic_response_t = response_t<glz::raw_json_view>;
 
-   template <basic_fixed_string name, class params_type, class result_type>
+   template <string_literal Name, class Params, class Result>
    struct method
    {
-      static constexpr std::string_view name_v{name};
-      using params_t = params_type;
-      using result_t = result_type;
+      static constexpr std::string_view name_v{Name};
+      using params_t = Params;
+      using result_t = Result;
    };
 
    namespace concepts
    {
       template <class T>
       concept method_type = requires(T) {
-                               T::name_v;
-                               {
-                                  std::same_as<decltype(T::name_v), std::string_view>
-                               };
-                               typename T::params_t;
-                               typename T::result_t;
-                            };
+         T::name_v;
+         {
+            std::same_as<decltype(T::name_v), std::string_view>
+         };
+         typename T::params_t;
+         typename T::result_t;
+      };
 
       template <class call_return_t>
       concept call_return_type =
@@ -198,15 +197,29 @@ namespace glz::rpc
 
    namespace detail
    {
-      template <basic_fixed_string name, class... method_type>
-      inline constexpr void set_callback(glz::tuplet::tuple<method_type...>& methods, const auto& callback)
+      template <string_literal name, class... Method>
+      inline constexpr void set_callback(glz::tuplet::tuple<Method...>& methods, const auto& callback)
       {
-         constexpr bool method_found = ((method_type::name_v == name) || ...);
+         constexpr bool method_found = ((Method::name_v == name) || ...);
          static_assert(method_found, "Method not settable in given tuple.");
 
-         methods.any([&callback](auto&& method) -> bool {
-            if constexpr (name == std::remove_reference_t<decltype(method)>::name_v) {
-               method.callback = callback;
+         methods.any([&](auto&& method) -> bool {
+            using M = std::decay_t<decltype(method)>;
+            if constexpr (name == M::name_v) {
+               using result_t = typename M::result_t;
+               using params_t = typename M::params_t;
+               using expected_t = expected<result_t, rpc::error>;
+               if constexpr (std::is_invocable_r_v<result_t, decltype(callback), const params_t&>) {
+                  method.callback = [=](const params_t& params) -> expected_t { return callback(params); };
+               }
+               else if constexpr (std::is_invocable_r_v<rpc::error, decltype(callback), const params_t&>) {
+                  method.callback = [=](const params_t& params) -> expected_t {
+                     return glz::unexpected{callback(params)};
+                  };
+               }
+               else {
+                  static_assert(false_v<M>, "Method supplied is not invocable with registered types");
+               }
                return true;
             }
             else {
@@ -234,20 +247,20 @@ namespace glz::rpc
       template <class T, T value>
       struct index_of_name<T, value>
       {
-         static constexpr std::size_t index = std::numeric_limits<size_t>::max();
+         static constexpr std::size_t index = (std::numeric_limits<size_t>::max)();
       };
 
-      template <class map_t, basic_fixed_string name, class... method_type>
-      auto get_request_map(glz::tuplet::tuple<method_type...>& methods) -> map_t&
+      template <class Map, string_literal Name, class... Method>
+      auto get_request_map(glz::tuplet::tuple<Method...>& methods) -> Map&
       {
-         constexpr bool method_found = ((method_type::name_v == name) || ...);
+         constexpr bool method_found = ((Method::name_v == Name) || ...);
          static_assert(method_found, "Method not declared in client.");
 
-         map_t* return_ptr{nullptr};
+         Map* return_ptr{nullptr};
 
          methods.any([&return_ptr](auto&& method) -> bool {
             using meth_t = std::remove_reference_t<decltype(method)>;
-            if constexpr (name == meth_t::name_v) {
+            if constexpr (Name == meth_t::name_v) {
                return_ptr = &method.pending_requests;
                return true; // break methods loop
             }
@@ -262,21 +275,21 @@ namespace glz::rpc
       }
    }
 
-   template <concepts::method_type... method_type>
+   template <concepts::method_type... Method>
    struct server
    {
       using raw_response_t = response_t<glz::raw_json>;
 
-      glz::tuplet::tuple<server_method_t<method_type>...> methods{};
+      glz::tuplet::tuple<server_method_t<Method>...> methods{};
 
-      template <basic_fixed_string name>
+      template <string_literal name>
       constexpr void on(const auto& callback) // std::function<expected<result_t, rpc::error>(params_t const&)>
       {
          detail::set_callback<name>(methods, callback);
       }
 
       using raw_call_return_t = std::vector<raw_response_t>;
-      // Return json stringified std::vector<response_t> meaning it can both be error and non-error and batch request
+      // Return JSON stringified std::vector<response_t> meaning it can both be error and non-error and batch request
       // response. If `id` is null in json_request a response will not be generated
       // If you would like to handle errors for each request:
       // auto response_vector = server.call<decltype(server_instance)::raw_call_return_t>("...");
@@ -284,16 +297,15 @@ namespace glz::rpc
       template <concepts::call_return_type return_t = std::string>
       return_t call(std::string_view json_request)
       {
-         constexpr auto return_helper = []<typename input_type>(input_type && response) -> auto
-         {
+         constexpr auto return_helper = []<class Input>(Input&& response) -> auto {
             if constexpr (std::same_as<return_t, std::string>) {
-               return glz::write_json(std::forward<input_type>(response));
+               return glz::write_json(std::forward<Input>(response));
             }
-            else if constexpr (std::same_as<input_type, raw_response_t>) {
-               return std::vector<raw_response_t>{std::forward<input_type>(response)};
+            else if constexpr (std::same_as<Input, raw_response_t>) {
+               return std::vector<raw_response_t>{std::forward<Input>(response)};
             }
             else {
-               return std::forward<input_type>(response);
+               return std::forward<Input>(response);
             }
          };
 
@@ -385,10 +397,10 @@ namespace glz::rpc
       }
    };
 
-   template <concepts::method_type... method_type>
+   template <concepts::method_type... Method>
    struct client
    {
-      glz::tuplet::tuple<client_method_t<method_type>...> methods{};
+      glz::tuplet::tuple<client_method_t<Method>...> methods{};
 
       rpc::error call(std::string_view json_response)
       {
@@ -450,22 +462,21 @@ namespace glz::rpc
       // const&)> where result_t is the result type declared for the given method name returns the request string and
       // whether the callback was inserted into the queue if the callback was not inserted into the queue it can mean
       // that the input was a notification or more serious, conflicting id, the provided id should be unique!
-      template <basic_fixed_string method_name>
+      template <string_literal Name>
       [[nodiscard]] std::pair<std::string, bool> request(id_t&& id, auto&& params, auto&& callback)
       {
-         constexpr bool method_found = ((method_type::name_v == method_name) || ...);
+         constexpr bool method_found = ((Method::name_v == Name) || ...);
          static_assert(method_found, "Method not declared in client.");
 
-         using params_type = std::remove_cvref_t<decltype(params)>;
-         constexpr bool params_type_found = (std::is_same_v<typename method_type::params_t, params_type> || ...);
+         using Params = std::remove_cvref_t<decltype(params)>;
+         constexpr bool params_type_found = (std::is_same_v<typename Method::params_t, Params> || ...);
          static_assert(params_type_found, "Input parameters do not match constructed client parameter types.");
 
          constexpr bool method_params_match =
-            ((method_type::name_v == method_name && std::is_same_v<typename method_type::params_t, params_type>) ||
-             ...);
+            ((Method::name_v == Name && std::is_same_v<typename Method::params_t, Params>) || ...);
          static_assert(method_params_match, "Method name and given params type do not match.");
 
-         rpc::request_t req{std::forward<decltype(id)>(id), method_name.view(), std::forward<decltype(params)>(params)};
+         rpc::request_t req{std::forward<decltype(id)>(id), Name.sv(), std::forward<decltype(params)>(params)};
 
          if (std::holds_alternative<glz::json_t::null_t>(id)) {
             return {glz::write_json(std::move(req)), false};
@@ -475,9 +486,9 @@ namespace glz::rpc
          bool inserted{false};
          methods.any([&inserted, &req, cb = std::forward<decltype(callback)>(callback)](auto&& method) -> bool {
             using meth_t = std::remove_reference_t<decltype(method)>;
-            if constexpr (method_name == meth_t::name_v) {
+            if constexpr (Name == meth_t::name_v) {
                [[maybe_unused]] decltype(method.pending_requests.begin()) unused{}; // iterator_t
-               std::tie(unused, inserted) = method.pending_requests.emplace(std::make_pair(req.id, cb));
+               std::tie(unused, inserted) = method.pending_requests.emplace(std::pair{req.id, cb});
                return true; // break methods loop
             }
             else {
@@ -488,29 +499,29 @@ namespace glz::rpc
          return {glz::write_json(std::move(req)), inserted};
       }
 
-      template <basic_fixed_string method_name>
+      template <string_literal Name>
       [[nodiscard]] auto notify(auto&& params) -> std::string
       {
          auto placebo{[](auto&, auto&) {}};
-         return request<method_name>(glz::json_t::null_t{}, params, std::move(placebo)).first;
+         return request<Name>(glz::json_t::null_t{}, params, std::move(placebo)).first;
       }
 
-      template <basic_fixed_string method_name>
+      template <string_literal Name>
       [[nodiscard]] const auto& get_request_map() const
       {
-         constexpr auto idx = detail::index_of_name<decltype(method_name), method_name, method_type...>::index;
-         using method_element = std::tuple_element_t<idx, std::tuple<client_method_t<method_type>...>>;
+         constexpr auto idx = detail::index_of_name<decltype(Name), Name, Method...>::index;
+         using method_element = std::tuple_element_t<idx, std::tuple<client_method_t<Method>...>>;
          using request_map_t = decltype(method_element().pending_requests);
-         return detail::get_request_map<request_map_t, method_name>(methods);
+         return detail::get_request_map<request_map_t, Name>(methods);
       }
 
-      template <basic_fixed_string method_name>
+      template <string_literal Name>
       [[nodiscard]] auto& get_request_map()
       {
-         constexpr auto idx = detail::index_of_name<decltype(method_name), method_name, method_type...>::index;
-         using method_element = std::tuple_element_t<idx, std::tuple<client_method_t<method_type>...>>;
+         constexpr auto idx = detail::index_of_name<decltype(Name), Name, Method...>::index;
+         using method_element = std::tuple_element_t<idx, std::tuple<client_method_t<Method>...>>;
          using request_map_t = decltype(method_element().pending_requests);
-         return detail::get_request_map<request_map_t, method_name>(methods);
+         return detail::get_request_map<request_map_t, Name>(methods);
       }
    };
 } // namespace glz::rpc
diff --git a/src/core/include/glaze/file/file_ops.hpp b/src/core/include/glaze/file/file_ops.hpp
index 04745aa6..75c05e3f 100644
--- a/src/core/include/glaze/file/file_ops.hpp
+++ b/src/core/include/glaze/file/file_ops.hpp
@@ -12,10 +12,8 @@
 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, std::ifstream& file) noexcept
    {
-      std::ifstream file{std::string(file_name)};
-
       if (!file) {
          return error_code::file_open_failure;
       }
@@ -29,6 +27,20 @@ namespace glz
       return {};
    }
 
+   template <class T>
+   [[nodiscard]] error_code file_to_buffer(T& buffer, const std::string& file_name) noexcept
+   {
+      std::ifstream file(file_name, std::ios::binary);
+      return file_to_buffer(buffer, file);
+   }
+
+   template <class T>
+   [[nodiscard]] error_code file_to_buffer(T& buffer, const std::string_view file_name) noexcept
+   {
+      std::ifstream file(std::string(file_name), std::ios::binary);
+      return file_to_buffer(buffer, file);
+   }
+
    template <class T>
    std::string file_to_buffer(T&& file_name) noexcept
    {
diff --git a/src/core/include/glaze/file/hostname_include.hpp b/src/core/include/glaze/file/hostname_include.hpp
new file mode 100644
index 00000000..10ac69d6
--- /dev/null
+++ b/src/core/include/glaze/file/hostname_include.hpp
@@ -0,0 +1,131 @@
+// Glaze Library
+// For the license information refer to glaze.hpp
+
+#pragma once
+
+#ifdef _WIN32
+#include <winsock2.h>
+#pragma comment(lib, "ws2_32.lib")
+#else
+#include <unistd.h>
+#endif
+
+#include "glaze/core/common.hpp"
+
+namespace glz
+{
+   namespace detail
+   {
+      template <class T>
+      struct hostname_includer
+      {
+         T& value;
+
+         static constexpr auto glaze_includer = true;
+         static constexpr auto glaze_reflect = false;
+      };
+   }
+
+   template <class T>
+   struct meta<detail::hostname_includer<T>>
+   {
+      static constexpr std::string_view name = detail::join_v<chars<"hostname_includer<">, name_v<T>, chars<">">>;
+   };
+
+   // Register this with an object to allow file including based on the hostname
+   // This is useful for configuration files that should be specific to a host
+   struct hostname_include final
+   {
+      bool reflection_helper{}; // needed for count_members
+      static constexpr auto glaze_includer = true;
+      static constexpr auto glaze_reflect = false;
+
+      constexpr decltype(auto) operator()(auto&& value) const noexcept
+      {
+         using V = std::decay_t<decltype(value)>;
+         return detail::hostname_includer<V>{value};
+      }
+   };
+
+   namespace detail
+   {
+      inline void replace_first_braces(std::string& original, const std::string& replacement) noexcept
+      {
+         static constexpr std::string_view braces = "{}";
+
+         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]{};
+
+#ifdef _WIN32
+         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 {};
+         }
+
+#ifdef _WIN32
+         WSACleanup();
+#endif
+
+         return {hostname};
+      }
+
+      template <class T>
+      struct from_json<hostname_includer<T>>
+      {
+         template <auto Opts>
+         static void op(auto&& value, is_context auto&& ctx, auto&& it, auto&& end) noexcept
+         {
+            std::string& path = string_buffer();
+            read<json>::op<Opts>(path, ctx, it, end);
+            if (bool(ctx.error)) [[unlikely]]
+               return;
+
+            replace_first_braces(path, 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{path});
+
+            std::string& buffer = path;
+            const auto string_file_path = file_path.string();
+            const auto ec = file_to_buffer(buffer, string_file_path);
+
+            if (bool(ec)) [[unlikely]] {
+               ctx.error = ec;
+               return;
+            }
+
+            const auto current_file = ctx.current_file;
+            ctx.current_file = string_file_path;
+
+            std::ignore = glz::read<Opts>(value.value, buffer, ctx);
+            if (bool(ctx.error)) [[unlikely]]
+               return;
+
+            ctx.current_file = current_file;
+         }
+      };
+
+      template <class T>
+      struct to_json<hostname_includer<T>>
+      {
+         template <auto Opts>
+         GLZ_ALWAYS_INLINE static void op(auto&&...) noexcept
+         {}
+      };
+   }
+}
diff --git a/src/core/include/glaze/glaze.hpp b/src/core/include/glaze/glaze.hpp
index e67bf9f3..41eedde5 100644
--- a/src/core/include/glaze/glaze.hpp
+++ b/src/core/include/glaze/glaze.hpp
@@ -1,7 +1,7 @@
 /*
   Glaze Library
 
-  Copyright (c) 2019 - present, Anyar Inc.
+  Copyright (c) 2019 - present, Stephen Berry
 
   Permission is hereby granted, free of charge, to any person obtaining
   a copy of this software and associated documentation files (the
@@ -41,74 +41,20 @@
 namespace glz
 {
    template <class T>
-   inline parse_error read_file(T& value, const sv file_name, auto&& buffer) noexcept
+   [[deprecated(
+      "Use specific read_file_json, etc. This old version was a bad design and would instatiate all "
+      "formats")]] inline parse_error
+   read_file(T&, const sv, auto&&) noexcept
    {
-      context ctx{};
-      ctx.current_file = file_name;
-
-      std::filesystem::path path{file_name};
-
-      const auto ec = file_to_buffer(buffer, ctx.current_file);
-
-      if (bool(ec)) {
-         return {ec};
-      }
-
-      if (path.has_extension()) {
-         const auto extension = path.extension().string();
-
-         if (extension == ".json" || extension == ".jsonc") {
-            return read<opts{}>(value, buffer, ctx);
-         }
-         else if (extension == ".beve") {
-            return read<opts{.format = binary}>(value, buffer, ctx);
-         }
-         else {
-            return {error_code::file_extension_not_supported};
-         }
-      }
-      else {
-         return {error_code::could_not_determine_extension};
-      }
+      return {};
    }
 
    template <class T>
-   [[nodiscard]] inline write_error write_file(T& value, const sv file_name, auto&& buffer) noexcept
+   [[deprecated(
+      "Use specific write_file_json, etc. This old version was a bad design and would instatiate all "
+      "formats")]] [[nodiscard]] inline write_error
+   write_file(T&, const sv, auto&&) noexcept
    {
-      context ctx{};
-      ctx.current_file = file_name;
-
-      std::filesystem::path path{file_name};
-
-      if (path.has_extension()) {
-         const auto extension = path.extension().string();
-
-         if (extension == ".json") {
-            write<opts{}>(value, buffer, ctx);
-         }
-         else if (extension == ".jsonc") {
-            write<opts{.comments = true}>(value, buffer, ctx);
-         }
-         else if (extension == ".beve") {
-            write<opts{.format = binary}>(value, buffer, ctx);
-         }
-         else {
-            return {error_code::file_extension_not_supported};
-         }
-      }
-      else {
-         return {error_code::could_not_determine_extension};
-      }
-
-      std::ofstream file(std::string{file_name});
-
-      if (file) {
-         file << buffer;
-      }
-      else {
-         return {error_code::file_open_failure};
-      }
-
       return {};
    }
 }
diff --git a/src/core/include/glaze/glaze_exceptions.hpp b/src/core/include/glaze/glaze_exceptions.hpp
index 1b71c07f..894c4b19 100644
--- a/src/core/include/glaze/glaze_exceptions.hpp
+++ b/src/core/include/glaze/glaze_exceptions.hpp
@@ -43,7 +43,9 @@ namespace glz::ex
 namespace glz::ex
 {
    template <class T>
-   void read_file(T& value, const sv file_name, auto&& buffer)
+   [[deprecated(
+      "Use specific read_file_json, etc. This old version was a bad design and would instatiate all formats")]] void
+   read_file(T& value, const sv file_name, auto&& buffer)
    {
       const auto ec = glz::read_file(value, file_name, buffer);
       if (ec == glz::error_code::file_open_failure) {
@@ -55,7 +57,9 @@ namespace glz::ex
    }
 
    template <class T>
-   void write_file(T& value, const sv file_name, auto&& buffer)
+   [[deprecated(
+      "Use specific read_file_json, etc. This old version was a bad design and would instatiate all formats")]] void
+   write_file(T& value, const sv file_name, auto&& buffer)
    {
       const auto ec = glz::write_file(value, file_name, buffer);
       if (ec == glz::error_code::file_open_failure) {
diff --git a/src/core/include/glaze/json/custom.hpp b/src/core/include/glaze/json/custom.hpp
index 0aaabbfb..5b5e56c2 100644
--- a/src/core/include/glaze/json/custom.hpp
+++ b/src/core/include/glaze/json/custom.hpp
@@ -16,6 +16,7 @@ namespace glz
       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;
@@ -36,7 +37,10 @@ namespace glz
             using V = std::decay_t<decltype(value)>;
             using From = typename V::from_t;
 
-            if constexpr (std::is_member_pointer_v<From>) {
+            if constexpr (std::same_as<From, skip>) {
+               skip_value<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>) {
@@ -100,7 +104,46 @@ namespace glz
                }
             }
             else {
-               read<json>::op<Opts>(get_member(value.val, value.from), ctx, it, end);
+               if constexpr (is_lambda_concrete<From>) {
+                  using Ret = lambda_result_t<From>;
+                  if constexpr (std::is_void_v<Ret>) {
+                     using Tuple = lambda_args_t<From>;
+                     constexpr auto N = std::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<Opts>(ctx, it, end);
+                        if (bool(ctx.error)) [[unlikely]]
+                           return;
+                        value.from(value.val);
+                     }
+                     else if constexpr (N == 2) {
+                        std::decay_t<std::tuple_element_t<1, Tuple>> input{};
+                        read<json>::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<json>::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.");
+               }
             }
          }
       };
@@ -153,13 +196,19 @@ namespace glz
                }
             }
             else {
-               write<json>::op<Opts>(get_member(value.val, value.to), ctx, args...);
+               if constexpr (std::invocable<To, decltype(value.val)>) {
+                  write<json>::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");
+               }
             }
          }
       };
 
       template <auto From, auto To>
-      inline constexpr decltype(auto) custom_impl() noexcept
+      inline constexpr auto custom_impl() noexcept
       {
          return [](auto&& v) { return custom_t{v, From, To}; };
       }
diff --git a/src/core/include/glaze/json/invoke.hpp b/src/core/include/glaze/json/invoke.hpp
index 0e766d25..8a11d26c 100644
--- a/src/core/include/glaze/json/invoke.hpp
+++ b/src/core/include/glaze/json/invoke.hpp
@@ -160,11 +160,11 @@ namespace glz
 
    template <class T>
    concept is_invoke_update = requires {
-                                 T::func;
-                                 T::prev;
-                                 T::initialized;
-                                 T::glaze;
-                              };
+      T::func;
+      T::prev;
+      T::initialized;
+      T::glaze;
+   };
 
    namespace detail
    {
diff --git a/src/core/include/glaze/json/json_ptr.hpp b/src/core/include/glaze/json/json_ptr.hpp
index 1941fc14..06d14d5d 100644
--- a/src/core/include/glaze/json/json_ptr.hpp
+++ b/src/core/include/glaze/json/json_ptr.hpp
@@ -21,19 +21,19 @@ namespace glz
    {
       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);
+                  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);
+         requires nullable_t<std::decay_t<T>>
+      bool seek_impl(F&& func, T&& value, sv json_ptr) noexcept;
 
       template <class F, class T>
-         requires readable_map_t<std::decay_t<T>> || glaze_object_t<T> bool
-      seek_impl(F&& func, T&& value, sv json_ptr);
+         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;
 
       template <class F, class T>
-      bool seek_impl(F&& func, T&& value, sv json_ptr)
+      bool seek_impl(F&& func, T&& value, sv json_ptr) noexcept
       {
          if (json_ptr.empty()) {
             func(value);
@@ -44,8 +44,8 @@ namespace glz
 
       // 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> bool
-      seek_impl(F&& func, T&& value, sv json_ptr)
+         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
       {
          if (json_ptr.empty()) {
             func(value);
@@ -97,27 +97,30 @@ namespace glz
             json_ptr = json_ptr.substr(p - json_ptr.data());
          }
 
-         if constexpr (glaze_object_t<T>) {
-            static constexpr auto frozen_map = detail::make_map<T>();
+         if constexpr (glaze_object_t<T> || reflectable<T>) {
+            decltype(auto) frozen_map = [&] {
+               if constexpr (reflectable<T>) {
+                  static constinit auto cmap = make_map<T>();
+                  populate_map(value, cmap); // Function required for MSVC to build
+                  return cmap;
+               }
+               else {
+                  static constexpr auto cmap = make_map<T>();
+                  return cmap;
+               }
+            }();
+
             const auto& member_it = frozen_map.find(key);
-            if (member_it != frozen_map.end()) {
+            if (member_it != frozen_map.end()) [[likely]] {
                return std::visit(
                   [&](auto&& member_ptr) {
-                     using V = std::decay_t<decltype(member_ptr)>;
-                     if constexpr (std::is_member_object_pointer_v<V>) {
-                        return seek_impl(std::forward<F>(func), value.*member_ptr, json_ptr);
-                     }
-                     else if constexpr (std::is_member_function_pointer_v<V>) {
-                        return seek_impl(std::forward<F>(func), member_ptr, json_ptr);
-                     }
-                     else {
-                        return seek_impl(std::forward<F>(func), member_ptr(value), json_ptr);
-                     }
+                     return seek_impl(std::forward<F>(func), get_member(value, member_ptr), json_ptr);
                   },
                   member_it->second);
             }
-            else
+            else [[unlikely]] {
                return false;
+            }
          }
          else {
             return seek_impl(std::forward<F>(func), value[key], json_ptr);
@@ -126,8 +129,8 @@ namespace glz
 
       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)
+                  is_std_tuple<std::decay_t<T>>
+      bool seek_impl(F&& func, T&& value, sv json_ptr) noexcept
       {
          if (json_ptr.empty()) {
             func(value);
@@ -162,8 +165,8 @@ namespace glz
       }
 
       template <class F, class T>
-         requires nullable_t<std::decay_t<T>> bool
-      seek_impl(F&& func, T&& value, sv json_ptr)
+         requires nullable_t<std::decay_t<T>>
+      bool seek_impl(F&& func, T&& value, sv json_ptr) noexcept
       {
          if (json_ptr.empty()) {
             func(value);
@@ -176,7 +179,7 @@ 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)
+   bool seek(F&& func, T&& value, sv json_ptr) noexcept
    {
       return detail::seek_impl(std::forward<F>(func), std::forward<T>(value), json_ptr);
    }
@@ -245,7 +248,7 @@ namespace glz
    // Get a refrence 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>, parse_error> get(T&& root_value, sv json_ptr)
+   expected<std::reference_wrapper<V>, parse_error> get(T&& root_value, sv json_ptr) noexcept
    {
       V* result{};
       error_code ec{};
@@ -274,7 +277,7 @@ 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)
+   V* get_if(T&& root_value, sv json_ptr) noexcept
    {
       V* result{};
       detail::seek_impl(
@@ -320,7 +323,7 @@ namespace glz
    // Assign to a value at the location of a json_ptr with respect to the root_value
    // if assignable and not a narrowing conversion
    template <class T, class V>
-   bool set(T&& root_value, const sv json_ptr, V&& value)
+   bool set(T&& root_value, const sv json_ptr, V&& value) noexcept
    {
       bool result{};
       detail::seek_impl(
@@ -439,20 +442,18 @@ namespace glz
    template <size_t N, auto& Arr>
    inline constexpr auto sub_group(const auto start)
    {
-      constexpr auto arr = Arr; // Msvc currently generates an internal compiler error otherwise
       std::array<sv, N> ret;
-      std::transform(arr.begin() + start, arr.begin() + start + N, ret.begin(), remove_first_key);
+      std::transform(Arr.begin() + start, Arr.begin() + start + N, ret.begin(), remove_first_key);
       return ret;
    }
 
    template <auto& Arr>
    inline constexpr auto group_json_ptrs()
    {
-      constexpr auto arr = Arr; // Msvc currently generates an internal compiler error otherwise
-      constexpr auto group_info = group_json_ptrs_impl(arr);
-      constexpr auto n_items_per_group = glz::tuplet::get<0>(group_info);
-      constexpr auto n_unique = glz::tuplet::get<1>(group_info);
-      constexpr auto unique_keys = glz::tuplet::get<2>(group_info);
+      constexpr auto group_info = group_json_ptrs_impl(Arr);
+      constexpr auto n_items_per_group = glz::get<0>(group_info);
+      constexpr auto n_unique = glz::get<1>(group_info);
+      constexpr auto unique_keys = glz::get<2>(group_info);
 
       auto arrs = make_arrays<n_items_per_group>(std::make_index_sequence<n_unique>{});
       size_t start{};
@@ -460,10 +461,10 @@ namespace glz
       for_each<n_unique>([&](auto I) {
          // NOTE: VS 2019 wont let us grab n_items_per_group as constexpr unless
          // its static but this is a constexpr func This is fixed in VS 2022
-         constexpr size_t n_items = std::tuple_size_v<std::decay_t<decltype(glz::tuplet::get<I>(arrs).second)>>;
+         constexpr size_t n_items = std::tuple_size_v<std::decay_t<decltype(glz::get<I>(arrs).second)>>;
 
-         glz::tuplet::get<I>(arrs).first = unique_keys[I];
-         glz::tuplet::get<I>(arrs).second = glz::sub_group<n_items, Arr>(start);
+         glz::get<I>(arrs).first = unique_keys[I];
+         glz::get<I>(arrs).second = glz::sub_group<n_items, Arr>(start);
          start += n_items_per_group[I];
       });
 
@@ -598,7 +599,7 @@ namespace glz
                      const auto k = parse_key(ctx, it, end);
                      if (cx_string_cmp<key>(k)) {
                         skip_ws<Opts>(ctx, it, end);
-                        match<':'>(ctx, it, end);
+                        match<':'>(ctx, it);
                         skip_ws<Opts>(ctx, it, end);
 
                         if constexpr (I == (N - 1)) {
@@ -642,7 +643,7 @@ namespace glz
                }
             }
             else {
-               match<'{'>(ctx, it, end);
+               match<'{'>(ctx, it);
 
                while (true) {
                   skip_ws<Opts>(ctx, it, end);
@@ -655,7 +656,7 @@ namespace glz
                   else {
                      if (cx_string_cmp<key>(k)) {
                         skip_ws<Opts>(ctx, it, end);
-                        match<':'>(ctx, it, end);
+                        match<':'>(ctx, it);
                         skip_ws<Opts>(ctx, it, end);
 
                         if constexpr (I == (N - 1)) {
diff --git a/src/core/include/glaze/json/json_t.hpp b/src/core/include/glaze/json/json_t.hpp
index d54ab7e4..67666129 100644
--- a/src/core/include/glaze/json/json_t.hpp
+++ b/src/core/include/glaze/json/json_t.hpp
@@ -39,7 +39,7 @@ namespace glz
       template <class T>
       T* get_if() noexcept
       {
-         return std::get_if<T>(data);
+         return std::get_if<T>(&data);
       }
 
       template <class T>
diff --git a/src/core/include/glaze/json/manage.hpp b/src/core/include/glaze/json/manage.hpp
index 275b2ddc..978d1730 100644
--- a/src/core/include/glaze/json/manage.hpp
+++ b/src/core/include/glaze/json/manage.hpp
@@ -15,6 +15,7 @@ namespace glz
       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;
diff --git a/src/core/include/glaze/json/ndjson.hpp b/src/core/include/glaze/json/ndjson.hpp
index 50ad512e..08c7d92e 100644
--- a/src/core/include/glaze/json/ndjson.hpp
+++ b/src/core/include/glaze/json/ndjson.hpp
@@ -87,6 +87,9 @@ namespace glz
             if constexpr (emplace_backable<T>) {
                while (it < end) {
                   read<json>::op<Opts>(value.emplace_back(), ctx, it, end);
+                  if (bool(ctx.error)) {
+                     return;
+                  }
 
                   read_new_lines();
                }
@@ -144,10 +147,10 @@ namespace glz
                   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::tuplet::get<I>(meta_v<T>)), ctx, it, end);
+                  read<json>::op<Opts>(get_member(value, glz::get<I>(meta_v<T>)), ctx, it, end);
                }
                else {
-                  read<json>::op<Opts>(glz::tuplet::get<I>(value), ctx, it, end);
+                  read<json>::op<Opts>(glz::get<I>(value), ctx, it, end);
                }
             });
          }
@@ -215,11 +218,10 @@ namespace glz
             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::tuplet::get<I>(meta_v<T>)), ctx,
-                                        std::forward<Args>(args)...);
+                  write<json>::op<Opts>(get_member(value, glz::get<I>(meta_v<T>)), ctx, std::forward<Args>(args)...);
                }
                else {
-                  write<json>::op<Opts>(glz::tuplet::get<I>(value), ctx, std::forward<Args>(args)...);
+                  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) {
diff --git a/src/core/include/glaze/json/read.hpp b/src/core/include/glaze/json/read.hpp
index cd0f688f..ce58c373 100644
--- a/src/core/include/glaze/json/read.hpp
+++ b/src/core/include/glaze/json/read.hpp
@@ -10,7 +10,7 @@
 #include <iterator>
 #include <locale>
 #include <ranges>
-#include <sstream>
+#include <type_traits>
 
 #include "glaze/core/common.hpp"
 #include "glaze/core/format.hpp"
@@ -18,6 +18,7 @@
 #include "glaze/file/file_ops.hpp"
 #include "glaze/json/json_t.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/type_traits.hpp"
@@ -25,6 +26,11 @@
 
 namespace glz
 {
+
+   // forward declare from json/quoted.hpp to avoid circular include
+   template <class T>
+   struct quoted_t;
+
    namespace detail
    {
       // Unless we can mutate the input buffer we need somewhere to store escaped strings for key lookup and such
@@ -32,7 +38,7 @@ namespace glz
       // not allowed or restricted
       GLZ_ALWAYS_INLINE std::string& string_buffer() noexcept
       {
-         static thread_local std::string buffer(128, ' ');
+         static thread_local std::string buffer(256, ' ');
          return buffer;
       }
 
@@ -41,11 +47,10 @@ namespace glz
       {};
 
       template <auto Opts, class T, class Ctx, class It0, class It1>
-      concept read_json_invocable =
-         requires(T&& value, Ctx&& ctx, It0&& it, It1&& end) {
-            from_json<std::remove_cvref_t<T>>::template op<Opts>(std::forward<T>(value), std::forward<Ctx>(ctx),
-                                                                 std::forward<It0>(it), std::forward<It1>(end));
-         };
+      concept read_json_invocable = requires(T&& value, Ctx&& ctx, It0&& it, It1&& end) {
+         from_json<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 <>
       struct read<json>
@@ -73,17 +78,62 @@ namespace glz
                }
             }
          }
+
+         // 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 (std::tuple_size_v<TupleType> == 2) {
+                        std::decay_t<std::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 {
+                     static_assert(false_v<T>, "method must have void return");
+                  }
+               }
+               else {
+                  static_assert(false_v<T>, "unknown_read type not handled");
+               }
+            }
+            else {
+               skip_value<Opts>(ctx, it, end);
+            }
+         }
       };
 
       template <glaze_value_t T>
       struct from_json<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
+         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<T>(), meta_wrapper_v<T>))>;
-            from_json<V>::template op<Opts>(get_member(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));
          }
       };
 
@@ -97,6 +147,44 @@ namespace glz
          }
       };
 
+      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
+         {
+            match<'"'>(ctx, it);
+            if (bool(ctx.error)) [[unlikely]]
+               return;
+
+            const auto n = value.size();
+            for (size_t i = 1; it < end; ++i, ++it) {
+               if (*it == '"') {
+                  ++it;
+                  return;
+               }
+
+               if (i > n) {
+                  ctx.error = error_code::exceeded_static_array_size;
+                  return;
+               }
+
+               if (*it == '0') {
+                  value[n - i] = 0;
+               }
+               else if (*it == '1') {
+                  value[n - i] = 1;
+               }
+               else [[unlikely]] {
+                  ctx.error = error_code::syntax_error;
+                  return;
+               }
+            }
+
+            ctx.error = error_code::expected_quote;
+         }
+      };
+
       template <>
       struct from_json<skip>
       {
@@ -152,6 +240,8 @@ namespace glz
                return;
 
             match<",">(ctx, args...);
+            if (bool(ctx.error)) [[unlikely]]
+               return;
 
             read<json>::op<Opts>(ptr[1], ctx, args...);
 
@@ -184,8 +274,12 @@ namespace glz
          GLZ_ALWAYS_INLINE static void op(bool_t auto&& value, is_context auto&& ctx, auto&& it, auto&& end) noexcept
          {
             if constexpr (Opts.quoted_num) {
-               skip_ws<Opts>(ctx, it, end);
-               match<'"'>(ctx, it, end);
+               skip_ws_no_pre_check<Opts>(ctx, it, end);
+               if (bool(ctx.error)) [[unlikely]]
+                  return;
+               match<'"'>(ctx, it);
+               if (bool(ctx.error)) [[unlikely]]
+                  return;
             }
 
             if constexpr (!Opts.ws_handled) {
@@ -194,28 +288,33 @@ namespace glz
                   return;
             }
 
-            switch (*it) {
-            case 't': {
-               ++it;
-               value = true;
-               match<"rue">(ctx, it, end);
-               break;
+            if (std::distance(it, end) < 4) [[unlikely]] {
+               ctx.error = error_code::expected_true_or_false;
+               return;
             }
-            case 'f': {
-               ++it;
-               value = false;
-               match<"alse">(ctx, it, end);
-               break;
+
+            uint64_t c{};
+            // Note that because our buffer must be null terminated, we can read one more index without checking:
+            // std::distance(it, end) < 5
+            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 & 0b11111111'11111111'11111111'00000000'11111111'11111111'11111111'11111111) == u_true) {
+               value = true;
+               it += 4;
             }
-               [[unlikely]] default:
-               {
+            else {
+               if (c != u_false) [[unlikely]] {
                   ctx.error = error_code::expected_true_or_false;
                   return;
                }
+               value = false;
+               it += 5;
             }
 
             if constexpr (Opts.quoted_num) {
-               match<'"'>(ctx, it, end);
+               match<'"'>(ctx, it);
             }
          }
       };
@@ -228,7 +327,9 @@ namespace glz
          {
             if constexpr (Options.quoted_num) {
                skip_ws<Options>(ctx, it, end);
-               match<'"'>(ctx, it, end);
+               match<'"'>(ctx, it);
+               if (bool(ctx.error)) [[unlikely]]
+                  return;
             }
 
             if constexpr (!Options.ws_handled) {
@@ -239,23 +340,48 @@ namespace glz
 
             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>) {
-                  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;
+                  if constexpr (std::same_as<V, uint64_t>) {
+                     if (*it == '-') [[unlikely]] {
+                        ctx.error = error_code::parse_number_failure;
+                        return;
+                     }
+
+                     static_assert(sizeof(*it) == sizeof(char));
+                     const char* cur = reinterpret_cast<const char*>(&*it);
+                     const char* beg = cur;
+                     auto s = parse_int<V, Options.force_conformance>(value, cur);
+                     if (!s) [[unlikely]] {
+                        ctx.error = error_code::parse_number_failure;
+                        return;
+                     }
+
+                     it += (cur - beg);
                   }
+                  else {
+                     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;
+                     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)>, Options.force_conformance>(i, cur);
+                     if (!s) [[unlikely]] {
+                        ctx.error = error_code::parse_number_failure;
+                        return;
+                     }
+
+                     if (i > maximum) [[unlikely]] {
+                        ctx.error = error_code::parse_number_failure;
+                        return;
+                     }
+                     value = V(i);
+                     it += (cur - beg);
                   }
-                  value = static_cast<V>(i);
                }
                else {
                   uint64_t i{};
@@ -264,51 +390,58 @@ namespace glz
                      sign = -1;
                      ++it;
                   }
-                  auto e = stoui64<V>(i, it);
-                  if (!e) [[unlikely]] {
+
+                  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)>, Options.force_conformance>(i, cur);
+                  if (!s) [[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;
+                  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;
+                     }
+                     value = V(sign * i);
+                  }
+                  else {
+                     if (i > maximum) [[unlikely]] {
+                        ctx.error = error_code::parse_number_failure;
+                        return;
+                     }
+                     value = V(i);
                   }
-                  value = V(sign * V(i));
+                  it += (cur - beg);
                }
             }
             else {
-               // TODO: fix this
-               using X =
-                  std::conditional_t<std::is_const_v<std::remove_pointer_t<std::remove_reference_t<decltype(it)>>>,
-                                     const uint8_t*, uint8_t*>;
-               auto cur = reinterpret_cast<X>(it);
-               auto s = parse_float<V, Options.force_conformance>(value, cur);
-               if (!s) [[unlikely]] {
-                  ctx.error = error_code::parse_number_failure;
-                  return;
+               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 += std::distance(it, ptr);
+               }
+               else {
+                  auto s = parse_float<V, Options.force_conformance>(value, it);
+                  if (!s) [[unlikely]] {
+                     ctx.error = error_code::parse_number_failure;
+                     return;
+                  }
                }
-               it = reinterpret_cast<std::remove_reference_t<decltype(it)>>(cur);
             }
 
             if constexpr (Options.quoted_num) {
-               match<'"'>(ctx, it, end);
+               match<'"'>(ctx, it);
             }
          }
       };
 
-      /* Copyright (c) 2022 Tero 'stedo' Liukko, MIT License */
-      GLZ_ALWAYS_INLINE unsigned char hex2dec(char hex) { return ((hex & 0xf) + (hex >> 6) * 9); }
-
-      GLZ_ALWAYS_INLINE char32_t hex4_to_char32(const char* hex)
-      {
-         uint32_t value = hex2dec(hex[3]);
-         value |= hex2dec(hex[2]) << 4;
-         value |= hex2dec(hex[1]) << 8;
-         value |= hex2dec(hex[0]) << 12;
-         return value;
-      }
-
       template <class T, class Val, class It, class End>
       GLZ_ALWAYS_INLINE void read_escaped_unicode(Val& value, is_context auto&& ctx, It&& it, End&& end)
       {
@@ -411,7 +544,10 @@ namespace glz
             if constexpr (Opts.number) {
                auto start = it;
                skip_number<Opts>(ctx, it, end);
-               value.append(start, static_cast<size_t>(it - start));
+               if (bool(ctx.error)) [[unlikely]] {
+                  return;
+               }
+               value.append(start, size_t(it - start));
             }
             else {
                if constexpr (!Opts.opening_handled) {
@@ -421,7 +557,7 @@ namespace glz
                         return;
                   }
 
-                  match<'"'>(ctx, it, end);
+                  match<'"'>(ctx, it);
                   if (bool(ctx.error)) [[unlikely]]
                      return;
                }
@@ -438,106 +574,45 @@ namespace glz
                   ++it;
                }
                else {
-                  auto handle_escaped = [&]() {
-                     switch (*it) {
-                     case '"':
-                     case '\\':
-                     case '/':
-                        value.push_back(*it);
-                        ++it;
-                        break;
-                     case 'b':
-                        value.push_back('\b');
-                        ++it;
-                        break;
-                     case 'f':
-                        value.push_back('\f');
-                        ++it;
-                        break;
-                     case 'n':
-                        value.push_back('\n');
-                        ++it;
-                        break;
-                     case 'r':
-                        value.push_back('\r');
-                        ++it;
-                        break;
-                     case 't':
-                        value.push_back('\t');
-                        ++it;
-                        break;
-                     case 'u': {
-                        ++it;
-                        read_escaped_unicode<char>(value, ctx, it, end);
-                        return;
-                     }
-                     default: {
-                        ctx.error = error_code::invalid_escape;
-                        return;
-                     }
-                     }
-                  };
-
-                  value.clear(); // Single append on unescaped strings so overwrite opt isnt as important
                   auto start = it;
-                  while (it < end) {
-                     if constexpr (!Opts.force_conformance) {
-                        skip_till_escape_or_quote(ctx, it, end);
-                        if (bool(ctx.error)) [[unlikely]]
-                           return;
 
-                        if (*it == '"') [[likely]] {
-                           value.append(start, static_cast<size_t>(it - start));
-                           ++it;
-                           return;
-                        }
-                        else [[unlikely]] {
-                           value.append(start, static_cast<size_t>(it - start));
-                           ++it;
-                           handle_escaped();
-                           if (bool(ctx.error)) [[unlikely]]
-                              return;
-                           start = it;
-                        }
+                  const bool escaped = skip_till_unescaped_quote<Opts>(ctx, it, end);
+                  if (bool(ctx.error)) [[unlikely]]
+                     return;
+
+                  if (escaped) {
+                     static constexpr auto Bytes = 8;
+
+                     const auto length = round_up_to_multiple<Bytes>(size_t(it - start));
+                     value.resize(length);
+
+                     const char* c;
+                     if (length < size_t(end - it)) [[likely]] {
+                        c = parse_string<Bytes>(&*start, value.data(), ctx);
                      }
-                     else {
-                        switch (*it) {
-                        [[likely]] case '"' : {
-                           value.append(start, static_cast<size_t>(it - start));
-                           ++it;
-                           return;
-                        }
-                        [[unlikely]] case '\b':
-                        [[unlikely]] case '\f':
-                        [[unlikely]] case '\n':
-                        [[unlikely]] case '\r':
-                        [[unlikely]] case '\t' : {
-                           ctx.error = error_code::syntax_error;
-                           return;
-                        }
-                        [[unlikely]] case '\0' : {
-                           ctx.error = error_code::unexpected_end;
-                           return;
-                        }
-                        [[unlikely]] case '\\' : {
-                           value.append(start, static_cast<size_t>(it - start));
-                           ++it;
-                           handle_escaped();
-                           if (bool(ctx.error)) [[unlikely]]
-                              return;
-                           start = it;
-                           break;
-                        }
-                           [[likely]] default : ++it;
-                        }
+                     else [[unlikely]] {
+                        c = parse_string<1>(&*start, value.data(), ctx);
+                     }
+
+                     if (bool(ctx.error)) [[unlikely]] {
+                        it = c;
+                        return;
                      }
+
+                     value.resize(size_t(c - value.data()));
+                  }
+                  else {
+                     value = sv{start, size_t(it - start)};
                   }
+
+                  ++it;
                }
             }
          }
       };
 
-      template <char_array_t T>
+      template <class T>
+         requires(str_view_t<T> || char_array_t<T>)
       struct from_json<T>
       {
          template <auto Opts, class It, class End>
@@ -550,7 +625,7 @@ namespace glz
                      return;
                }
 
-               match<'"'>(ctx, it, end);
+               match<'"'>(ctx, it);
                if (bool(ctx.error)) [[unlikely]]
                   return;
             }
@@ -577,19 +652,20 @@ namespace glz
             };
 
             auto start = it;
+            [[maybe_unused]] auto write_to_char_buffer = [&] {
+               if constexpr (char_array_t<T>) {
+                  const size_t n = it - start - 1;
+                  sv str{start, n};
 
-            auto write_to_char_buffer = [&] {
-               const size_t n = it - start - 1;
-               sv str{start, n};
-
-               if ((sizeof(value) - 1) < n) {
-                  ctx.error = error_code::unexpected_end;
-                  return;
-               }
-               for (size_t i = 0; i < n; ++i) {
-                  value[i] = str[i];
+                  if ((sizeof(value) - 1) < n) {
+                     ctx.error = error_code::unexpected_end;
+                     return;
+                  }
+                  for (size_t i = 0; i < n; ++i) {
+                     value[i] = str[i];
+                  }
+                  value[n] = '\0';
                }
-               value[n] = '\0';
             };
 
             while (it < end) {
@@ -600,7 +676,12 @@ namespace glz
 
                   if (*it == '"') {
                      ++it;
-                     write_to_char_buffer();
+                     if constexpr (str_view_t<T>) {
+                        value = std::string_view{start, size_t(it - start - 1)};
+                     }
+                     else if constexpr (char_array_t<T>) {
+                        write_to_char_buffer();
+                     }
                      return;
                   }
                   else {
@@ -633,9 +714,14 @@ namespace glz
                      handle_escaped();
                      if (bool(ctx.error)) [[unlikely]]
                         return;
-                     write_to_char_buffer();
-                     if (bool(ctx.error)) [[unlikely]]
-                        return;
+                     if constexpr (str_view_t<T>) {
+                        value = std::string_view{start, size_t(it - start - 1)};
+                     }
+                     else if constexpr (char_array_t<T>) {
+                        write_to_char_buffer();
+                        if (bool(ctx.error)) [[unlikely]]
+                           return;
+                     }
                      break;
                   }
                   default:
@@ -643,15 +729,14 @@ namespace glz
                   }
                }
             }
-            return;
          }
       };
 
-      template <str_view_t T>
+      template <char_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>
+         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) {
@@ -660,173 +745,78 @@ namespace glz
                      return;
                }
 
-               match<'"'>(ctx, it, end);
+               match<'"'>(ctx, it);
                if (bool(ctx.error)) [[unlikely]]
                   return;
             }
 
-            // overwrite portion
-            auto handle_escaped = [&]() {
+            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':
-               case 'u': {
+                  value = '\t';
                   ++it;
                   break;
+               case 'u': {
+                  ++it;
+                  read_escaped_unicode<T>(value, ctx, it, end);
+                  return;
                }
                default: {
                   ctx.error = error_code::invalid_escape;
                   return;
                }
                }
-            };
+            }
+            else {
+               if (it == end) [[unlikely]] {
+                  ctx.error = error_code::unexpected_end;
+                  return;
+               }
+               value = *it++;
+            }
+            match<'"'>(ctx, it);
+         }
+      };
 
-            // growth portion
-            auto start = it;
-            while (it < end) {
-               if constexpr (!Opts.force_conformance) {
-                  skip_till_escape_or_quote(ctx, it, end);
-                  if (bool(ctx.error)) [[unlikely]]
-                     return;
+      template <glaze_enum_t 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
+         {
+            if constexpr (!Opts.ws_handled) {
+               skip_ws<Opts>(ctx, it, end);
+               if (bool(ctx.error)) [[unlikely]]
+                  return;
+            }
 
-                  if (*it == '"') {
-                     ++it;
-                     value = std::string_view{start, size_t(it - start - 1)};
-                     return;
-                  }
-                  else {
-                     ++it;
-                     handle_escaped();
-                     if (bool(ctx.error)) [[unlikely]]
-                        return;
-                  }
-               }
-               else {
-                  switch (*it) {
-                  case '"': {
-                     ++it;
-                     return;
-                  }
-                  case '\b':
-                  case '\f':
-                  case '\n':
-                  case '\r':
-                  case '\t': {
-                     ctx.error = error_code::syntax_error;
-                     return;
-                  }
-                  case '\0': {
-                     ctx.error = error_code::unexpected_end;
-                     return;
-                  }
-                  case '\\': {
-                     ++it;
-                     handle_escaped();
-                     if (bool(ctx.error)) [[unlikely]]
-                        return;
-                     value = sv{start, size_t(it - start - 1)};
-                     break;
-                  }
-                  default:
-                     ++it;
-                  }
-               }
-            }
-            return;
-         }
-      };
-
-      template <char_t 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
-         {
-            if constexpr (!Opts.opening_handled) {
-               if constexpr (!Opts.ws_handled) {
-                  skip_ws<Opts>(ctx, it, end);
-                  if (bool(ctx.error)) [[unlikely]]
-                     return;
-               }
-
-               match<'"'>(ctx, it, end);
-               if (bool(ctx.error)) [[unlikely]]
-                  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': {
-                  ++it;
-                  read_escaped_unicode<T>(value, ctx, it, end);
-                  return;
-               }
-               default: {
-                  ctx.error = error_code::invalid_escape;
-                  return;
-               }
-               }
-            }
-            else {
-               if (it == end) [[unlikely]] {
-                  ctx.error = error_code::unexpected_end;
-                  return;
-               }
-               value = *it++;
-            }
-            match<'"'>(ctx, it, end);
-         }
-      };
-
-      template <glaze_enum_t 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
-         {
-            if constexpr (!Opts.ws_handled) {
-               skip_ws<Opts>(ctx, it, end);
-               if (bool(ctx.error)) [[unlikely]]
-                  return;
-            }
-
-            const auto key = parse_key(ctx, it, end);
+            const auto key = parse_key(ctx, it, end); // TODO: Use more optimal enum key parsing
             if (bool(ctx.error)) [[unlikely]]
                return;
 
@@ -867,13 +857,13 @@ namespace glz
                if (bool(ctx.error)) [[unlikely]]
                   return;
             }
-            match<'"'>(ctx, it, end);
+            match<'"'>(ctx, it);
             if (bool(ctx.error)) [[unlikely]]
                return;
             skip_till_quote(ctx, it, end);
             if (bool(ctx.error)) [[unlikely]]
                return;
-            match<'"'>(ctx, it, end);
+            match<'"'>(ctx, it);
             if (bool(ctx.error)) [[unlikely]]
                return;
          }
@@ -908,10 +898,10 @@ namespace glz
             }
             static constexpr auto Opts = ws_handled_off<Options>();
 
-            match<'['>(ctx, it, end);
+            match<'['>(ctx, it);
             if (bool(ctx.error)) [[unlikely]]
                return;
-            skip_ws<Opts>(ctx, it, end);
+            skip_ws_no_pre_check<Opts>(ctx, it, end);
             if (bool(ctx.error)) [[unlikely]]
                return;
 
@@ -928,14 +918,14 @@ namespace glz
                if (bool(ctx.error)) [[unlikely]]
                   return;
                value.emplace(std::move(v));
-               skip_ws<Opts>(ctx, it, end);
+               skip_ws_no_pre_check<Opts>(ctx, it, end);
                if (bool(ctx.error)) [[unlikely]]
                   return;
                if (*it == ']') {
                   ++it;
                   return;
                }
-               match<','>(ctx, it, end);
+               match<','>(ctx, it);
                if (bool(ctx.error)) [[unlikely]]
                   return;
             }
@@ -956,10 +946,10 @@ namespace glz
             }
             static constexpr auto Opts = ws_handled_off<Options>();
 
-            match<'['>(ctx, it, end);
+            match<'['>(ctx, it);
             if (bool(ctx.error)) [[unlikely]]
                return;
-            skip_ws<Opts>(ctx, it, end);
+            skip_ws_no_pre_check<Opts>(ctx, it, end);
             if (bool(ctx.error)) [[unlikely]]
                return;
 
@@ -983,12 +973,12 @@ namespace glz
                read<json>::op<ws_handled<Opts>()>(*value_it++, ctx, it, end);
                if (bool(ctx.error)) [[unlikely]]
                   return;
-               skip_ws<Opts>(ctx, it, end);
+               skip_ws_no_pre_check<Opts>(ctx, it, end);
                if (bool(ctx.error)) [[unlikely]]
                   return;
                if (*it == ',') [[likely]] {
                   ++it;
-                  skip_ws<Opts>(ctx, it, end);
+                  skip_ws_no_pre_check<Opts>(ctx, it, end);
                   if (bool(ctx.error)) [[unlikely]]
                      return;
                }
@@ -1016,12 +1006,12 @@ namespace glz
                   read<json>::op<ws_handled<Opts>()>(value.emplace_back(), ctx, it, end);
                   if (bool(ctx.error)) [[unlikely]]
                      return;
-                  skip_ws<Opts>(ctx, it, end);
+                  skip_ws_no_pre_check<Opts>(ctx, it, end);
                   if (bool(ctx.error)) [[unlikely]]
                      return;
                   if (*it == ',') [[likely]] {
                      ++it;
-                     skip_ws<Opts>(ctx, it, end);
+                     skip_ws_no_pre_check<Opts>(ctx, it, end);
                      if (bool(ctx.error)) [[unlikely]]
                         return;
                   }
@@ -1043,13 +1033,13 @@ namespace glz
 
       // 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
+      // '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);
+         skip_ws_no_pre_check<Opts>(ctx, it, end);
          if (bool(ctx.error)) [[unlikely]]
             return {};
 
@@ -1114,7 +1104,7 @@ namespace glz
             }
             static constexpr auto Opts = ws_handled_off<Options>();
 
-            match<'['>(ctx, it, end);
+            match<'['>(ctx, it);
             if (bool(ctx.error)) [[unlikely]]
                return;
             const auto n = number_of_array_elements<Opts>(ctx, it, end);
@@ -1125,12 +1115,14 @@ namespace glz
             for (auto& x : value) {
                read<json>::op<Opts>(x, ctx, it, end);
                skip_ws<Opts>(ctx, it, end);
+               if (bool(ctx.error)) [[unlikely]]
+                  return;
                if (i < n - 1) {
-                  match<','>(ctx, it, end);
+                  match<','>(ctx, it);
                }
                ++i;
             }
-            match<']'>(ctx, it, end);
+            match<']'>(ctx, it);
          }
       };
 
@@ -1156,10 +1148,10 @@ namespace glz
                   return;
             }
 
-            match<'['>(ctx, it, end);
+            match<'['>(ctx, it);
             if (bool(ctx.error)) [[unlikely]]
                return;
-            skip_ws<Opts>(ctx, it, end);
+            skip_ws_no_pre_check<Opts>(ctx, it, end);
             if (bool(ctx.error)) [[unlikely]]
                return;
 
@@ -1168,10 +1160,10 @@ namespace glz
                   return;
                }
                if constexpr (I != 0) {
-                  match<','>(ctx, it, end);
+                  match<','>(ctx, it);
                   if (bool(ctx.error)) [[unlikely]]
                      return;
-                  skip_ws<Opts>(ctx, it, end);
+                  skip_ws_no_pre_check<Opts>(ctx, it, end);
                   if (bool(ctx.error)) [[unlikely]]
                      return;
                }
@@ -1181,12 +1173,12 @@ namespace glz
                      return;
                }
                else if constexpr (glaze_array_t<T>) {
-                  read<json>::op<ws_handled<Opts>()>(get_member(value, glz::tuplet::get<I>(meta_v<T>)), ctx, it, end);
+                  read<json>::op<ws_handled<Opts>()>(get_member(value, glz::get<I>(meta_v<T>)), ctx, it, end);
                   if (bool(ctx.error)) [[unlikely]]
                      return;
                }
                else {
-                  read<json>::op<ws_handled<Opts>()>(glz::tuplet::get<I>(value), ctx, it, end);
+                  read<json>::op<ws_handled<Opts>()>(glz::get<I>(value), ctx, it, end);
                   if (bool(ctx.error)) [[unlikely]]
                      return;
                }
@@ -1195,7 +1187,7 @@ namespace glz
                   return;
             });
 
-            match<']'>(ctx, it, end);
+            match<']'>(ctx, it);
          }
       };
 
@@ -1211,7 +1203,7 @@ namespace glz
                   return;
             }
 
-            match<'['>(ctx, it, end);
+            match<'['>(ctx, it);
             if (bool(ctx.error)) [[unlikely]]
                return;
 
@@ -1240,7 +1232,7 @@ namespace glz
                   ++it;
                   return;
                }
-               match<','>(ctx, it, end);
+               match<','>(ctx, it);
             }
          }
       };
@@ -1249,7 +1241,7 @@ namespace glz
       struct from_json<includer<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) noexcept
          {
             std::string& path = string_buffer();
             read<json>::op<Opts>(path, ctx, it, end);
@@ -1259,17 +1251,17 @@ namespace glz
             const auto file_path = relativize_if_not_absolute(std::filesystem::path(ctx.current_file).parent_path(),
                                                               std::filesystem::path{path});
 
-            std::string& buffer = string_buffer();
-            std::string string_file_path = file_path.string();
+            std::string& buffer = path;
+            const auto string_file_path = file_path.string();
             const auto ec = file_to_buffer(buffer, string_file_path);
 
-            if (bool(ec)) {
+            if (bool(ec)) [[unlikely]] {
                ctx.error = ec;
                return;
             }
 
             const auto current_file = ctx.current_file;
-            ctx.current_file = file_path.string();
+            ctx.current_file = string_file_path;
 
             std::ignore = glz::read<Opts>(value.value, buffer, ctx);
             if (bool(ctx.error)) [[unlikely]]
@@ -1279,6 +1271,7 @@ namespace glz
          }
       };
 
+      // TODO: count the maximum number of escapes that can be seen if error_on_unknown_keys is true
       template <glaze_object_t T>
       GLZ_ALWAYS_INLINE constexpr bool keys_may_contain_escape()
       {
@@ -1287,11 +1280,23 @@ namespace glz
          bool may_escape = false;
          constexpr auto N = std::tuple_size_v<meta_t<T>>;
          for_each<N>([&](auto I) {
-            constexpr auto s = glz::tuplet::get<0>(glz::tuplet::get<I>(meta_v<T>));
-            for (auto& c : s) {
-               if (c == '\\' || c == '"' || is_unicode(c)) {
-                  may_escape = true;
-                  return;
+            constexpr auto first = get<0>(get<I>(meta_v<T>));
+            using T0 = std::decay_t<decltype(first)>;
+            if constexpr (std::is_member_object_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;
+                     return;
+                  }
                }
             }
          });
@@ -1299,6 +1304,12 @@ namespace glz
          return may_escape;
       }
 
+      template <reflectable T>
+      inline constexpr bool keys_may_contain_escape()
+      {
+         return false; // escapes are not valid in C++ names
+      }
+
       template <is_variant T>
       GLZ_ALWAYS_INLINE constexpr bool keys_may_contain_escape()
       {
@@ -1317,15 +1328,9 @@ namespace glz
          return may_escape;
       }
 
-      struct key_stats_t
-      {
-         uint32_t min_length = (std::numeric_limits<uint32_t>::max)();
-         uint32_t max_length{};
-         uint32_t length_range{};
-      };
-
       // only use this if the keys cannot contain escape characters
-      template <glaze_object_t T, string_literal tag = "">
+      template <class T, string_literal tag = "">
+         requires(glaze_object_t<T> || reflectable<T>)
       GLZ_ALWAYS_INLINE constexpr auto key_stats()
       {
          key_stats_t stats{};
@@ -1335,10 +1340,20 @@ namespace glz
             stats.min_length = tag_size;
          }
 
-         constexpr auto N = std::tuple_size_v<meta_t<T>>;
+         constexpr auto N = [] {
+            if constexpr (reflectable<T>) {
+               return count_members<T>;
+            }
+            else {
+               return std::tuple_size_v<meta_t<T>>;
+            }
+         }();
+
          for_each<N>([&](auto I) {
-            constexpr auto s = glz::tuplet::get<0>(glz::tuplet::get<I>(meta_v<T>));
-            const auto n = s.size();
+            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;
             }
@@ -1393,24 +1408,31 @@ namespace glz
                if (bool(ctx.error)) [[unlikely]]
                   return;
             }
-            match<'{'>(ctx, it, end);
+            match<'{'>(ctx, it);
+            if (bool(ctx.error)) [[unlikely]]
+               return;
          }
 
-         skip_ws<Opts>(ctx, it, end);
+         skip_ws_no_pre_check<Opts>(ctx, it, end);
+         if (bool(ctx.error)) [[unlikely]]
+            return;
       }
 
       template <glz::opts Opts>
       GLZ_ALWAYS_INLINE void parse_object_entry_sep(is_context auto& ctx, auto& it, const auto end)
       {
-         skip_ws<Opts>(ctx, it, end);
+         skip_ws_no_pre_check<Opts>(ctx, it, end);
          if (bool(ctx.error)) [[unlikely]]
             return;
-         match<':'>(ctx, it, end);
-         skip_ws<Opts>(ctx, it, end);
+         match<':'>(ctx, it);
+         if (bool(ctx.error)) [[unlikely]]
+            return;
+         skip_ws_no_pre_check<Opts>(ctx, it, end);
       }
 
       // Key parsing for meta objects or variants of meta objects.
-      // TODO We could expand this to compiletime known strings in general like enums
+      // 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)
       {
@@ -1420,61 +1442,41 @@ namespace glz
             if (bool(ctx.error)) [[unlikely]]
                return {};
          }
-         match<'"'>(ctx, it, end);
+         match<'"'>(ctx, it);
          if (bool(ctx.error)) [[unlikely]]
             return {};
 
-         if constexpr (keys_may_contain_escape<T>()) {
-            auto start = it;
-
-            skip_till_escape_or_quote(ctx, it, end);
-            if (bool(ctx.error)) [[unlikely]]
-               return {};
-            if (*it == '\\') [[unlikely]] {
-               // we don't optimize this currently because it would increase binary size significantly with the
-               // complexity of generating escaped compile time versions of keys
-               it = start;
-               std::string& static_key = string_buffer();
-               read<json>::op<opening_handled<Opts>()>(static_key, ctx, it, end);
-               return static_key;
-            }
-            else [[likely]] {
-               const sv key{start, static_cast<size_t>(it - start)};
-               ++it;
-               return key;
+         constexpr auto N = [] {
+            if constexpr (reflectable<T>) {
+               return count_members<T>;
+            }
+            else {
+               return std::tuple_size_v<meta_t<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;
          }
-         else if constexpr (std::tuple_size_v<meta_t<T>> > 0) {
+         else if constexpr (N > 0) {
             static constexpr auto stats = key_stats<T, tag>();
-            if constexpr (stats.length_range < 16 && Opts.error_on_unknown_keys) {
+            if constexpr (stats.length_range < 24) {
                if ((it + stats.max_length) < end) [[likely]] {
-                  if constexpr (stats.length_range == 0) {
-                     const sv key{it, stats.max_length};
-                     it += stats.max_length;
-                     match<'"'>(ctx, it, end);
-                     return key;
-                  }
-                  else if constexpr (stats.length_range < 4) {
-                     auto start = it;
-                     it += stats.min_length;
-                     for (uint32_t i = 0; i <= stats.length_range; ++it, ++i) {
-                        if (*it == '"') {
-                           const sv key{start, static_cast<size_t>(it - start)};
-                           ++it;
-                           return key;
-                        }
-                     }
-                     ctx.error = error_code::unknown_key;
-                     return {};
-                  }
-                  else {
-                     return parse_key_cx<stats.min_length, stats.length_range>(ctx, it);
-                  }
+                  return parse_key_cx<Opts, stats>(it);
                }
             }
+            auto start = it;
+            skip_till_quote(ctx, it, end);
+            return {start, size_t(it - start)};
+         }
+         else {
+            auto start = it;
+            skip_till_quote(ctx, it, end);
+            return {start, size_t(it - start)};
          }
-
-         return parse_unescaped_key(ctx, it, end);
       }
 
       template <pair_t T>
@@ -1522,16 +1524,16 @@ namespace glz
             if (bool(ctx.error)) [[unlikely]]
                return;
 
-            skip_ws<Opts>(ctx, it, end);
+            skip_ws_no_pre_check<Opts>(ctx, it, end);
             if (bool(ctx.error)) [[unlikely]]
                return;
 
-            match<'}'>(ctx, it, end);
+            match<'}'>(ctx, it);
          }
       };
 
       template <class T>
-         requires readable_map_t<T> || glaze_object_t<T>
+         requires readable_map_t<T> || glaze_object_t<T> || reflectable<T>
       struct from_json<T>
       {
          template <auto Options, string_literal tag = "">
@@ -1543,178 +1545,269 @@ namespace glz
 
             static constexpr auto Opts = opening_handled_off<ws_handled_off<Options>()>();
 
-            constexpr auto num_members = std::tuple_size_v<meta_t<T>>;
-            // Only used if error_on_missing_keys = true
-            [[maybe_unused]] bit_array<num_members> fields{};
-
-            bool first = true;
-            while (true) {
-               if (*it == '}') [[unlikely]] {
+            static constexpr auto num_members = [] {
+               if constexpr (reflectable<T>) {
+                  return count_members<T>;
+               }
+               else {
+                  return std::tuple_size_v<meta_t<T>>;
+               }
+            }();
+            if constexpr ((glaze_object_t<T> || reflectable<T>)&&num_members == 0 && Opts.error_on_unknown_keys) {
+               if (*it == '}') [[likely]] {
                   ++it;
-                  if constexpr (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;
-                     }
-                  }
                   return;
                }
-               else if (first) [[unlikely]]
-                  first = false;
-               else [[likely]] {
-                  match<','>(ctx, it, end);
-                  if (bool(ctx.error)) [[unlikely]]
-                     return;
-                  skip_ws<Opts>(ctx, it, end);
-                  if (bool(ctx.error)) [[unlikely]]
-                     return;
-               }
-
-               if constexpr (glaze_object_t<T> && num_members == 0) {
-                  // parsing to an empty object, but at this point the JSON presents keys
-                  const sv key = parse_object_key<T, ws_handled<Opts>(), tag>(ctx, it, end);
-                  if (bool(ctx.error)) [[unlikely]]
-                     return;
+               ctx.error = error_code::unknown_key;
+               return;
+            }
+            else {
+               // Only used if error_on_missing_keys = true
+               [[maybe_unused]] bit_array<num_members> fields{};
+
+               decltype(auto) frozen_map = [&] {
+                  if constexpr (reflectable<T> && num_members > 0) {
+                     static constinit auto cmap = make_map<T, Opts.use_hash_comparison>();
+                     // 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;
+                  }
+               }();
 
-                  if constexpr (Opts.error_on_unknown_keys) {
-                     if constexpr (tag.sv().empty()) {
-                        std::advance(it, -int64_t(key.size()));
-                        ctx.error = error_code::unknown_key;
-                        return;
-                     }
-                     else if (key != tag.sv()) {
-                        std::advance(it, -int64_t(key.size()));
-                        ctx.error = error_code::unknown_key;
-                        return;
+               bool first = true;
+               while (true) {
+                  if (*it == '}') {
+                     ++it;
+                     if constexpr (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;
+                        }
                      }
+                     return;
+                  }
+                  else if (first) {
+                     first = false;
                   }
                   else {
-                     parse_object_entry_sep<Opts>(ctx, it, end);
+                     match<','>(ctx, it);
                      if (bool(ctx.error)) [[unlikely]]
                         return;
-
-                     skip_value<Opts>(ctx, it, end);
+                     skip_ws_no_pre_check<Opts>(ctx, it, end);
                      if (bool(ctx.error)) [[unlikely]]
                         return;
                   }
-               }
-               else if constexpr (glaze_object_t<T>) {
-                  const sv key = parse_object_key<T, ws_handled<Opts>(), tag>(ctx, it, end);
-                  if (bool(ctx.error)) [[unlikely]]
-                     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 ((glaze_object_t<T> || reflectable<T>)&&num_members == 0 && 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) {
+                     match<'"'>(ctx, it);
+                     if (bool(ctx.error)) [[unlikely]]
+                        return;
+
+                     // parsing to an empty object, but at this point the JSON presents keys
+
+                     // Unknown key handler does not unescape keys or want unescaped keys. Unknown escaped keys are
+                     // handled by the user.
+
+                     sv key;
+                     const auto start = it;
+                     while (true) {
+                        skip_till_escape_or_quote(ctx, it, end);
+                        if (bool(ctx.error)) [[unlikely]]
+                           return;
+
+                        if (*it == '"') [[likely]] {
+                           key = {start, size_t(it - start)};
+                           ++it;
+                           break;
+                        }
+                        else {
+                           ++it; // skip the escape
+                           if (*it == '"') {
+                              ++it; // skip the escaped quote
+                           }
+                        }
+                     }
 
-                  static constexpr auto frozen_map = detail::make_map<T, Opts.use_hash_comparison>();
-                  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) {
-                        // 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);
+                     read<json>::handle_unknown<Opts>(key, value, ctx, it, end);
                      if (bool(ctx.error)) [[unlikely]]
                         return;
                   }
-                  else [[unlikely]] {
+                  else if constexpr (glaze_object_t<T> || reflectable<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]]
+                        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 (Opts.error_on_unknown_keys) {
-                        if constexpr (tag.sv().empty()) {
-                           std::advance(it, -int64_t(key.size()));
+                        if (*it != '"') [[unlikely]] {
                            ctx.error = error_code::unknown_key;
                            return;
                         }
-                        else if (key != tag.sv()) {
-                           std::advance(it, -int64_t(key.size()));
-                           ctx.error = error_code::unknown_key;
-                           return;
-                        }
-                        else {
-                           // We duplicate this code to avoid generating unreachable code
+                        ++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;
 
-                           skip_value<Opts>(ctx, it, end);
+                           if constexpr (Opts.error_on_missing_keys) {
+                              // 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 constexpr (tag.sv().empty()) {
+                              std::advance(it, -int64_t(key.size()));
+                              ctx.error = error_code::unknown_key;
+                              return;
+                           }
+                           else if (key != tag.sv()) {
+                              std::advance(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;
+                           }
+                        }
                      }
                      else {
-                        // We duplicate this code to avoid generating unreachable code
-                        parse_object_entry_sep<Opts>(ctx, it, end);
+                        if (const auto& member_it = frozen_map.find(key); member_it != frozen_map.end()) [[likely]] {
+                           match<'"'>(ctx, it);
+                           if (bool(ctx.error)) [[unlikely]]
+                              return;
+
+                           parse_object_entry_sep<Opts>(ctx, it, end);
+                           if (bool(ctx.error)) [[unlikely]]
+                              return;
+
+                           if constexpr (Opts.error_on_missing_keys) {
+                              // 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_till_quote(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;
+
+                           read<json>::handle_unknown<Opts>(key, value, ctx, it, end);
+                           if (bool(ctx.error)) [[unlikely]]
+                              return;
+                        }
+                     }
+                  }
+                  else {
+                     // using k_t = std::conditional_t<heterogeneous_map<T>, sv, typename T::key_type>;
+                     using k_t = typename T::key_type;
+                     if constexpr (std::is_same_v<k_t, std::string>) {
+                        static thread_local k_t key;
+                        read<json>::op<Opts>(key, ctx, it, end);
                         if (bool(ctx.error)) [[unlikely]]
                            return;
 
-                        skip_value<Opts>(ctx, it, end);
+                        parse_object_entry_sep<Opts>(ctx, it, end);
+
+                        read<json>::op<ws_handled<Opts>()>(value[key], ctx, it, end);
                         if (bool(ctx.error)) [[unlikely]]
                            return;
                      }
-                  }
-               }
-               else {
-                  // using k_t = std::conditional_t<heterogeneous_map<T>, sv, typename T::key_type>;
-                  using k_t = typename T::key_type;
-                  if constexpr (std::is_same_v<k_t, std::string>) {
-                     static thread_local k_t key;
-                     read<json>::op<Opts>(key, ctx, it, end);
-                     if (bool(ctx.error)) [[unlikely]]
-                        return;
-
-                     parse_object_entry_sep<Opts>(ctx, it, end);
-
-                     read<json>::op<ws_handled<Opts>()>(value[key], ctx, it, end);
-                     if (bool(ctx.error)) [[unlikely]]
-                        return;
-                  }
-                  else if constexpr (str_t<k_t>) {
-                     k_t key;
-                     read<json>::op<Opts>(key, ctx, it, end);
-                     if (bool(ctx.error)) [[unlikely]]
-                        return;
+                     else if constexpr (str_t<k_t>) {
+                        k_t key;
+                        read<json>::op<Opts>(key, ctx, it, end);
+                        if (bool(ctx.error)) [[unlikely]]
+                           return;
 
-                     parse_object_entry_sep<Opts>(ctx, it, end);
-                     if (bool(ctx.error)) [[unlikely]]
-                        return;
+                        parse_object_entry_sep<Opts>(ctx, it, end);
+                        if (bool(ctx.error)) [[unlikely]]
+                           return;
 
-                     read<json>::op<ws_handled<Opts>()>(value[key], ctx, it, end);
-                     if (bool(ctx.error)) [[unlikely]]
-                        return;
-                  }
-                  else {
-                     static_assert(std::is_arithmetic_v<k_t> || glaze_enum_t<k_t>);
-                     k_t key_value{};
-                     if constexpr (std::is_arithmetic_v<k_t>) {
-                        read<json>::op<opt_true<Opts, &opts::quoted_num>>(key_value, ctx, it, end);
+                        read<json>::op<ws_handled<Opts>()>(value[key], ctx, it, end);
+                        if (bool(ctx.error)) [[unlikely]]
+                           return;
                      }
                      else {
-                        read<json>::op<Opts>(key_value, ctx, it, end);
-                     }
-                     if (bool(ctx.error)) [[unlikely]]
-                        return;
+                        k_t key_value{};
+                        if constexpr (glaze_enum_t<k_t>) {
+                           read<json>::op<Opts>(key_value, ctx, it, end);
+                        }
+                        else if constexpr (std::is_arithmetic_v<k_t>) {
+                           // 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<k_t>{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;
+                        parse_object_entry_sep<Opts>(ctx, it, end);
+                        if (bool(ctx.error)) [[unlikely]]
+                           return;
 
-                     read<json>::op<Opts>(value[key_value], ctx, it, end);
-                     if (bool(ctx.error)) [[unlikely]]
-                        return;
+                        read<json>::op<Opts>(value[key_value], ctx, it, end);
+                        if (bool(ctx.error)) [[unlikely]]
+                           return;
+                     }
                   }
+                  skip_ws<Opts>(ctx, it, end);
+                  if (bool(ctx.error)) [[unlikely]]
+                     return;
                }
-               skip_ws<Opts>(ctx, it, end);
-               if (bool(ctx.error)) [[unlikely]]
-                  return;
             }
          }
       };
@@ -1752,18 +1845,83 @@ namespace glz
       struct variant_types<std::variant<Ts...>>
       {
          // TODO this way of filtering types is compile time intensive.
-         using bool_types = decltype(std::tuple_cat(std::conditional_t<bool_t<Ts>, std::tuple<Ts>, std::tuple<>>{}...));
-         using number_types =
-            decltype(std::tuple_cat(std::conditional_t<num_t<Ts>, std::tuple<Ts>, std::tuple<>>{}...));
-         using string_types = decltype(std::tuple_cat(std::conditional_t < str_t<Ts> || glaze_enum_t<Ts>,
-                                                      std::tuple<Ts>, std::tuple < >> {}...));
-         using object_types =
-            decltype(std::tuple_cat(std::conditional_t < readable_map_t<Ts> || writable_map_t<Ts> || glaze_object_t<Ts>,
-                                    std::tuple<Ts>, std::tuple < >> {}...));
-         using array_types = decltype(std::tuple_cat(std::conditional_t < array_t<Ts> || glaze_array_t<Ts>,
-                                                     std::tuple<Ts>, std::tuple < >> {}...));
+         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(std::tuple_cat(std::conditional_t<null_t<Ts>, std::tuple<Ts>, std::tuple<>>{}...));
+            decltype(tuplet::tuple_cat(std::conditional_t<null_t<Ts>, tuplet::tuple<Ts>, tuplet::tuple<>>{}...));
+      };
+
+      // post process output of variant_types
+      template <typename>
+      struct tuple_types;
+
+      template <typename... 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 <typename tuple_types_t>
+      struct process_arithmetic_boolean_string_or_array
+      {
+         template <auto Options>
+         GLZ_FLATTEN static void op(auto&& value, is_context auto&& ctx, auto&& it, auto&& end)
+         {
+            if constexpr (std::tuple_size_v<tuple_types_t> < 1) {
+               ctx.error = error_code::no_matching_variant_type;
+            }
+            else {
+               using const_glaze_types = typename tuple_types<tuple_types_t>::glaze_const_types;
+               bool found_match{};
+               for_each<std::tuple_size_v<const_glaze_types>>([&]([[maybe_unused]] auto I) mutable {
+                  if (found_match) {
+                     return;
+                  }
+                  using V = std::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{};
+                  }
+                  else {
+                     it = copy_it;
+                  }
+               });
+               if (found_match) {
+                  return;
+               }
+
+               using non_const_types = typename tuple_types<tuple_types_t>::glaze_non_const_types;
+               if constexpr (std::tuple_size_v < non_const_types >> 0) {
+                  using V = std::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);
+               }
+               else {
+                  ctx.error = error_code::no_matching_variant_type;
+               }
+            }
+         }
       };
 
       template <is_variant T>
@@ -1799,7 +1957,7 @@ namespace glz
                   }
                   else {
                      auto possible_types = bit_array<std::variant_size_v<T>>{}.flip();
-                     static constexpr auto deduction_map = glz::detail::make_variant_deduction_map<T>();
+                     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>);
                      skip_ws<Opts>(ctx, it, end);
                      if (bool(ctx.error)) [[unlikely]]
@@ -1807,11 +1965,14 @@ namespace glz
                      auto start = it;
                      while (*it != '}') {
                         if (it != start) {
-                           match<','>(ctx, it, end);
+                           match<','>(ctx, it);
                            if (bool(ctx.error)) [[unlikely]]
                               return;
                         }
-                        std::string_view key = parse_object_key<T, Opts, tag_literal>(ctx, it, end);
+                        const sv key = parse_object_key<T, Opts, tag_literal>(ctx, it, end);
+                        if (bool(ctx.error)) [[unlikely]]
+                           return;
+                        match<'"'>(ctx, it);
                         if (bool(ctx.error)) [[unlikely]]
                            return;
 
@@ -1823,26 +1984,23 @@ namespace glz
                            else [[unlikely]] {
                               if constexpr (!tag_v<T>.empty()) {
                                  if (key == tag_v<T>) {
-                                    skip_ws<Opts>(ctx, it, end);
-                                    if (bool(ctx.error)) [[unlikely]]
-                                       return;
-                                    match<':'>(ctx, it, end);
+                                    parse_object_entry_sep<Opts>(ctx, it, end);
                                     if (bool(ctx.error)) [[unlikely]]
                                        return;
-
-                                    std::string& type_id = string_buffer();
-                                    read<json>::op<Opts>(type_id, ctx, it, end);
+                                    std::string_view type_id{};
+                                    read<json>::op<ws_handled<Opts>()>(type_id, ctx, it, end);
                                     if (bool(ctx.error)) [[unlikely]]
                                        return;
-                                    skip_ws<Opts>(ctx, it, end);
+                                    skip_ws_no_pre_check<Opts>(ctx, it, end);
                                     if (bool(ctx.error)) [[unlikely]]
                                        return;
-                                    match<','>(ctx, it, end);
-                                    if (bool(ctx.error)) [[unlikely]]
+                                    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(std::string_view{type_id});
+                                    auto id_it = id_map.find(type_id);
                                     if (id_it != id_map.end()) [[likely]] {
                                        it = start;
                                        const auto type_index = id_it->second;
@@ -1850,7 +2008,7 @@ namespace glz
                                        std::visit(
                                           [&](auto&& v) {
                                              using V = std::decay_t<decltype(v)>;
-                                             constexpr bool is_object = glaze_object_t<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);
@@ -1878,23 +2036,20 @@ namespace glz
                         else if constexpr (!tag_v<T>.empty()) {
                            // empty object case for variant
                            if (key == tag_v<T>) {
-                              skip_ws<Opts>(ctx, it, end);
-                              if (bool(ctx.error)) [[unlikely]]
-                                 return;
-                              match<':'>(ctx, it, end);
+                              parse_object_entry_sep<Opts>(ctx, it, end);
                               if (bool(ctx.error)) [[unlikely]]
                                  return;
 
-                              std::string& type_id = string_buffer();
-                              read<json>::op<Opts>(type_id, ctx, it, end);
+                              std::string_view type_id{};
+                              read<json>::op<ws_handled<Opts>()>(type_id, ctx, it, end);
                               if (bool(ctx.error)) [[unlikely]]
                                  return;
-                              skip_ws<Opts>(ctx, it, end);
+                              skip_ws_no_pre_check<Opts>(ctx, it, end);
                               if (bool(ctx.error)) [[unlikely]]
                                  return;
 
                               static constexpr auto id_map = make_variant_id_map<T>();
-                              auto id_it = id_map.find(std::string_view{type_id});
+                              auto id_it = id_map.find(type_id);
                               if (id_it != id_map.end()) [[likely]] {
                                  it = start;
                                  const auto type_index = id_it->second;
@@ -1929,7 +2084,7 @@ namespace glz
                            std::visit(
                               [&](auto&& v) {
                                  using V = std::decay_t<decltype(v)>;
-                                 constexpr bool is_object = glaze_object_t<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);
                                  }
@@ -1944,7 +2099,7 @@ namespace glz
                         skip_value<Opts>(ctx, it, end);
                         if (bool(ctx.error)) [[unlikely]]
                            return;
-                        skip_ws<Opts>(ctx, it, end);
+                        skip_ws_no_pre_check<Opts>(ctx, it, end);
                         if (bool(ctx.error)) [[unlikely]]
                            return;
                      }
@@ -1953,38 +2108,17 @@ namespace glz
                   break;
                case '[':
                   using array_types = typename variant_types<T>::array_types;
-                  if constexpr (std::tuple_size_v<array_types> < 1) {
-                     ctx.error = error_code::no_matching_variant_type;
-                  }
-                  else {
-                     using V = std::tuple_element_t<0, array_types>;
-                     if (!std::holds_alternative<V>(value)) value = V{};
-                     read<json>::op<ws_handled<Opts>()>(std::get<V>(value), ctx, it, end);
-                  }
+                  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;
-                  if constexpr (std::tuple_size_v<string_types> < 1) {
-                     ctx.error = error_code::no_matching_variant_type;
-                  }
-                  else {
-                     using V = std::tuple_element_t<0, string_types>;
-                     if (!std::holds_alternative<V>(value)) value = V{};
-                     read<json>::op<ws_handled<Opts>()>(std::get<V>(value), ctx, it, end);
-                  }
+                  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;
-                  if constexpr (std::tuple_size_v<bool_types> < 1) {
-                     ctx.error = error_code::no_matching_variant_type;
-                  }
-                  else {
-                     using V = std::tuple_element_t<0, bool_types>;
-                     if (!std::holds_alternative<V>(value)) value = V{};
-                     read<json>::op<ws_handled<Opts>()>(std::get<V>(value), ctx, it, end);
-                  }
+                  process_arithmetic_boolean_string_or_array<bool_types>::template op<Opts>(value, ctx, it, end);
                   break;
                }
                case 'n':
@@ -2001,14 +2135,7 @@ namespace glz
                default: {
                   // Not bool, string, object, or array so must be number or null
                   using number_types = typename variant_types<T>::number_types;
-                  if constexpr (std::tuple_size_v<number_types> < 1) {
-                     ctx.error = error_code::no_matching_variant_type;
-                  }
-                  else {
-                     using V = std::tuple_element_t<0, number_types>;
-                     if (!std::holds_alternative<V>(value)) value = V{};
-                     read<json>::op<ws_handled<Opts>()>(std::get<V>(value), ctx, it, end);
-                  }
+                  process_arithmetic_boolean_string_or_array<number_types>::template op<Opts>(value, ctx, it, end);
                }
                }
             }
@@ -2033,15 +2160,15 @@ namespace glz
             }
             static constexpr auto Opts = ws_handled_off<Options>();
 
-            match<'['>(ctx, it, end);
+            match<'['>(ctx, it);
             if (bool(ctx.error)) [[unlikely]]
                return;
-            skip_ws<Opts>(ctx, it, end);
+            skip_ws_no_pre_check<Opts>(ctx, it, end);
             if (bool(ctx.error)) [[unlikely]]
                return;
 
             // TODO Use key parsing for compiletime known keys
-            match<'"'>(ctx, it, end);
+            match<'"'>(ctx, it);
             if (bool(ctx.error)) [[unlikely]]
                return;
             auto start = it;
@@ -2049,7 +2176,7 @@ namespace glz
             if (bool(ctx.error)) [[unlikely]]
                return;
             sv type_id = {start, static_cast<size_t>(it - start)};
-            match<'"'>(ctx, it, end);
+            match<'"'>(ctx, it);
             if (bool(ctx.error)) [[unlikely]]
                return;
 
@@ -2059,7 +2186,7 @@ namespace glz
                skip_ws<Opts>(ctx, it, end);
                if (bool(ctx.error)) [[unlikely]]
                   return;
-               match<','>(ctx, it, end);
+               match<','>(ctx, it);
                if (bool(ctx.error)) [[unlikely]]
                   return;
                const auto type_index = id_it->second;
@@ -2076,7 +2203,7 @@ namespace glz
             skip_ws<Opts>(ctx, it, end);
             if (bool(ctx.error)) [[unlikely]]
                return;
-            match<']'>(ctx, it, end);
+            match<']'>(ctx, it);
          }
       };
 
@@ -2170,6 +2297,6 @@ namespace glz
          return {ec};
       }
 
-      return read<Opts>(value, buffer, ctx);
+      return read<set_json<Opts>()>(value, buffer, ctx);
    }
 }
diff --git a/src/core/include/glaze/json/schema.hpp b/src/core/include/glaze/json/schema.hpp
index 88757b48..9f2547e4 100644
--- a/src/core/include/glaze/json/schema.hpp
+++ b/src/core/include/glaze/json/schema.hpp
@@ -199,11 +199,15 @@ namespace glz
             // });
             s.oneOf = std::vector<schematic>(N);
             for_each<N>([&](auto I) {
-               static constexpr auto item = glz::tuplet::get<I>(meta_v<V>);
+               static constexpr auto item = get<I>(meta_v<V>);
+               using T0 = std::decay_t<decltype(get<0>(item))>;
                auto& enumeration = (*s.oneOf)[I.value];
-               enumeration.constant = glz::tuplet::get<0>(item);
-               if constexpr (std::tuple_size_v < decltype(item) >> 2) {
-                  enumeration.description = std::get<2>(item);
+               enumeration.constant = get_enum_key<V, 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 = std::tuple_size_v<decltype(item)>;
+               if constexpr (Size > comment_index) {
+                  enumeration.description = get<comment_index>(item);
                }
             });
          }
@@ -305,7 +309,8 @@ namespace glz
          }
       };
 
-      template <glaze_object_t T>
+      template <class T>
+         requires(glaze_object_t<T> || reflectable<T>)
       struct to_json_schema<T>
       {
          template <auto Opts>
@@ -323,29 +328,42 @@ namespace glz
                s.examples = meta<V>::examples;
             }
 
-            static constexpr auto N = std::tuple_size_v<meta_t<V>>;
-            s.properties = std::map<std::string_view, schema, std::less<>>();
+            static constexpr auto N = [] {
+               if constexpr (reflectable<T>) {
+                  return count_members<T>;
+               }
+               else {
+                  return std::tuple_size_v<meta_t<T>>;
+               }
+            }();
+            s.properties = std::map<sv, schema, std::less<>>();
             for_each<N>([&](auto I) {
-               static constexpr auto item = glz::tuplet::get<I>(meta_v<V>);
-               using mptr_t = decltype(glz::tuplet::get<1>(item));
-               using val_t = std::decay_t<member_t<V, mptr_t>>;
+               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>;
+
                auto& def = defs[name_v<val_t>];
                if (!def.type) {
                   to_json_schema<val_t>::template op<Opts>(def, defs);
                }
                auto ref_val = schema{join_v<chars<"#/$defs/">, name_v<val_t>>};
-               static constexpr auto Size = std::tuple_size_v<decltype(item)>;
-               if constexpr (Size > 2) {
-                  using additional_data_type = decltype(glz::tuplet::get<2>(item));
-                  if constexpr (std::is_convertible_v<additional_data_type, std::string_view>) {
-                     ref_val.description = glz::tuplet::get<2>(item);
+               static constexpr size_t comment_index = member_index + 1;
+               static constexpr auto Size = std::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 = glz::tuplet::get<2>(item);
+                     ref_val = get<comment_index>(item);
                      ref_val.ref = join_v<chars<"#/$defs/">, name_v<val_t>>;
                   }
                }
-               (*s.properties)[glz::tuplet::get<0>(item)] = ref_val;
+
+               constexpr sv key = key_name<I, T, Element::use_reflection>;
+               (*s.properties)[key] = ref_val;
             });
             s.additionalProperties = false;
          }
@@ -359,17 +377,14 @@ namespace glz
       detail::schematic s{};
       s.defs.emplace();
       detail::to_json_schema<std::decay_t<T>>::template op<opts{}>(s, *s.defs);
-      write<opts{}>(std::move(s), std::forward<Buffer>(buffer));
+      write<opts{.write_type_info = false}>(std::move(s), std::forward<Buffer>(buffer));
    }
 
    template <class T>
-   inline auto write_json_schema() noexcept
+   [[nodiscard]] inline auto write_json_schema() noexcept
    {
       std::string buffer{};
-      detail::schematic s{};
-      s.defs.emplace();
-      detail::to_json_schema<std::decay_t<T>>::template op<opts{}>(s, *s.defs);
-      write<opts{.write_type_info = false}>(std::move(s), buffer);
+      write_json_schema<T>(buffer);
       return buffer;
    }
 }
diff --git a/src/core/include/glaze/json/skip.hpp b/src/core/include/glaze/json/skip.hpp
index 0e721b6f..297705f1 100644
--- a/src/core/include/glaze/json/skip.hpp
+++ b/src/core/include/glaze/json/skip.hpp
@@ -10,10 +10,6 @@ namespace glz::detail
    template <opts Opts>
    GLZ_FLATTEN void skip_object(is_context auto&& ctx, auto&& it, auto&& end) noexcept
    {
-      if (bool(ctx.error)) [[unlikely]] {
-         return;
-      }
-
       if constexpr (!Opts.force_conformance) {
          skip_until_closed<'{', '}'>(ctx, it, end);
       }
@@ -34,37 +30,33 @@ namespace glz::detail
             skip_string<Opts>(ctx, it, end);
             if (bool(ctx.error)) [[unlikely]]
                return;
-            skip_ws<Opts>(ctx, it, end);
+            skip_ws_no_pre_check<Opts>(ctx, it, end);
             if (bool(ctx.error)) [[unlikely]]
                return;
-            match<':'>(ctx, it, end);
+            match<':'>(ctx, it);
             if (bool(ctx.error)) [[unlikely]]
                return;
-            skip_ws<Opts>(ctx, it, end);
+            skip_ws_no_pre_check<Opts>(ctx, it, end);
             if (bool(ctx.error)) [[unlikely]]
                return;
             skip_value<Opts>(ctx, it, end);
             if (bool(ctx.error)) [[unlikely]]
                return;
-            skip_ws<Opts>(ctx, it, end);
+            skip_ws_no_pre_check<Opts>(ctx, it, end);
             if (bool(ctx.error)) [[unlikely]]
                return;
             if (*it != ',') break;
-            skip_ws<Opts>(ctx, ++it, end);
+            skip_ws_no_pre_check<Opts>(ctx, ++it, end);
             if (bool(ctx.error)) [[unlikely]]
                return;
          }
-         match<'}'>(ctx, it, end);
+         match<'}'>(ctx, it);
       }
    }
 
    template <opts Opts>
    GLZ_FLATTEN void skip_array(is_context auto&& ctx, auto&& it, auto&& end) noexcept
    {
-      if (bool(ctx.error)) [[unlikely]] {
-         return;
-      }
-
       if constexpr (!Opts.force_conformance) {
          skip_until_closed<'[', ']'>(ctx, it, end);
       }
@@ -81,28 +73,26 @@ namespace glz::detail
             skip_value<Opts>(ctx, it, end);
             if (bool(ctx.error)) [[unlikely]]
                return;
-            skip_ws<Opts>(ctx, it, end);
+            skip_ws_no_pre_check<Opts>(ctx, it, end);
             if (bool(ctx.error)) [[unlikely]]
                return;
             if (*it != ',') break;
-            skip_ws<Opts>(ctx, ++it, end);
+            skip_ws_no_pre_check<Opts>(ctx, ++it, end);
             if (bool(ctx.error)) [[unlikely]]
                return;
          }
-         match<']'>(ctx, it, end);
+         match<']'>(ctx, it);
       }
    }
 
    template <opts Opts>
    GLZ_FLATTEN void skip_value(is_context auto&& ctx, auto&& it, auto&& end) noexcept
    {
-      if (bool(ctx.error)) [[unlikely]] {
-         return;
-      }
-
       if constexpr (!Opts.force_conformance) {
          if constexpr (!Opts.ws_handled) {
             skip_ws<Opts>(ctx, it, end);
+            if (bool(ctx.error)) [[unlikely]]
+               return;
          }
          while (true) {
             switch (*it) {
@@ -145,6 +135,8 @@ namespace glz::detail
       else {
          if constexpr (!Opts.ws_handled) {
             skip_ws<Opts>(ctx, it, end);
+            if (bool(ctx.error)) [[unlikely]]
+               return;
          }
          switch (*it) {
          case '{': {
diff --git a/src/core/include/glaze/json/study.hpp b/src/core/include/glaze/json/study.hpp
index d02a0d38..faa92b41 100644
--- a/src/core/include/glaze/json/study.hpp
+++ b/src/core/include/glaze/json/study.hpp
@@ -216,9 +216,9 @@ namespace glz
 
       template <class T>
       concept generator = requires(T g) {
-                             g.generate();
-                             g.done();
-                          };
+         g.generate();
+         g.done();
+      };
 
       // Takes a state generator and a function on which to invoke the state
       void run_study(generator auto& g, auto&& f)
diff --git a/src/core/include/glaze/json/write.hpp b/src/core/include/glaze/json/write.hpp
index f73f377c..37a356f9 100644
--- a/src/core/include/glaze/json/write.hpp
+++ b/src/core/include/glaze/json/write.hpp
@@ -12,6 +12,7 @@
 #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"
@@ -25,17 +26,16 @@ namespace glz
       {};
 
       template <auto Opts, class T, class Ctx, class B, class IX>
-      concept write_json_invocable =
-         requires(T&& value, Ctx&& ctx, B&& b, 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));
-         };
+      concept write_json_invocable = requires(T&& value, Ctx&& ctx, B&& b, 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 <>
       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)
+         GLZ_ALWAYS_INLINE static void op(T&& value, Ctx&& ctx, B&& b, IX&& ix) noexcept
          {
             if constexpr (write_json_invocable<Opts, T, Ctx, B, IX>) {
                to_json<std::remove_cvref_t<T>>::template op<Opts>(std::forward<T>(value), std::forward<Ctx>(ctx),
@@ -50,12 +50,26 @@ namespace glz
       template <glaze_value_t T>
       struct to_json<T>
       {
-         template <auto Opts, is_context Ctx, class B, class IX>
-         GLZ_ALWAYS_INLINE static void op(auto&& 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));
+         }
+      };
+
+      template <is_bitset T>
+      struct to_json<T>
+      {
+         template <auto Opts>
+         GLZ_ALWAYS_INLINE static void op(auto&& value, auto&&, auto&& b, auto&& ix) noexcept
          {
-            using V = std::decay_t<decltype(get_member(std::declval<T>(), meta_wrapper_v<T>))>;
-            to_json<V>::template op<Opts>(get_member(value, meta_wrapper_v<T>), std::forward<Ctx>(ctx),
-                                          std::forward<B>(b), std::forward<IX>(ix));
+            dump<'"'>(b, ix);
+            for (size_t i = value.size(); i > 0; --i) {
+               value[i - 1] ? dump<'1'>(b, ix) : dump<'0'>(b, ix);
+            }
+            dump<'"'>(b, ix);
          }
       };
 
@@ -63,18 +77,18 @@ namespace glz
       struct to_json<T>
       {
          template <auto Opts>
-         GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&&, auto&& b, auto&& ix)
+         GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&&, auto&& b, auto&& ix) noexcept
          {
             static constexpr auto N = std::tuple_size_v<meta_t<T>>;
 
             dump<'['>(b, ix);
 
             for_each<N>([&](auto I) {
-               static constexpr auto item = glz::tuplet::get<I>(meta_v<T>);
+               static constexpr auto item = glz::get<I>(meta_v<T>);
 
-               if (get_member(value, glz::tuplet::get<1>(item))) {
+               if (get_member(value, glz::get<1>(item))) {
                   dump<'"'>(b, ix);
-                  dump(glz::tuplet::get<0>(item), b, ix);
+                  dump(glz::get<0>(item), b, ix);
                   dump<'"'>(b, ix);
                   dump<','>(b, ix);
                }
@@ -93,7 +107,7 @@ namespace glz
       struct to_json<hidden>
       {
          template <auto Opts>
-         GLZ_ALWAYS_INLINE static void op(auto&&, is_context auto&&, auto&&... args)
+         GLZ_ALWAYS_INLINE static void op(auto&&, is_context auto&&, auto&&... args) noexcept
          {
             dump(R"("hidden type should not have been written")", args...);
          }
@@ -103,7 +117,7 @@ namespace glz
       struct to_json<skip>
       {
          template <auto Opts>
-         GLZ_ALWAYS_INLINE static void op(auto&&, is_context auto&&, auto&&... args)
+         GLZ_ALWAYS_INLINE static void op(auto&&, is_context auto&&, auto&&... args) noexcept
          {
             dump(R"("skip type should not have been written")", args...);
          }
@@ -113,7 +127,7 @@ namespace glz
       struct to_json<T>
       {
          template <auto Opts>
-         GLZ_ALWAYS_INLINE static void op(auto&&, is_context auto&&, auto&&...)
+         GLZ_ALWAYS_INLINE static void op(auto&&, is_context auto&&, auto&&...) noexcept
          {}
       };
 
@@ -121,7 +135,7 @@ namespace glz
       struct to_json<T>
       {
          template <auto Opts, class... Args>
-         GLZ_ALWAYS_INLINE static void op(auto&& value, Args&&... args)
+         GLZ_ALWAYS_INLINE static void op(auto&& value, Args&&... args) noexcept
          {
             using V = std::decay_t<decltype(value.get())>;
             to_json<V>::template op<Opts>(value.get(), std::forward<Args>(args)...);
@@ -173,6 +187,56 @@ namespace glz
          }
       };
 
+      constexpr uint16_t combine(const char chars[2]) noexcept
+      {
+         return uint16_t(chars[0]) | (uint16_t(chars[1]) << 8);
+      }
+
+      // clang-format off
+      constexpr std::array<uint16_t, 256> char_escape_table = { //
+         0, 0, 0, 0, 0, 0, 0, 0, combine(R"(\b)"), combine(R"(\t)"), //
+         combine(R"(\n)"), 0, combine(R"(\f)"), combine(R"(\r)"), 0, 0, 0, 0, 0, 0, //
+         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, //
+         0, 0, 0, 0, combine(R"(\")"), 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, combine(R"(\\)") //
+      };
+      // clang-format on
+
+      template <size_t Bytes>
+         requires(Bytes == 8)
+      GLZ_ALWAYS_INLINE void serialize_string(const auto* in, auto* out, auto& ix) noexcept
+      {
+         uint64_t swar;
+         while (true) {
+            std::memcpy(&swar, in, Bytes);
+            std::memcpy(out + ix, in, Bytes);
+            auto next = has_quote(swar) | has_escape(swar) | is_less_16(swar);
+
+            if (next) {
+               next = std::countr_zero(next) >> 3;
+               const auto escape_char = char_escape_table[uint32_t(in[next])];
+               if (escape_char == 0) {
+                  ix += next;
+                  return;
+               }
+               ix += next;
+               in += next;
+               std::memcpy(out + ix, &escape_char, 2);
+               ix += 2;
+               ++in;
+            }
+            else {
+               ix += 8;
+               in += 8;
+            }
+         }
+      }
+
       template <class T>
          requires str_t<T> || char_t<T>
       struct to_json<T>
@@ -184,51 +248,75 @@ namespace glz
                // TODO: Should we check if the string number is valid?
                dump(value, b, ix);
             }
-            else {
-               if constexpr (char_t<T>) {
-                  if constexpr (Opts.raw) {
-                     dump(value, b, ix);
+            else if constexpr (char_t<T>) {
+               if constexpr (Opts.raw) {
+                  dump(value, b, ix);
+               }
+               else {
+                  dump<'"'>(b, ix);
+
+                  switch (value) {
+                  case '"':
+                     dump<"\\\"">(b, ix);
+                     break;
+                  case '\\':
+                     dump<"\\\\">(b, ix);
+                     break;
+                  case '\b':
+                     dump<"\\b">(b, ix);
+                     break;
+                  case '\f':
+                     dump<"\\f">(b, ix);
+                     break;
+                  case '\n':
+                     dump<"\\n">(b, ix);
+                     break;
+                  case '\r':
+                     dump<"\\r">(b, ix);
+                     break;
+                  case '\t':
+                     dump<"\\t">(b, ix);
+                     break;
+                  case '\0':
+                     // escape character treated as empty string
+                     break;
+                  default:
+                     // Hiding warning for build, this is an error with wider char types
+                     dump(static_cast<char>(value), b,
+                          ix); // TODO: This warning is an error We need to be able to dump wider char types
                   }
-                  else {
-                     dump<'"'>(b, ix);
 
-                     switch (value) {
-                     case '"':
-                        dump<"\\\"">(b, ix);
-                        break;
-                     case '\\':
-                        dump<"\\\\">(b, ix);
-                        break;
-                     case '\b':
-                        dump<"\\b">(b, ix);
-                        break;
-                     case '\f':
-                        dump<"\\f">(b, ix);
-                        break;
-                     case '\n':
-                        dump<"\\n">(b, ix);
-                        break;
-                     case '\r':
-                        dump<"\\r">(b, ix);
-                        break;
-                     case '\t':
-                        dump<"\\t">(b, ix);
-                        break;
-                     case '\0':
-                        // escape character treated as empty string
-                        break;
-                     default:
-                        // Hiding warning for build, this is an error with wider char types
-                        dump(static_cast<char>(value), b,
-                             ix); // TODO: This warning is an error We need to be able to dump wider char types
+                  dump<'"'>(b, ix);
+               }
+            }
+            else {
+               if constexpr (Opts.raw_string) {
+                  const sv str = [&]() -> sv {
+                     if constexpr (!char_array_t<T> && std::is_pointer_v<std::decay_t<T>>) {
+                        return value ? value : "";
+                     }
+                     else {
+                        return value;
                      }
+                  }();
 
-                     dump<'"'>(b, ix);
+                  // We need at space for quotes and the string length: 2 + n.
+                  if constexpr (resizeable<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));
+                     }
                   }
+                  // now we don't have to check writing
+
+                  dump_unchecked<'"'>(b, ix);
+                  dump_unchecked(str, b, ix);
+                  dump_unchecked<'"'>(b, ix);
                }
                else {
                   const sv str = [&]() -> sv {
-                     if constexpr (!detail::char_array_t<T> && std::is_pointer_v<std::decay_t<T>>) {
+                     if constexpr (!char_array_t<T> && std::is_pointer_v<std::decay_t<T>>) {
                         return value ? value : "";
                      }
                      else {
@@ -237,76 +325,72 @@ namespace glz
                   }();
                   const auto n = str.size();
 
-                  if constexpr (Opts.raw_string) {
-                     // We need at space for quotes and the string length: 2 + n.
-                     if constexpr (detail::resizeable<B>) {
-                        const auto k = ix + 2 + n;
-                        if (k >= b.size()) [[unlikely]] {
-                           b.resize((std::max)(b.size() * 2, k));
-                        }
+                  // 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
+                  if constexpr (resizeable<B>) {
+                     const auto k = ix + 10 + 2 * n;
+                     if (k >= b.size()) [[unlikely]] {
+                        b.resize((std::max)(b.size() * 2, k));
                      }
-                     // now we don't have to check writing
+                  }
+                  // now we don't have to check writing
 
-                     dump_unchecked<'"'>(b, ix);
-                     dump_unchecked(str, b, ix);
-                     dump_unchecked<'"'>(b, ix);
+                  if constexpr (Opts.raw) {
+                     dump(str, b, ix);
                   }
                   else {
-                     // 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.
-                     if constexpr (detail::resizeable<B>) {
-                        const auto k = ix + 2 + 2 * n;
-                        if (k >= b.size()) [[unlikely]] {
-                           b.resize((std::max)(b.size() * 2, k));
-                        }
-                     }
-                     // now we don't have to check writing
+                     dump_unchecked<'"'>(b, ix);
 
-                     if constexpr (Opts.raw) {
-                        dump(str, b, ix);
+                     if constexpr (string_t<T> && !std::is_const_v<std::remove_reference_t<decltype(value)>>) {
+                        // we know the output buffer has enough space, but we must ensure the string buffer has space
+                        // for swar as well
+                        value.reserve(round_up_to_multiple<8>(n));
+                        serialize_string<8>(value.data(), data_ptr(b), ix);
                      }
                      else {
-                        dump_unchecked<'"'>(b, ix);
+                        const auto* c = str.data();
+                        const auto* const e = c + n;
+
+                        if (str.size() > 7) {
+                           for (const auto end_m7 = e - 7; c < end_m7;) {
+                              std::memcpy(data_ptr(b) + ix, c, 8);
+                              uint64_t chunk;
+                              std::memcpy(&chunk, c, 8);
+                              const uint64_t test_chars = has_quote(chunk) | has_escape(chunk) | is_less_16(chunk);
+                              if (test_chars) {
+                                 const auto length = (std::countr_zero(test_chars) >> 3);
+                                 c += length;
+                                 ix += length;
+
+                                 if (const auto escaped = char_escape_table[uint8_t(*c)]; escaped) [[likely]] {
+                                    std::memcpy(data_ptr(b) + ix, &escaped, 2);
+                                 }
+                                 ix += 2;
+                                 ++c;
+                              }
+                              else {
+                                 ix += 8;
+                                 c += 8;
+                              }
+                           }
+                        }
 
-                        for (auto&& c : str) {
-                           switch (c) {
-                           case '"':
-                              std::memcpy(data_ptr(b) + ix, R"(\")", 2);
-                              ix += 2;
-                              break;
-                           case '\\':
-                              std::memcpy(data_ptr(b) + ix, R"(\\)", 2);
-                              ix += 2;
-                              break;
-                           case '\b':
-                              std::memcpy(data_ptr(b) + ix, R"(\b)", 2);
-                              ix += 2;
-                              break;
-                           case '\f':
-                              std::memcpy(data_ptr(b) + ix, R"(\f)", 2);
-                              ix += 2;
-                              break;
-                           case '\n':
-                              std::memcpy(data_ptr(b) + ix, R"(\n)", 2);
+                        // Tail end of buffer. Uncommon for long strings.
+                        for (; c < e; ++c) {
+                           if (const auto escaped = char_escape_table[uint8_t(*c)]; escaped) [[likely]] {
+                              std::memcpy(data_ptr(b) + ix, &escaped, 2);
                               ix += 2;
-                              break;
-                           case '\r':
-                              std::memcpy(data_ptr(b) + ix, R"(\r)", 2);
-                              ix += 2;
-                              break;
-                           case '\t':
-                              std::memcpy(data_ptr(b) + ix, R"(\t)", 2);
-                              ix += 2;
-                              break;
-                           [[likely]] default:
-                              std::memcpy(data_ptr(b) + ix, &c, 1);
+                           }
+                           else {
+                              std::memcpy(data_ptr(b) + ix, c, 1);
                               ++ix;
                            }
                         }
-
-                        dump_unchecked<'"'>(b, ix);
                      }
+
+                     dump_unchecked<'"'>(b, ix);
                   }
                }
             }
@@ -324,17 +408,14 @@ namespace glz
             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()};
-               // Note: Assumes people dont use strings with chars that need to
-               // be
-               // escaped for their enum names
-               // TODO: Could create a pre qouted map for better perf
+               // 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
                dump<'"'>(args...);
                dump(str, args...);
                dump<'"'>(args...);
             }
             else [[unlikely]] {
-               // What do we want to happen if the value doesnt have a mapped
-               // string
+               // 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)...);
             }
          }
@@ -375,7 +456,7 @@ namespace glz
       };
 
       template <glz::opts Opts>
-      GLZ_ALWAYS_INLINE void write_entry_separator(is_context auto&& ctx, auto&&... args)
+      GLZ_ALWAYS_INLINE void write_entry_separator(is_context auto&& ctx, auto&&... args) noexcept
       {
          dump<','>(args...);
          if constexpr (Opts.prettify) {
@@ -388,9 +469,10 @@ namespace glz
       struct to_json<T>
       {
          template <auto Opts, class... Args>
-         GLZ_ALWAYS_INLINE static void op(const auto& value, is_context auto&& ctx, Args&&... args) noexcept
+         GLZ_ALWAYS_INLINE static void op(auto&& value, is_context auto&& ctx, Args&&... args) noexcept
          {
             dump<'['>(args...);
+
             if (!empty_range(value)) {
                if constexpr (Opts.prettify) {
                   ctx.indentation_level += Opts.indentation_width;
@@ -398,10 +480,10 @@ namespace glz
                   dumpn<Opts.indentation_char>(ctx.indentation_level, args...);
                }
 
-               auto it = std::cbegin(value);
+               auto it = std::begin(value);
                write<json>::op<Opts>(*it, ctx, args...);
                ++it;
-               for (; it != std::cend(value); ++it) {
+               for (const auto fin = std::end(value); it != fin; ++it) {
                   write_entry_separator<Opts>(ctx, args...);
                   write<json>::op<Opts>(*it, ctx, args...);
                }
@@ -411,30 +493,31 @@ namespace glz
                   dumpn<Opts.indentation_char>(ctx.indentation_level, args...);
                }
             }
+
             dump<']'>(args...);
          }
       };
 
-      template <opts Opts, typename Key, typename Value, is_context Ctx>
-      void write_pair_content(const Key& key, const Value& value, Ctx& ctx, auto&&... args) noexcept
+      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...);
-            dump<':'>(args...);
          }
          else {
-            dump<'"'>(args...);
-            write<json>::op<Opts>(key, ctx, args...);
-            dump<R"(":)">(args...);
+            write<json>::op<opt_false<Opts, &opts::raw_string>>(quoted_t<const Key>{key}, ctx, args...);
          }
          if constexpr (Opts.prettify) {
-            dump<' '>(args...);
+            dump<": ">(args...);
+         }
+         else {
+            dump<':'>(args...);
          }
 
-         write<json>::op<opening_and_closing_handled_off<Opts>()>(value, ctx, args...);
+         write<json>::op<opening_and_closing_handled_off<Opts>()>(std::forward<Value>(value), ctx, args...);
       }
 
-      template <glz::opts Opts, typename Value>
+      template <opts Opts, class Value>
       [[nodiscard]] GLZ_ALWAYS_INLINE constexpr bool skip_member(const Value& value) noexcept
       {
          if constexpr (null_t<Value> && Opts.skip_null_members) {
@@ -497,38 +580,79 @@ namespace glz
                   }
                }
 
-               auto write_first_entry = [&ctx, &args...](const auto first_it) {
-                  const auto& [first_key, first_val] = *first_it;
-                  if (skip_member<Opts>(first_val)) {
-                     return true;
+               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;
+                     }
+                     write_pair_content<Opts>(it->first, it->second, ctx, args...);
+                     return false;
+                  }
+                  else {
+                     const auto& [key, entry_val] = *it;
+                     if (skip_member<Opts>(entry_val)) {
+                        return true;
+                     }
+                     write_pair_content<Opts>(key, entry_val, ctx, args...);
+                     return false;
                   }
-                  write_pair_content<Opts>(first_key, first_val, ctx, args...);
-                  return false;
                };
 
-               auto it = std::cbegin(value);
-               [[maybe_unused]] bool previous_skipped = write_first_entry(it);
-               for (++it; it != std::cend(value); ++it) {
-                  const auto& [key, entry_val] = *it;
-                  if (skip_member<Opts>(entry_val)) {
-                     previous_skipped = true;
-                     continue;
-                  }
+               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;
+                     }
 
-                  // 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 on last entry but then branch is permanent
-                  if constexpr (Opts.skip_null_members) {
-                     if (!previous_skipped) {
+                     // 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...);
+                        }
+                     }
+                     else {
                         write_entry_separator<Opts>(ctx, args...);
                      }
+
+                     write_pair_content<Opts>(it->first, it->second, ctx, args...);
                   }
                   else {
-                     write_entry_separator<Opts>(ctx, args...);
+                     const 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.
+                     // 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...);
+                     }
+
+                     write_pair_content<Opts>(key, entry_val, ctx, args...);
                   }
 
-                  write_pair_content<Opts>(key, entry_val, ctx, args...);
-                  previous_skipped = false;
+                  starting = false;
                }
 
                if constexpr (!Opts.closing_handled) {
@@ -670,10 +794,10 @@ namespace glz
             }
             for_each<N>([&](auto I) {
                if constexpr (glaze_array_t<V>) {
-                  write<json>::op<Opts>(get_member(value.value, glz::tuplet::get<I>(meta_v<T>)), ctx, args...);
+                  write<json>::op<Opts>(get_member(value.value, glz::get<I>(meta_v<T>)), ctx, args...);
                }
                else {
-                  write<json>::op<Opts>(glz::tuplet::get<I>(value.value), ctx, args...);
+                  write<json>::op<Opts>(glz::get<I>(value.value), ctx, args...);
                }
                constexpr bool needs_comma = I < N - 1;
                if constexpr (needs_comma) {
@@ -714,10 +838,10 @@ namespace glz
             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::tuplet::get<I>(meta_v<T>)), ctx, args...);
+                  write<json>::op<Opts>(get_member(value, glz::get<I>(meta_v<T>)), ctx, args...);
                }
                else {
-                  write<json>::op<Opts>(glz::tuplet::get<I>(value), ctx, args...);
+                  write<json>::op<Opts>(glz::get<I>(value), ctx, args...);
                }
                constexpr bool needs_comma = I < N - 1;
                if constexpr (needs_comma) {
@@ -737,7 +861,7 @@ namespace glz
       struct to_json<includer<T>>
       {
          template <auto Opts, class... Args>
-         GLZ_ALWAYS_INLINE static void op(auto&& /*value*/, is_context auto&& /*ctx*/, Args&&...) noexcept
+         GLZ_ALWAYS_INLINE static void op(auto&&, is_context auto&&, Args&&...) noexcept
          {}
       };
 
@@ -788,10 +912,9 @@ namespace glz
       template <const std::string_view& S>
       GLZ_ALWAYS_INLINE constexpr auto array_from_sv() noexcept
       {
-         constexpr auto s = S; // Needed for MSVC to avoid an internal compiler error
-         constexpr auto N = s.size();
+         constexpr auto N = S.size();
          std::array<char, N> arr;
-         std::copy_n(s.data(), N, arr.data());
+         std::copy_n(S.data(), N, arr.data());
          return arr;
       }
 
@@ -827,18 +950,15 @@ namespace glz
             bool first = true;
             for_each<N>([&](auto I) {
                static constexpr auto Opts = opening_and_closing_handled_off<ws_handled_off<Options>()>();
-               decltype(auto) item = glz::tuplet::get<2 * I + 1>(value.value);
+               decltype(auto) item = glz::get<2 * I + 1>(value.value);
                using val_t = std::decay_t<decltype(item)>;
 
                if (skip_member<Opts>(item)) {
                   return;
                }
 
-               // skip file_include
-               if constexpr (std::is_same_v<val_t, includer<V>>) {
-                  return;
-               }
-               else if constexpr (std::is_same_v<val_t, hidden> || std::same_as<val_t, skip>) {
+               // skip
+               if constexpr (is_includer<val_t> || std::is_same_v<val_t, hidden> || std::same_as<val_t, skip>) {
                   return;
                }
                else {
@@ -854,7 +974,7 @@ namespace glz
                   using Key = typename std::decay_t<std::tuple_element_t<2 * I, V>>;
 
                   if constexpr (str_t<Key> || char_t<Key>) {
-                     const sv key = glz::tuplet::get<2 * I>(value.value);
+                     const sv key = glz::get<2 * I>(value.value);
                      write<json>::op<Opts>(key, ctx, b, ix);
                      dump<':'>(b, ix);
                      if constexpr (Opts.prettify) {
@@ -902,7 +1022,7 @@ namespace glz
             static constexpr auto N = std::tuple_size_v<V>;
 
             for_each<N>([&](auto I) {
-               write<json>::op<opening_and_closing_handled<Options>()>(glz::tuplet::get<I>(value.value), ctx, b, ix);
+               write<json>::op<opening_and_closing_handled<Options>()>(glz::get<I>(value.value), ctx, b, ix);
                if constexpr (I < N - 1) {
                   dump<','>(b, ix);
                }
@@ -918,11 +1038,35 @@ namespace glz
       };
 
       template <class T>
-         requires glaze_object_t<T>
+         requires glaze_object_t<T> || reflectable<T>
       struct to_json<T>
       {
+         template <auto Options, class V>
+         GLZ_FLATTEN 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>) {
+                  write<json>::op<write_unknown_off<Options>()>(glz::merge{value, value.*writer}, ctx, b, ix);
+               }
+               else if constexpr (std::is_member_function_pointer_v<WriterType>) {
+                  write<json>::op<write_unknown_off<Options>()>(glz::merge{value, (value.*writer)()}, ctx, b, ix);
+               }
+               else {
+                  static_assert(false_v<T>, "unknown_write type not handled");
+               }
+            }
+            else {
+               op_base<write_unknown_on<Options>()>(std::forward<V>(value), ctx, b, ix);
+            }
+         }
+
+         // handles glaze_object_t without extra unknown fields
          template <auto Options>
-         GLZ_FLATTEN static void op(auto&& value, is_context auto&& ctx, auto&& b, auto&& ix) noexcept
+         GLZ_FLATTEN static void op_base(auto&& value, is_context auto&& ctx, auto&& b, auto&& ix) noexcept
          {
             if constexpr (!Options.opening_handled) {
                dump<'{'>(b, ix);
@@ -933,29 +1077,58 @@ namespace glz
                }
             }
 
+            using Info = object_type_info<Options, T>;
+
             using V = std::decay_t<T>;
-            static constexpr auto N = std::tuple_size_v<meta_t<V>>;
+            static constexpr auto N = Info::N;
+
+            [[maybe_unused]] decltype(auto) t = [&] {
+               if constexpr (reflectable<T>) {
+                  if constexpr (std::is_const_v<std::remove_reference_t<decltype(value)>>) {
+                     static constinit auto tuple_of_ptrs = make_const_tuple_from_struct<T>();
+                     populate_tuple_ptr(value, tuple_of_ptrs);
+                     return tuple_of_ptrs;
+                  }
+                  else {
+                     static constinit auto tuple_of_ptrs = make_tuple_from_struct<T>();
+                     populate_tuple_ptr(value, tuple_of_ptrs);
+                     return tuple_of_ptrs;
+                  }
+               }
+               else {
+                  return nullptr;
+               }
+            }();
 
-            bool first = true;
+            [[maybe_unused]] bool first = true;
+            static constexpr auto first_is_written = Info::first_will_be_written;
             for_each<N>([&](auto I) {
                static constexpr auto Opts = opening_and_closing_handled_off<ws_handled_off<Options>()>();
-               static constexpr auto item = glz::tuplet::get<I>(meta_v<V>);
-               using mptr_t = std::tuple_element_t<1, decltype(item)>;
-               using val_t = member_t<V, mptr_t>;
+
+               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 = typename Element::type;
+
+               decltype(auto) member = [&] {
+                  if constexpr (reflectable<T>) {
+                     return std::get<I>(t);
+                  }
+                  else {
+                     return get<member_index>(get<I>(meta_v<V>));
+                  }
+               }();
 
                if constexpr (null_t<val_t> && Opts.skip_null_members) {
                   if constexpr (always_null_t<T>)
                      return;
                   else {
                      auto is_null = [&]() {
-                        if constexpr (std::is_member_pointer_v<mptr_t>) {
-                           return !bool(value.*glz::tuplet::get<1>(item));
-                        }
-                        else if constexpr (raw_nullable<val_t>) {
-                           return !bool(glz::tuplet::get<1>(item)(value).val);
+                        if constexpr (raw_nullable<val_t>) {
+                           return !bool(member(value).val);
                         }
                         else {
-                           return !bool(glz::tuplet::get<1>(item)(value));
+                           return !bool(get_member(value, member));
                         }
                      }();
                      if (is_null) return;
@@ -963,56 +1136,50 @@ namespace glz
                }
 
                // skip file_include
-               if constexpr (std::is_same_v<val_t, includer<std::decay_t<V>>>) {
+               if constexpr (is_includer<val_t>) {
                   return;
                }
                else if constexpr (std::is_same_v<val_t, hidden> || std::same_as<val_t, skip>) {
                   return;
                }
                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
+                  if constexpr (first_is_written && I > 0) {
                      write_entry_separator<Opts>(ctx, b, ix);
                   }
-
-                  using Key = typename std::decay_t<std::tuple_element_t<0, decltype(item)>>;
-
-                  if constexpr (str_t<Key> || char_t<Key>) {
-                     static constexpr sv key = glz::tuplet::get<0>(item);
-                     if constexpr (needs_escaping(key)) {
-                        write<json>::op<Opts>(key, ctx, b, ix);
-                        dump<':'>(b, ix);
-                        if constexpr (Opts.prettify) {
-                           dump<' '>(b, ix);
-                        }
+                  else {
+                     if (first) {
+                        first = false;
                      }
                      else {
-                        if constexpr (Opts.prettify) {
-                           static constexpr auto quoted_key = join_v<chars<"\"">, key, chars<"\": ">>;
-                           dump<quoted_key>(b, ix);
-                        }
-                        else {
-                           static constexpr auto quoted_key = join_v<chars<"\"">, key, chars<"\":">>;
-                           dump<quoted_key>(b, ix);
-                        }
+                        // 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);
+                     }
+                  }
+
+                  static constexpr sv key = key_name<I, T, use_reflection>;
+                  if constexpr (needs_escaping(key)) {
+                     write<json>::op<Opts>(key, ctx, b, ix);
+                     dump<':'>(b, ix);
+                     if constexpr (Opts.prettify) {
+                        dump<' '>(b, ix);
                      }
                   }
                   else {
-                     static constexpr auto quoted_key =
-                        concat_arrays(concat_arrays("\"", glz::tuplet::get<0>(item)), "\":", Opts.prettify ? " " : "");
-                     write<json>::op<Opts>(quoted_key, ctx, b, ix);
+                     static constexpr auto quoted_key = join_v < chars<"\"">, key,
+                                           Opts.prettify ? chars<"\": "> : chars < "\":" >>
+                        ;
+                     dump<quoted_key>(b, ix);
                   }
 
-                  write<json>::op<Opts>(get_member(value, glz::tuplet::get<1>(item)), ctx, b, ix);
+                  write<json>::op<Opts>(get_member(value, member), ctx, b, ix);
 
-                  static constexpr auto S = std::tuple_size_v<decltype(item)>;
-                  if constexpr (Opts.comments && S > 2) {
-                     if constexpr (std::is_convertible_v<decltype(glz::tuplet::get<2>(item)), std::string_view>) {
-                        static constexpr sv comment = glz::tuplet::get<2>(item);
+                  static constexpr size_t comment_index = member_index + 1;
+                  static constexpr auto S = std::tuple_size_v<typename Element::Item>;
+                  if constexpr (Opts.comments && S > comment_index) {
+                     static constexpr auto i = glz::get<I>(meta_v<V>);
+                     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);
@@ -1065,10 +1232,10 @@ namespace glz
       return buffer;
    }
 
-   template <class T>
+   template <opts Opts = opts{}, class T>
    [[nodiscard]] inline write_error write_file_json(T&& value, const std::string& file_name, auto&& buffer) noexcept
    {
-      write<opts{}>(std::forward<T>(value), buffer);
+      write<set_json<Opts>()>(std::forward<T>(value), buffer);
       return {buffer_to_file(buffer, file_name)};
    }
 }
diff --git a/src/core/include/glaze/record/recorder.hpp b/src/core/include/glaze/record/recorder.hpp
index cf2c07b2..bb5a4f37 100644
--- a/src/core/include/glaze/record/recorder.hpp
+++ b/src/core/include/glaze/record/recorder.hpp
@@ -40,6 +40,8 @@ namespace glz
    template <class... Ts>
    struct recorder
    {
+      static constexpr auto glaze_reflect = false;
+
       using container_type = std::variant<std::deque<Ts>...>;
 
       std::deque<std::pair<std::string, std::pair<container_type, const void*>>> data;
@@ -122,11 +124,11 @@ namespace glz
             }
 
             if constexpr (!Options.opening_handled) {
-               skip_ws<Options>(ctx, it, end);
-               match<'{'>(ctx, it, end);
+               skip_ws_no_pre_check<Options>(ctx, it, end);
+               match<'{'>(ctx, it);
             }
 
-            skip_ws<Options>(ctx, it, end);
+            skip_ws_no_pre_check<Options>(ctx, it, end);
 
             static constexpr auto Opts = opening_handled_off<ws_handled_off<Options>()>();
 
@@ -148,20 +150,20 @@ namespace glz
                }
 
                skip_ws<Opts>(ctx, it, end);
-               match<':'>(ctx, it, end);
+               match<':'>(ctx, it);
                skip_ws<Opts>(ctx, it, end);
 
                std::visit([&](auto&& deq) { read<json>::op<Opts>(deq, ctx, it, end); }, v.first);
 
                if (i < n - 1) {
                   skip_ws<Opts>(ctx, it, end);
-                  match<','>(ctx, it, end);
+                  match<','>(ctx, it);
                   skip_ws<Opts>(ctx, it, end);
                }
             }
 
             skip_ws<Opts>(ctx, it, end);
-            match<'}'>(ctx, it, end);
+            match<'}'>(ctx, it);
          }
       };
 
diff --git a/src/core/include/glaze/reflection/get_name.hpp b/src/core/include/glaze/reflection/get_name.hpp
new file mode 100644
index 00000000..eef10bff
--- /dev/null
+++ b/src/core/include/glaze/reflection/get_name.hpp
@@ -0,0 +1,175 @@
+// Glaze Library
+// For the license information refer to glaze.hpp
+
+#pragma once
+
+// TODO: Use std::source_location when deprecating clang 14
+// #include <source_location>
+#include <string_view>
+
+#include "glaze/reflection/to_tuple.hpp"
+#include "glaze/tuplet/tuple.hpp"
+
+#if defined(__clang__) || defined(__GNUC__)
+#define GLZ_PRETTY_FUNCTION __PRETTY_FUNCTION__
+#elif defined(_MSC_VER)
+#define GLZ_PRETTY_FUNCTION __FUNCSIG__
+#endif
+
+// For struct fields
+namespace glz::detail
+{
+   template <class T>
+   extern const T external;
+
+   // using const char* simplifies the complier's output and should improve compile times
+   template <auto Ptr>
+   [[nodiscard]] consteval auto mangled_name()
+   {
+      // return std::source_location::current().function_name();
+      return GLZ_PRETTY_FUNCTION;
+   }
+
+   template <class T>
+   [[nodiscard]] consteval auto mangled_name()
+   {
+      // return std::source_location::current().function_name();
+      return GLZ_PRETTY_FUNCTION;
+   }
+
+#if defined(__clang__)
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Weverything"
+   template <auto N, class T>
+   constexpr std::string_view get_name_impl = mangled_name<get_ptr<N>(external<T>)>();
+#pragma clang diagnostic pop
+#elif __GNUC__
+   template <auto N, class T>
+   constexpr std::string_view get_name_impl = mangled_name<get_ptr<N>(external<T>)>();
+#else
+   template <auto N, class T>
+   constexpr std::string_view get_name_impl = mangled_name<get_ptr<N>(external<T>)>();
+#endif
+
+   struct GLAZE_REFLECTOR
+   {
+      int GLAZE_FIELD;
+   };
+
+   struct reflect_field
+   {
+      static constexpr auto name = get_name_impl<0, GLAZE_REFLECTOR>;
+      static constexpr auto end = name.substr(name.find("GLAZE_FIELD") + sizeof("GLAZE_FIELD") - 1);
+      static constexpr auto begin = name[name.find("GLAZE_FIELD") - 1];
+   };
+
+   struct reflect_type
+   {
+      static constexpr std::string_view name = mangled_name<GLAZE_REFLECTOR>();
+      static constexpr auto end = name.substr(name.find("GLAZE_REFLECTOR") + sizeof("GLAZE_REFLECTOR") - 1);
+#if defined(__GNUC__) || defined(__clang__)
+      static constexpr auto begin = std::string_view{"T = "};
+#else
+      static constexpr auto begin = std::string_view{"glz::detail::mangled_name<"};
+#endif
+   };
+}
+
+namespace glz
+{
+   template <auto N, class T>
+   static constexpr auto nameof = [] {
+      constexpr auto name = detail::get_name_impl<N, T>;
+      constexpr auto begin = name.find(detail::reflect_field::end);
+      constexpr auto tmp = name.substr(0, begin);
+      return tmp.substr(tmp.find_last_of(detail::reflect_field::begin) + 1);
+   }();
+
+   template <class T>
+   static constexpr auto type_name = [] {
+      constexpr std::string_view name = detail::mangled_name<T>();
+      constexpr auto begin = name.find(detail::reflect_type::end);
+      constexpr auto tmp = name.substr(0, begin);
+#if defined(__GNUC__) || defined(__clang__)
+      return tmp.substr(tmp.rfind(detail::reflect_type::begin) + detail::reflect_type::begin.size());
+#else
+      constexpr auto name_with_keyword =
+         tmp.substr(tmp.rfind(detail::reflect_type::begin) + detail::reflect_type::begin.size());
+      return name_with_keyword.substr(name_with_keyword.find(' ') + 1);
+#endif
+   }();
+
+   template <class T, size_t... I>
+   [[nodiscard]] constexpr auto member_names_impl(std::index_sequence<I...>)
+   {
+      return std::array{nameof<I, T>...};
+   }
+
+   template <class T>
+   static constexpr auto member_names =
+      [] { return member_names_impl<T>(std::make_index_sequence<detail::count_members<T>>{}); }();
+}
+
+// For member object pointers
+namespace glz
+{
+   template <class T>
+   struct remove_member_pointer
+   {
+      using type = T;
+   };
+
+   template <class C, class T>
+   struct remove_member_pointer<T C::*>
+   {
+      using type = C;
+   };
+
+   template <class T, auto P>
+   consteval std::string_view get_name_msvc() noexcept
+   {
+      std::string_view str = GLZ_PRETTY_FUNCTION;
+      str = str.substr(str.find("->") + 2);
+      return str.substr(0, str.find(">"));
+   }
+
+#if defined(__clang__)
+   inline constexpr auto pretty_function_tail = "]";
+#elif defined(__GNUC__) || defined(__GNUG__)
+   inline constexpr auto pretty_function_tail = ";";
+#elif defined(_MSC_VER)
+#endif
+
+   template <auto P>
+      requires(std::is_member_object_pointer_v<decltype(P)>)
+   consteval std::string_view get_name() noexcept
+   {
+#if defined(_MSC_VER) && !defined(__clang__)
+      using T = remove_member_pointer<std::decay_t<decltype(P)>>::type;
+      constexpr auto p = P;
+      return get_name_msvc<T, &(detail::external<T>.*p)>();
+#else
+      // TODO: Use std::source_location when deprecating clang 14
+      // std::string_view str = std::source_location::current().function_name();
+      std::string_view str = GLZ_PRETTY_FUNCTION;
+      str = str.substr(str.find("&") + 1);
+      str = str.substr(0, str.find(pretty_function_tail));
+      return str.substr(str.rfind("::") + 2);
+#endif
+   }
+
+   template <auto E>
+      requires(std::is_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/src/core/include/glaze/reflection/reflect.hpp b/src/core/include/glaze/reflection/reflect.hpp
new file mode 100644
index 00000000..02066246
--- /dev/null
+++ b/src/core/include/glaze/reflection/reflect.hpp
@@ -0,0 +1,151 @@
+// Glaze Library
+// For the license information refer to glaze.hpp
+
+#pragma once
+
+#include "glaze/core/common.hpp"
+#include "glaze/reflection/get_name.hpp"
+#include "glaze/reflection/to_tuple.hpp"
+
+namespace glz
+{
+   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 = std::tuple_size_v<V>;
+         [[maybe_unused]] constexpr auto members = member_names<T>;
+         static_assert(count_members<T> == n);
+
+         using value_t = reflection_value_tuple_variant_t<V>;
+
+         auto naive_or_normal_hash = [&] {
+            if constexpr (n <= 20) {
+               return glz::detail::naive_map<value_t, n, use_hash_comparison>(
+                  {std::pair<sv, value_t>{get<I>(members), std::add_pointer_t<std::tuple_element_t<I, V>>{}}...});
+            }
+            else {
+               return glz::detail::normal_map<sv, value_t, n, use_hash_comparison>(
+                  {std::pair<sv, value_t>{get<I>(members), std::add_pointer_t<std::tuple_element_t<I, 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...>{
+               std::pair<sv, value_t>{get<I>(members), std::add_pointer_t<std::tuple_element_t<I, V>>{}}...};
+         }
+         else if constexpr (n == 2) {
+            return micro_map2<value_t, named_member<T, I>::value...>{
+               std::pair<sv, value_t>{get<I>(members), std::add_pointer_t<std::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 front_desc = single_char_hash<n>(member_names<T>);
+
+            if constexpr (front_desc.valid) {
+               return make_single_char_map<value_t, front_desc>(
+                  {{get<I>(members), std::add_pointer_t<std::tuple_element_t<I, V>>{}}...});
+            }
+            else {
+               constexpr auto back_desc = single_char_hash<n, false>(member_names<T>);
+
+               if constexpr (back_desc.valid) {
+                  return make_single_char_map<value_t, back_desc>(
+                     {{get<I>(members), std::add_pointer_t<std::tuple_element_t<I, V>>{}}...});
+               }
+               else {
+                  return naive_or_normal_hash();
+               }
+            }
+         }
+         else {
+            return naive_or_normal_hash();
+         }
+      }
+
+      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<std::decay_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));
+         for_each<count_members<T>>([&](auto I) {
+            std::get<std::add_pointer_t<std::decay_t<decltype(std::get<I>(t))>>>(std::get<I>(cmap.items).second) =
+               &std::get<I>(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 std::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 = std::decay_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 = std::decay_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));
+         for_each<count_members<T>>([&](auto I) { std::get<I>(tuple_of_ptrs) = &std::get<I>(t); });
+      }
+   }
+}
diff --git a/src/core/include/glaze/reflection/to_tuple.hpp b/src/core/include/glaze/reflection/to_tuple.hpp
new file mode 100644
index 00000000..4946d73e
--- /dev/null
+++ b/src/core/include/glaze/reflection/to_tuple.hpp
@@ -0,0 +1,1327 @@
+// Glaze Library
+// For the license information refer to glaze.hpp
+
+#pragma once
+
+#include <optional>
+#include <string_view>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+
+#include "glaze/util/type_traits.hpp"
+
+namespace glz
+{
+   namespace detail
+   {
+      struct any_t final
+      {
+#if defined(__clang__)
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Weverything"
+         template <class T>
+            requires(!std::same_as<T, const char*> && !std::same_as<T, std::nullptr_t>)
+         [[maybe_unused]] constexpr operator T();
+#pragma clang diagnostic pop
+#elif defined(_MSC_VER)
+         template <class T>
+            requires(!std::same_as<T, const char*> && !std::same_as<T, std::nullptr_t>)
+         [[maybe_unused]] constexpr operator T();
+
+         template <class T>
+            requires(is_specialization_v<T, std::optional>)
+         [[maybe_unused]] constexpr operator T()
+         {
+            return std::nullopt;
+         }
+#else
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+         template <class T>
+            requires(!std::same_as<T, const char*> && !std::same_as<T, std::nullptr_t>)
+         [[maybe_unused]] constexpr operator T();
+#pragma GCC diagnostic pop
+#endif
+
+         [[maybe_unused]] constexpr operator std::string_view() { return {}; }
+      };
+
+      template <class T, class... Args>
+         requires(std::is_aggregate_v<std::remove_cvref_t<T>>)
+      inline constexpr auto count_members = [] {
+         using V = std::remove_cvref_t<T>;
+         if constexpr (requires { V{{Args{}}..., {any_t{}}}; } == false) {
+            return sizeof...(Args);
+         }
+         else {
+            return count_members<V, Args..., any_t>;
+         }
+      }();
+
+      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);
+         }
+      }
+
+      template <class T>
+      struct ptr_t final
+      {
+         const T* ptr;
+      };
+
+      template <size_t N, class T>
+      constexpr auto get_ptr(T&& t) noexcept
+      {
+         decltype(auto) p = std::get<N>(to_tuple(t));
+         return ptr_t<std::decay_t<decltype(p)>>{&p};
+      }
+   }
+}
diff --git a/src/core/include/glaze/tuplet/tuple.hpp b/src/core/include/glaze/tuplet/tuple.hpp
index 0fb90da4..489a0c26 100644
--- a/src/core/include/glaze/tuplet/tuple.hpp
+++ b/src/core/include/glaze/tuplet/tuple.hpp
@@ -46,8 +46,7 @@ namespace glz
       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>;
+      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;
@@ -68,16 +67,16 @@ 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
+         } -> same_as<bool>;
+      };
    } // namespace tuplet
 
    // tuplet::type_list implementation
@@ -187,7 +186,8 @@ namespace glz
       // This takes a forwarding tuple as a parameter. The forwarding tuple only
       // contains references, so it should just be taken by value.
       template <class T, class... Outer, class... Inner>
-      constexpr auto cat_impl(T tup, type_list<Outer...>, type_list<Inner...>) -> tuple<type_t<Inner>...>
+      constexpr auto cat_impl([[maybe_unused]] T tup, type_list<Outer...>, type_list<Inner...>)
+         -> tuple<type_t<Inner>...>
       {
          return {{{static_cast<type_t<Outer>&&>(tup.identity_t<Outer>::value).identity_t<Inner>::value}...}};
       }
@@ -528,45 +528,42 @@ namespace glz
       convert(Tuple&&) -> convert<Tuple>;
    } // namespace tuplet
 
-   // tuplet::get implementation
-   // tuplet::tie implementation
-   // tuplet::apply implementation
-   namespace tuplet
+   // glz::get implementation
+   // glz::tie implementation
+   // glz::apply implementation
+   template <size_t I, tuplet::indexable Tup>
+   constexpr decltype(auto) get(Tup&& tup)
    {
-      template <size_t I, indexable Tup>
-      constexpr decltype(auto) get(Tup&& tup)
-      {
-         return static_cast<Tup&&>(tup)[tag<I>()];
-      }
+      return static_cast<Tup&&>(tup)[tuplet::tag<I>()];
+   }
 
-      template <class... T>
-      constexpr tuple<T&...> tie(T&... t)
-      {
-         return {t...};
-      }
+   template <class... T>
+   constexpr tuplet::tuple<T&...> tie(T&... t)
+   {
+      return {t...};
+   }
 
-      template <class F, base_list_tuple Tup>
-      constexpr decltype(auto) apply(F&& func, Tup&& tup)
-      {
-         return 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);
-      }
-   } // namespace tuplet
+   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);
+   }
 
    // tuplet::tuple_cat implementation
    // tuplet::make_tuple implementation
diff --git a/src/core/include/glaze/util/dtoa.hpp b/src/core/include/glaze/util/dtoa.hpp
index 867de766..1ab28d5e 100644
--- a/src/core/include/glaze/util/dtoa.hpp
+++ b/src/core/include/glaze/util/dtoa.hpp
@@ -1042,7 +1042,8 @@ namespace glz
                buffer[0] = '0';
                buffer[1] = '.';
                buffer += 2;
-               for (; buffer < num_hdr; ++buffer) *buffer = '0';
+               // we don't have to increment the buffer because we are returning
+               std::memset(buffer, '0', num_hdr - buffer);
                return num_end;
             }
             else {
@@ -1053,7 +1054,7 @@ namespace glz
                std::memset(buffer + 16, '0', 8);
                auto num_hdr = buffer + 1;
                auto num_end = write_u64_len_15_to_17_trim(num_hdr, sig_dec);
-               for (int i = 0; i < dot_pos; i++) buffer[i] = buffer[i + 1];
+               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;
             }
diff --git a/src/core/include/glaze/util/dump.hpp b/src/core/include/glaze/util/dump.hpp
index e1c93abb..63e6f89a 100644
--- a/src/core/include/glaze/util/dump.hpp
+++ b/src/core/include/glaze/util/dump.hpp
@@ -273,6 +273,7 @@ namespace glz::detail
    template <class B>
    GLZ_ALWAYS_INLINE void dump(const std::span<const std::byte> bytes, B&& b, auto& ix) noexcept
    {
+      assert(ix <= b.size());
       const auto n = bytes.size();
       if (ix + n > b.size()) [[unlikely]] {
          b.resize((std::max)(b.size() * 2, ix + n));
@@ -285,6 +286,7 @@ namespace glz::detail
    template <size_t N, class B>
    GLZ_ALWAYS_INLINE void dump(const std::array<uint8_t, N>& bytes, B&& b, auto& ix) noexcept
    {
+      assert(ix <= b.size());
       if (ix + N > b.size()) [[unlikely]] {
          b.resize((std::max)(b.size() * 2, ix + N));
       }
diff --git a/src/core/include/glaze/util/expected.hpp b/src/core/include/glaze/util/expected.hpp
index 27c57314..56c3b52a 100644
--- a/src/core/include/glaze/util/expected.hpp
+++ b/src/core/include/glaze/util/expected.hpp
@@ -48,11 +48,15 @@ namespace glz
    }
 }
 
+#ifdef __has_include
 #if __has_include(<expected>)
 #include <expected>
+#elif __has_include(<experimental/expected>)
+#include <experimental/expected>
+#endif
 #endif
 
-#ifdef __cpp_lib_expected
+#if defined(__cpp_lib_expected)
 namespace glz
 {
    template <class expected_t, class unexpected_t>
@@ -122,10 +126,10 @@ namespace glz
 
       template <class E2>
          requires(requires(const E& x, E2 const& y) {
-                     {
-                        x == y
-                        } -> std::convertible_to<bool>;
-                  })
+            {
+               x == y
+            } -> std::convertible_to<bool>;
+         })
       friend constexpr auto operator==(const unexpected& x, const unexpected<E2>& y) -> bool
       {
          return x.value() == y.value();
@@ -200,19 +204,48 @@ namespace glz
    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> >);
+      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> >;
@@ -475,7 +508,7 @@ namespace glz
          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&
+      constexpr auto operator=(const unexpected<G>& e) -> expected&
       {
          using GF = const G&;
          if (has_value()) {
@@ -492,7 +525,7 @@ namespace glz
          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&
+      constexpr auto operator=(unexpected<G>&& e) -> expected&
       {
          using GF = G;
          if (has_value()) {
@@ -667,14 +700,14 @@ namespace glz
 
       template <class U>
          requires std::is_copy_constructible_v<T> && std::is_convertible_v<U, T>
-                                                  constexpr auto value_or(U&& v) const& -> 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
+      constexpr auto value_or(U&& v) && -> T
       {
          return has_value() ? std::move(**this) : static_cast<T>(std::forward<U>(v));
       }
@@ -922,15 +955,14 @@ namespace glz
       // 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
+            {
+               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;
@@ -947,10 +979,10 @@ namespace glz
 
       template <class E2>
          requires requires(const E& x, const unexpected<E2>& e) {
-                     {
-                        x == e.value()
-                        } -> std::convertible_to<bool>;
-                  }
+            {
+               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());
@@ -1115,7 +1147,7 @@ namespace glz
 
       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&
+      constexpr auto operator=(const unexpected<G>& e) -> expected&
       {
          if (has_value()) {
             std::construct_at(std::addressof(this->unex), std::forward<const G&>(e.value()));
@@ -1129,7 +1161,7 @@ namespace glz
 
       template <class G>
          requires std::is_constructible_v<E, G> && std::is_assignable_v<E&, G>
-                                                constexpr auto operator=(unexpected<G>&& e) -> expected&
+      constexpr auto operator=(unexpected<G>&& e) -> expected&
       {
          if (has_value()) {
             std::construct_at(std::addressof(this->unex), std::forward<G>(e.value()));
@@ -1448,12 +1480,11 @@ namespace glz
       // 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
+            {
+               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());
@@ -1461,10 +1492,10 @@ namespace glz
 
       template <class E2>
          requires requires(const expected& x, const unexpected<E2>& e) {
-                     {
-                        x.error() == e.value()
-                        } -> std::convertible_to<bool>;
-                  }
+            {
+               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());
diff --git a/src/core/include/glaze/util/fixed_string.hpp b/src/core/include/glaze/util/fixed_string.hpp
deleted file mode 100644
index 301e4487..00000000
--- a/src/core/include/glaze/util/fixed_string.hpp
+++ /dev/null
@@ -1,40 +0,0 @@
-// Glaze Library
-// For the license information refer to glaze.hpp
-
-#pragma once
-
-#include <algorithm>
-#include <string_view>
-
-namespace glz
-{
-   template <class CharType, unsigned N>
-   struct [[nodiscard]] basic_fixed_string
-   {
-      using char_type = CharType;
-
-      char_type data_[N + 1]{};
-
-      constexpr basic_fixed_string() noexcept : data_{} {}
-
-      template <class other_char_type>
-         requires std::same_as<other_char_type, char_type>
-      constexpr basic_fixed_string(const other_char_type (&foo)[N + 1]) noexcept
-      {
-         std::copy_n(foo, N + 1, data_);
-      }
-
-      [[nodiscard]] constexpr std::basic_string_view<char_type> view() const noexcept { return {&data_[0], N}; }
-
-      constexpr operator std::basic_string_view<char_type>() const noexcept { return {&data_[0], N}; }
-
-      template <unsigned M>
-      constexpr auto operator==(const basic_fixed_string<char_type, M>& r) const noexcept
-      {
-         return N == M && view() == r.view();
-      }
-   };
-
-   template <class char_type, unsigned N>
-   basic_fixed_string(const char_type (&str)[N]) -> basic_fixed_string<char_type, N - 1>;
-}
diff --git a/src/core/include/glaze/util/hash_map.hpp b/src/core/include/glaze/util/hash_map.hpp
index e1ce19d9..5edeb227 100644
--- a/src/core/include/glaze/util/hash_map.hpp
+++ b/src/core/include/glaze/util/hash_map.hpp
@@ -18,6 +18,11 @@
 #include <span>
 #include <string_view>
 
+#ifdef _MSC_VER
+// Turn off broken warning from MSVC for << operator precedence
+#pragma warning(disable : 4554)
+#endif
+
 // Notes on padding:
 // We only need to do buffer extensions on very short keys (n < 8)
 // Our static thread_local string_buffer always has enough padding for short strings (n < 8)
@@ -25,7 +30,6 @@
 // Typically short keys are not going to be at the end of the buffer
 // For valid keys we always have a quote and a null character '\0'
 // Our key can be empty, which means we need 6 bytes of additional padding
-// Getting rid of the page boundary check is an improvement to performance and safer overall
 
 namespace glz::detail
 {
@@ -35,7 +39,7 @@ namespace glz::detail
       uint64_t res{};
       if (std::is_constant_evaluated()) {
          for (size_t i = 0; i < N; ++i) {
-            res |= (uint64_t(bytes[i]) << (i << 3));
+            res |= (uint64_t(uint8_t(bytes[i])) << (i << 3));
          }
       }
       else {
@@ -84,7 +88,7 @@ namespace glz::detail
       if (std::is_constant_evaluated()) {
          uint64_t res{};
          for (size_t i = 0; i < N; ++i) {
-            res |= (uint64_t(bytes[i]) << (i << 3));
+            res |= (uint64_t(uint8_t(bytes[i])) << (i << 3));
          }
          return res;
       }
@@ -282,13 +286,12 @@ namespace glz::detail
       static constexpr auto max_bucket_size = 2 * std::bit_width(N);
       using hash_alg = naive_hash;
       uint64_t seed{};
-      // TODO: We can probably save space by using smaller items in the table (We know the range stored)
       // The extra info in the bucket most likely does not need to be 64 bits
       std::array<int64_t, N> buckets{};
       using storage_type = decltype(fit_unsigned_type<N>());
       std::array<storage_type, storage_size> table{};
       std::array<std::pair<Key, Value>, N> items{};
-      std::array<uint64_t, N> hashes{};
+      std::array<uint64_t, N + 1> hashes{}; // Save one more hash value of 0 for unknown keys
 
       constexpr decltype(auto) begin() const { return items.begin(); }
       constexpr decltype(auto) end() const { return items.end(); }
@@ -331,7 +334,7 @@ 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 extra = buckets[hash % N];
-         auto index = extra < 1 ? -extra : table[combine(hash, extra) % storage_size];
+         const auto 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 keys could colide becuase of perfect hashing so this
@@ -390,7 +393,8 @@ namespace glz::detail
          std::sort(buckets_index.begin(), buckets_index.end(),
                    [&bucket_sizes](size_t i1, size_t i2) { return bucket_sizes[i1] > bucket_sizes[i2]; });
 
-         std::fill(table.begin(), table.end(), storage_type(-1));
+         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;
@@ -402,12 +406,12 @@ namespace glz::detail
             do {
                failed = false;
                // We need to reserve top bit for bucket_size == 1
-               auto secondary_seed = gen() >> 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] != storage_type(-1)) {
+                  if (table[slot] != unknown_key_indice) {
                      failed = true;
                      table = table_old;
                      break;
@@ -533,14 +537,12 @@ namespace glz::detail
    {
       std::array<std::pair<std::string_view, T>, 1> items{};
 
-      static constexpr auto s = S; // Needed for MSVC to avoid an internal compiler error
-
       constexpr decltype(auto) begin() const { return items.begin(); }
       constexpr decltype(auto) end() const { return items.end(); }
 
       constexpr decltype(auto) find(auto&& key) const noexcept
       {
-         if (s == key) [[likely]] {
+         if (S == key) [[likely]] {
             return items.begin();
          }
          else [[unlikely]] {
@@ -552,17 +554,16 @@ namespace glz::detail
    template <const std::string_view& S, bool CheckSize = true>
    inline constexpr bool cx_string_cmp(const std::string_view key) noexcept
    {
-      constexpr auto s = S; // Needed for MSVC to avoid an internal compiler error
-      constexpr auto n = s.size();
+      constexpr auto n = S.size();
       if (std::is_constant_evaluated()) {
-         return key == s;
+         return key == S;
       }
       else {
          if constexpr (CheckSize) {
-            return (key.size() == n) && (std::memcmp(key.data(), s.data(), n) == 0);
+            return (key.size() == n) && (std::memcmp(key.data(), S.data(), n) == 0);
          }
          else {
-            return std::memcmp(key.data(), s.data(), n) == 0;
+            return std::memcmp(key.data(), S.data(), n) == 0;
          }
       }
    }
@@ -572,11 +573,8 @@ namespace glz::detail
    {
       std::array<std::pair<std::string_view, T>, 2> items{};
 
-      static constexpr auto s0 = S0; // Needed for MSVC to avoid an internal compiler error
-      static constexpr auto s1 = S1; // Needed for MSVC to avoid an internal compiler error
-
       static constexpr bool same_size =
-         s0.size() == s1.size(); // if we need to check the size again on the second compare
+         S0.size() == S1.size(); // if we need to check the size again on the second compare
       static constexpr bool check_size = !same_size;
 
       constexpr decltype(auto) begin() const { return items.begin(); }
@@ -585,16 +583,16 @@ namespace glz::detail
       constexpr decltype(auto) find(auto&& key) const noexcept
       {
          if constexpr (same_size) {
-            constexpr auto n = s0.size();
+            constexpr auto n = S0.size();
             if (key.size() != n) {
                return items.end();
             }
          }
 
-         if (cx_string_cmp<s0, check_size>(key)) {
+         if (cx_string_cmp<S0, check_size>(key)) {
             return items.begin();
          }
-         else if (cx_string_cmp<s1, check_size>(key)) {
+         else if (cx_string_cmp<S1, check_size>(key)) {
             return items.begin() + 1;
          }
          else [[unlikely]] {
diff --git a/src/core/include/glaze/util/itoa.hpp b/src/core/include/glaze/util/itoa.hpp
index 208e440c..924a83b0 100644
--- a/src/core/include/glaze/util/itoa.hpp
+++ b/src/core/include/glaze/util/itoa.hpp
@@ -48,13 +48,6 @@ namespace glz
       '0', '8', '1', '8', '2', '8', '3', '8', '4', '8', '5', '8', '6', '8', '7', '8', '8', '8', '9', '9', '0', '9', '1',
       '9', '2', '9', '3', '9', '4', '9', '5', '9', '6', '9', '7', '9', '8', '9', '9'};
 
-   /* This struct can help compiler generate 2-byte load/store */
-   /* instructions on platforms that support unaligned access. */
-   struct pair final
-   {
-      char c1, c2;
-   };
-
    template <class T>
       requires std::same_as<T, uint32_t>
    inline auto* to_chars(auto* buf, T val) noexcept
@@ -139,12 +132,11 @@ namespace glz
 
    template <class T>
       requires std::same_as<T, int32_t>
-   inline auto* to_chars(auto* buf, T val) noexcept
+   inline auto* to_chars(auto* buf, T x) noexcept
    {
-      uint32_t neg = uint32_t(-val);
-      std::size_t sign = val < 0;
       *buf = '-';
-      return to_chars(buf + sign, sign ? uint32_t(neg) : uint32_t(val));
+      // shifts are necessary to have the numeric_limits<int32_t>::min case
+      return to_chars(buf + (x < 0), uint32_t(x ^ (x >> 31)) - (x >> 31));
    }
 
    GLZ_ALWAYS_INLINE auto* to_chars_u64_len_8(auto* buf, uint32_t val) noexcept
@@ -167,9 +159,8 @@ namespace glz
    GLZ_ALWAYS_INLINE auto* to_chars_u64_len_4(auto* buf, uint32_t val) noexcept
    {
       /* 4 digits: aabb */
-      uint32_t aa, bb;
-      aa = (val * 5243) >> 19; /* (val / 100) */
-      bb = val - aa * 100; /* (val % 100) */
+      const uint32_t aa = (val * 5243) >> 19; /* (val / 100) */
+      const uint32_t bb = val - aa * 100; /* (val % 100) */
       std::memcpy(buf, char_table + aa * 2, 2);
       std::memcpy(buf + 2, char_table + bb * 2, 2);
       return buf + 4;
@@ -226,14 +217,12 @@ namespace glz
 
    inline auto* to_chars_u64_len_5_8(auto* buf, uint32_t val) noexcept
    {
-      uint32_t aa, bb, cc, dd, aabb, bbcc, ccdd, lz;
-
       if (val < 1000000) { /* 5-6 digits: aabbcc */
-         aa = uint32_t((uint64_t(val) * 429497) >> 32); /* (val / 10000) */
-         bbcc = val - aa * 10000; /* (val % 10000) */
-         bb = (bbcc * 5243) >> 19; /* (bbcc / 100) */
-         cc = bbcc - bb * 100; /* (bbcc % 100) */
-         lz = aa < 10;
+         const uint32_t aa = uint32_t((uint64_t(val) * 429497) >> 32); /* (val / 10000) */
+         const uint32_t bbcc = val - aa * 10000; /* (val % 10000) */
+         const uint32_t bb = (bbcc * 5243) >> 19; /* (bbcc / 100) */
+         const uint32_t cc = bbcc - bb * 100; /* (bbcc % 100) */
+         const uint32_t lz = aa < 10;
          std::memcpy(buf, char_table + aa * 2 + lz, 2);
          buf -= lz;
          std::memcpy(buf + 2, char_table + bb * 2, 2);
@@ -242,13 +231,13 @@ namespace glz
       }
       else { /* 7-8 digits: aabbccdd */
          /* (val / 10000) */
-         aabb = uint32_t((uint64_t(val) * 109951163) >> 40);
-         ccdd = val - aabb * 10000; /* (val % 10000) */
-         aa = (aabb * 5243) >> 19; /* (aabb / 100) */
-         cc = (ccdd * 5243) >> 19; /* (ccdd / 100) */
-         bb = aabb - aa * 100; /* (aabb % 100) */
-         dd = ccdd - cc * 100; /* (ccdd % 100) */
-         lz = aa < 10;
+         const uint32_t aabb = uint32_t((uint64_t(val) * 109951163) >> 40);
+         const uint32_t ccdd = val - aabb * 10000; /* (val % 10000) */
+         const uint32_t aa = (aabb * 5243) >> 19; /* (aabb / 100) */
+         const uint32_t cc = (ccdd * 5243) >> 19; /* (ccdd / 100) */
+         const uint32_t bb = aabb - aa * 100; /* (aabb % 100) */
+         const uint32_t dd = ccdd - cc * 100; /* (ccdd % 100) */
+         const uint32_t lz = aa < 10;
          std::memcpy(buf, char_table + aa * 2 + lz, 2);
          buf -= lz;
          std::memcpy(buf + 2, char_table + bb * 2, 2);
@@ -262,26 +251,23 @@ namespace glz
       requires std::same_as<T, uint64_t>
    inline auto* to_chars(auto* buf, T val) noexcept
    {
-      uint64_t tmp, hgh;
-      uint32_t mid, low;
-
       if (val < 100000000) { /* 1-8 digits */
          buf = to_chars_u64_len_1_8(buf, uint32_t(val));
          return buf;
       }
       else if (val < 100000000ull * 100000000ull) { /* 9-16 digits */
-         hgh = val / 100000000;
-         low = uint32_t(val - hgh * 100000000); /* (val % 100000000) */
+         const uint64_t hgh = val / 100000000;
+         const auto low = uint32_t(val - hgh * 100000000); /* (val % 100000000) */
          buf = to_chars_u64_len_1_8(buf, uint32_t(hgh));
          buf = to_chars_u64_len_8(buf, low);
          return buf;
       }
       else { /* 17-20 digits */
-         tmp = val / 100000000;
-         low = uint32_t(val - tmp * 100000000); /* (val % 100000000) */
-         hgh = uint32_t(tmp / 10000);
-         mid = uint32_t(tmp - hgh * 10000); /* (tmp % 10000) */
-         buf = to_chars_u64_len_5_8(buf, uint32_t(hgh));
+         const uint64_t tmp = val / 100000000;
+         const auto low = uint32_t(val - tmp * 100000000); /* (val % 100000000) */
+         const auto hgh = uint32_t(tmp / 10000);
+         const auto mid = uint32_t(tmp - hgh * 10000); /* (tmp % 10000) */
+         buf = to_chars_u64_len_5_8(buf, hgh);
          buf = to_chars_u64_len_4(buf, mid);
          buf = to_chars_u64_len_8(buf, low);
          return buf;
@@ -290,11 +276,10 @@ namespace glz
 
    template <class T>
       requires std::same_as<T, int64_t>
-   inline auto* to_chars(auto* buf, T val) noexcept
+   inline auto* to_chars(auto* buf, T x) noexcept
    {
-      uint64_t neg = uint64_t(-val);
-      std::size_t sign = val < 0;
       *buf = '-';
-      return to_chars(buf + sign, sign ? uint64_t(neg) : uint64_t(val));
+      // shifts are necessary to have the numeric_limits<int64_t>::min case
+      return to_chars(buf + (x < 0), uint64_t(x ^ (x >> 63)) - (x >> 63));
    }
 }
diff --git a/src/core/include/glaze/util/murmur.hpp b/src/core/include/glaze/util/murmur.hpp
index 094b0638..ca1a68a2 100644
--- a/src/core/include/glaze/util/murmur.hpp
+++ b/src/core/include/glaze/util/murmur.hpp
@@ -63,7 +63,7 @@ namespace glz
       // we use. Swaps only apply when the memory is copied in a chunk.
       h ^= murmur_32_scramble(k);
       /* Finalize. */
-      h ^= static_cast<uint32_t>(n); // static_cast needed for MSVC 2019
+      h ^= uint32_t(n);
       h ^= h >> 16;
       h *= 0x85ebca6b;
       h ^= h >> 13;
diff --git a/src/core/include/glaze/util/parse.hpp b/src/core/include/glaze/util/parse.hpp
index 4019f648..143ed00b 100644
--- a/src/core/include/glaze/util/parse.hpp
+++ b/src/core/include/glaze/util/parse.hpp
@@ -6,6 +6,7 @@
 #include <bit>
 #include <cstring>
 #include <iterator>
+#include <locale>
 #include <span>
 
 #include "glaze/api/name.hpp"
@@ -19,6 +20,36 @@
 
 namespace glz::detail
 {
+   // clang-format off
+   constexpr std::array<char, 256> char_unescape_table = { //
+      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, '\b', 0, //
+      0, 0, '\f', 0, 0, 0, 0, 0, 0, 0, //
+      '\n', 0, 0, 0, '\r', 0, '\t', 0, 0, 0, //
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 0 //
+   };
+   // clang-format on
+
+   // assumes null terminated
+   template <char c>
+   GLZ_ALWAYS_INLINE void match(is_context auto&& ctx, auto&& it) noexcept
+   {
+      if (*it != c) [[unlikely]] {
+         ctx.error = error_code::syntax_error;
+      }
+      else [[likely]] {
+         ++it;
+      }
+   }
+
    // assumes null terminated
    template <char c>
    GLZ_ALWAYS_INLINE void match(is_context auto&& ctx, auto&& it, auto&&) noexcept
@@ -34,12 +65,12 @@ namespace glz::detail
    template <string_literal str>
    GLZ_ALWAYS_INLINE void match(is_context auto&& ctx, auto&& it, auto&& end) noexcept
    {
-      const auto n = static_cast<size_t>(std::distance(it, end));
-      if ((n < str.size) || (std::memcmp(it, str.value, str.size) != 0)) [[unlikely]] {
+      const auto n = size_t(end - it);
+      if ((n < str.size()) || std::memcmp(&*it, str.value, str.size())) [[unlikely]] {
          ctx.error = error_code::syntax_error;
       }
-      else {
-         it += str.size;
+      else [[likely]] {
+         it += str.size();
       }
    }
 
@@ -74,85 +105,113 @@ namespace glz::detail
       }
    }
 
-   template <opts Opts>
-   GLZ_ALWAYS_INLINE void skip_ws(is_context auto&& ctx, auto&& it, auto&& end) noexcept
+   consteval uint64_t repeat_byte(char c)
    {
-      if (bool(ctx.error)) [[unlikely]] {
-         return;
-      }
+      const auto byte = uint8_t(c);
+      uint64_t res{};
+      res |= uint64_t(byte) << 56;
+      res |= uint64_t(byte) << 48;
+      res |= uint64_t(byte) << 40;
+      res |= uint64_t(byte) << 32;
+      res |= uint64_t(byte) << 24;
+      res |= uint64_t(byte) << 16;
+      res |= uint64_t(byte) << 8;
+      res |= uint64_t(byte);
+      return res;
+   }
 
-      while (true) {
-         switch (*it) {
-         case '\t':
-         case '\n':
-         case '\r':
-         case ' ':
-            ++it;
-            break;
-         case '/': {
-            if constexpr (Opts.force_conformance) {
-               ctx.error = error_code::syntax_error;
-               return;
-            }
-            else {
+   GLZ_ALWAYS_INLINE constexpr auto has_zero(const uint64_t chunk) noexcept
+   {
+      return (((chunk - 0x0101010101010101) & ~chunk) & 0x8080808080808080);
+   }
+
+   GLZ_ALWAYS_INLINE constexpr auto has_quote(const uint64_t chunk) noexcept
+   {
+      return has_zero(chunk ^ repeat_byte('"'));
+   }
+
+   GLZ_ALWAYS_INLINE constexpr auto has_escape(const uint64_t chunk) noexcept
+   {
+      return has_zero(chunk ^ repeat_byte('\\'));
+   }
+
+   GLZ_ALWAYS_INLINE constexpr auto has_space(const uint64_t chunk) noexcept
+   {
+      return has_zero(chunk ^ repeat_byte(' '));
+   }
+
+   GLZ_ALWAYS_INLINE constexpr auto has_forward_slash(const uint64_t chunk) noexcept
+   {
+      return has_zero(chunk ^ repeat_byte('/'));
+   }
+
+   GLZ_ALWAYS_INLINE constexpr uint64_t is_less_16(const uint64_t c) noexcept
+   {
+      return has_zero(c & 0b1111000011110000111100001111000011110000111100001111000011110000);
+   }
+
+   GLZ_ALWAYS_INLINE constexpr uint64_t is_greater_15(const uint64_t c) noexcept
+   {
+      return (c & 0b1111000011110000111100001111000011110000111100001111000011110000);
+   }
+
+   template <opts Opts>
+   GLZ_ALWAYS_INLINE void skip_ws_no_pre_check(is_context auto&& ctx, auto&& it, auto&& end) noexcept
+   {
+      if constexpr (!Opts.force_conformance) {
+         while (true) {
+            switch (*it) {
+            case '\t':
+            case '\n':
+            case '\r':
+            case ' ':
+               ++it;
+               break;
+            case '/': {
                skip_comment(ctx, it, end);
                if (bool(ctx.error)) [[unlikely]] {
                   return;
                }
                break;
             }
-         }
-         default:
-            return;
+            default:
+               return;
+            }
          }
       }
-   }
-
-   GLZ_ALWAYS_INLINE void skip_ws_no_comments(auto&& it) noexcept
-   {
-      while (true) {
-         switch (*it) {
-         case '\t':
-         case '\n':
-         case '\r':
-         case ' ':
-            ++it;
-            break;
-         default:
-            return;
+      else {
+         while (true) {
+            switch (*it) {
+            case '\t':
+            case '\n':
+            case '\r':
+            case ' ':
+               ++it;
+               break;
+            default:
+               return;
+            }
          }
       }
    }
 
-   GLZ_ALWAYS_INLINE auto has_zero(const uint64_t chunk) noexcept
-   {
-      return (((chunk - 0x0101010101010101) & ~chunk) & 0x8080808080808080);
-   }
-
-   GLZ_ALWAYS_INLINE auto has_quote(const uint64_t chunk) noexcept
-   {
-      return has_zero(chunk ^ 0b0010001000100010001000100010001000100010001000100010001000100010);
-   }
-
-   GLZ_ALWAYS_INLINE auto has_escape(const uint64_t chunk) noexcept
+   template <opts Opts>
+   GLZ_ALWAYS_INLINE void skip_ws(is_context auto&& ctx, auto&& it, auto&& end) noexcept
    {
-      return has_zero(chunk ^ 0b0101110001011100010111000101110001011100010111000101110001011100);
+      if (ctx.error == error_code::none) [[likely]] {
+         skip_ws_no_pre_check<Opts>(ctx, it, end);
+      }
    }
 
    GLZ_ALWAYS_INLINE void skip_till_escape_or_quote(is_context auto&& ctx, auto&& it, auto&& end) noexcept
    {
       static_assert(std::contiguous_iterator<std::decay_t<decltype(it)>>);
 
-      if (bool(ctx.error)) [[unlikely]] {
-         return;
-      }
-
-      const auto end_m7 = end - 7;
-      for (; it < end_m7; it += 8) {
+      for (const auto end_m7 = end - 7; it < end_m7; it += 8) {
          uint64_t chunk;
          std::memcpy(&chunk, it, 8);
-         uint64_t test_chars = has_quote(chunk) | has_escape(chunk);
-         if (test_chars != 0) {
+         const uint64_t test_chars = has_quote(chunk) | has_escape(chunk);
+         if (test_chars) {
             it += (std::countr_zero(test_chars) >> 3);
             return;
          }
@@ -173,10 +232,6 @@ namespace glz::detail
 
    GLZ_ALWAYS_INLINE void skip_till_quote(is_context auto&& ctx, auto&& it, auto&& end) noexcept
    {
-      if (bool(ctx.error)) [[unlikely]] {
-         return;
-      }
-
       static_assert(std::contiguous_iterator<std::decay_t<decltype(it)>>);
 
       auto* pc = std::memchr(it, '"', std::distance(it, end));
@@ -185,49 +240,176 @@ namespace glz::detail
          return;
       }
 
-      /*const auto end_m7 = end - 7;
-      for (; it < end_m7; it += 8) {
-         uint64_t chunk;
-         std::memcpy(&chunk, it, 8);
-         uint64_t char_test = has_quote(chunk);
-         if (char_test != 0) {
-            it += (std::countr_zero(char_test) >> 3);
-            return;
+      ctx.error = error_code::expected_quote;
+   }
+
+   template <opts Opts>
+   GLZ_ALWAYS_INLINE bool skip_till_unescaped_quote(is_context auto&& ctx, auto&& it, auto&& end) noexcept
+   {
+      static_assert(std::contiguous_iterator<std::decay_t<decltype(it)>>);
+
+      if constexpr (!Opts.force_conformance) {
+         bool escaped = false;
+         for (const auto fin = end - 7; it < fin;) {
+            uint64_t chunk;
+            std::memcpy(&chunk, it, 8);
+            uint64_t test_chars = has_quote(chunk);
+            escaped |= has_escape(chunk);
+            if (test_chars) {
+               it += (std::countr_zero(test_chars) >> 3);
+
+               auto* prev = it - 1;
+               while (*prev == '\\') {
+                  --prev;
+               }
+               if (size_t(it - prev) % 2) {
+                  return escaped;
+               }
+               ++it; // skip the escaped quote
+            }
+            else {
+               it += 8;
+            }
+         }
+
+         // Tail end of buffer. Should be rare we even get here
+         while (it < end) {
+            switch (*it) {
+            case '\\': {
+               escaped = true;
+               ++it;
+               if (it == end) [[unlikely]] {
+                  ctx.error = error_code::expected_quote;
+                  return true;
+               }
+               ++it;
+               break;
+            }
+            case '"': {
+               auto* prev = it - 1;
+               while (*prev == '\\') {
+                  --prev;
+                  escaped = true;
+               }
+               if (size_t(it - prev) % 2) {
+                  return escaped;
+               }
+               ++it; // skip the escaped quote
+               break;
+            }
+            default: {
+               ++it;
+            }
+            }
          }
       }
+      else {
+         bool escaped = false;
+         for (const auto fin = end - 7; it < fin;) {
+            uint64_t chunk;
+            std::memcpy(&chunk, it, 8);
+            uint64_t test_chars = has_quote(chunk) | has_escape(chunk) | is_less_16(chunk);
+            if (test_chars) {
+               it += (std::countr_zero(test_chars) >> 3);
+
+               if (*it == '"') {
+                  return escaped;
+               }
+               else if (*it == '\\') [[likely]] {
+                  ++it;
+                  if (char_unescape_table[*it]) [[likely]] {
+                     ++it;
+                     continue;
+                  }
+                  else if (*it == 'u') [[unlikely]] {
+                     ++it;
+                     if ((end - it) < 4) [[unlikely]] {
+                        ctx.error = error_code::syntax_error;
+                        return true;
+                     }
+                     else if (std::all_of(it, it + 4, ::isxdigit)) [[likely]] {
+                        it += 4;
+                        continue;
+                     }
+                     else [[unlikely]] {
+                        ctx.error = error_code::syntax_error;
+                        return true;
+                     }
+                  }
+               }
+               ctx.error = error_code::syntax_error;
+               return true;
+            }
+            else {
+               it += 8;
+            }
+         }
 
-      // Tail end of buffer. Should be rare we even get here
-      while (it < end) {
-         switch (*it) {
+         // Tail end of buffer. Should be rare we even get here
+         while (it < end) {
+            if (*it < 16) [[unlikely]] {
+               ctx.error = error_code::syntax_error;
+               return true;
+            }
+
+            switch (*it) {
+            case '\\': {
+               escaped = true;
+               ++it;
+               if (char_unescape_table[*it]) [[likely]] {
+                  ++it;
+               }
+               else if (*it == 'u') {
+                  ++it;
+                  if ((end - it) < 4) [[unlikely]] {
+                     ctx.error = error_code::syntax_error;
+                     return true;
+                  }
+                  else if (std::all_of(it, it + 4, ::isxdigit)) [[likely]] {
+                     it += 4;
+                     continue;
+                  }
+                  else [[unlikely]] {
+                     ctx.error = error_code::syntax_error;
+                     return true;
+                  }
+               }
+               else [[unlikely]] {
+                  ctx.error = error_code::syntax_error;
+                  return true;
+               }
+
+               break;
+            }
             case '"': {
-               return;
+               return escaped;
+            }
+            default: {
+               ++it;
+            }
             }
          }
-         ++it;
-      }*/
+      }
+
       ctx.error = error_code::expected_quote;
+      return false;
    }
 
    // very similar code to skip_till_quote, but it consumes the iterator and returns the key
    [[nodiscard]] GLZ_ALWAYS_INLINE const sv parse_unescaped_key(is_context auto&& ctx, auto&& it, auto&& end) noexcept
    {
-      if (bool(ctx.error)) [[unlikely]] {
-         return {};
-      }
-
       static_assert(std::contiguous_iterator<std::decay_t<decltype(it)>>);
 
       auto start = it;
 
-      const auto end_m7 = end - 7;
-      for (; it < end_m7; it += 8) {
+      for (const auto end_m7 = end - 7; it < end_m7; it += 8) {
          uint64_t chunk;
          std::memcpy(&chunk, it, 8);
          uint64_t test_chars = has_quote(chunk);
-         if (test_chars != 0) {
+         if (test_chars) {
             it += (std::countr_zero(test_chars) >> 3);
 
-            sv ret{start, static_cast<size_t>(it - start)};
+            sv ret{start, size_t(it - start)};
             ++it;
             return ret;
          }
@@ -235,51 +417,140 @@ namespace glz::detail
 
       // Tail end of buffer. Should be rare we even get here
       while (it < end) {
-         switch (*it) {
-         case '"': {
-            sv ret{start, static_cast<size_t>(it - start)};
+         if (*it == '"') {
+            sv ret{start, size_t(it - start)};
             ++it;
             return ret;
          }
-         }
          ++it;
       }
       ctx.error = error_code::expected_quote;
       return {};
    }
 
-   // very similar code to skip_till_quote, but it consumes the iterator and returns the key
-   template <uint32_t MinLength, uint32_t LengthRange>
-   [[nodiscard]] GLZ_ALWAYS_INLINE const sv parse_key_cx(is_context auto&& ctx, auto&& it) noexcept
+   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;
+
       auto start = it;
-      it += MinLength; // immediately skip minimum length
 
-      static_assert(LengthRange < 16);
-      if constexpr (LengthRange == 7) {
+      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 += (std::countr_zero(test_chunk) >> 3);
+               return {start, size_t(it - start)};
+            }
+            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 += (std::countr_zero(test_chars) >> 3);
+                  return {start, size_t(it - start)};
+               }
+            }
+
+            while (it < e) {
+               if (*it == '"') {
+                  return {start, size_t(it - start)};
+               }
+               ++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;
+            }
+         }
+         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 != 0) [[likely]] {
+         if (test_chunk) [[likely]] {
             it += (std::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;
+         }
 
-            sv ret{start, static_cast<size_t>(it - start)};
-            ++it;
-            return ret;
+         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 != 0) {
+         if (test_chunk) {
             it += (std::countr_zero(test_chunk) >> 3);
-
-            sv ret{start, static_cast<size_t>(it - start)};
-            ++it;
-            return ret;
          }
          else {
             it += 8;
@@ -287,70 +558,49 @@ namespace glz::detail
             chunk = 0; // must zero out the chunk
             std::memcpy(&chunk, it, rest);
             test_chunk = has_quote(chunk);
-            if (test_chunk != 0) {
+            if (test_chunk) {
                it += (std::countr_zero(test_chunk) >> 3);
-
-               sv ret{start, static_cast<size_t>(it - start)};
-               ++it;
-               return ret;
             }
          }
+         return {start, size_t(it - start)};
       }
       else {
          uint64_t chunk{};
          std::memcpy(&chunk, it, LengthRange + 1);
          const uint64_t test_chunk = has_quote(chunk);
-         if (test_chunk != 0) [[likely]] {
+         if (test_chunk) [[likely]] {
             it += (std::countr_zero(test_chunk) >> 3);
-
-            sv ret{start, static_cast<size_t>(it - start)};
-            ++it;
-            return ret;
          }
+         return {start, size_t(it - start)};
       }
-
-      ctx.error = error_code::unknown_key;
-      return {};
    }
 
    template <opts Opts>
    GLZ_ALWAYS_INLINE void skip_string(is_context auto&& ctx, auto&& it, auto&& end) noexcept
    {
-      if (bool(ctx.error)) [[unlikely]] {
-         return;
+      if constexpr (!Opts.opening_handled) {
+         ++it;
       }
 
-      ++it;
-
       if constexpr (Opts.force_conformance) {
          while (true) {
+            if (*it < 16) [[unlikely]] {
+               ctx.error = error_code::syntax_error;
+               return;
+            }
+
             switch (*it) {
-            case '"':
+            case '"': {
                ++it;
                return;
-            case '\b':
-            case '\f':
-            case '\n':
-            case '\r':
-            case '\t': {
-               ctx.error = error_code::syntax_error;
-               return;
             }
             case '\\': {
                ++it;
-               switch (*it) {
-               case '"':
-               case '\\':
-               case '/':
-               case 'b':
-               case 'f':
-               case 'n':
-               case 'r':
-               case 't': {
+               if (char_unescape_table[*it]) {
                   ++it;
                   continue;
                }
-               case 'u': {
+               else if (*it == 'u') {
                   ++it;
                   if ((end - it) < 4) [[unlikely]] {
                      ctx.error = error_code::syntax_error;
@@ -358,33 +608,67 @@ namespace glz::detail
                   }
                   else if (std::all_of(it, it + 4, ::isxdigit)) [[likely]] {
                      it += 4;
-                  }
-                  else [[unlikely]] {
-                     ctx.error = error_code::syntax_error;
-                     return;
-                  }
-                  continue;
-               }
-                  [[unlikely]] default:
-                  {
-                     ctx.error = error_code::syntax_error;
-                     return;
+                     continue;
                   }
                }
+               ctx.error = error_code::syntax_error;
+               return;
             }
-               [[likely]] default : ++it;
             }
+            ++it;
          }
       }
       else {
+         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 += (std::countr_zero(test_chars) >> 3);
+
+               auto* prev = it - 1;
+               while (*prev == '\\') {
+                  --prev;
+               }
+               if (size_t(it - prev) % 2) {
+                  ++it; // skip the quote
+                  return;
+               }
+               ++it; // skip the escaped quote
+            }
+            else {
+               it += 8;
+            }
+         }
+
+         // Tail end of buffer. Should be rare we even get here
          while (it < end) {
-            if (*it == '"') {
+            switch (*it) {
+            case '\\': {
+               ++it;
+               if (it == end) [[unlikely]] {
+                  ctx.error = error_code::expected_quote;
+                  return;
+               }
                ++it;
                break;
             }
-            else if (*it == '\\' && ++it == end) [[unlikely]]
+            case '"': {
+               auto* prev = it - 1;
+               while (*prev == '\\') {
+                  --prev;
+               }
+               if (size_t(it - prev) % 2) {
+                  ++it; // skip the quote
+                  return;
+               }
+               ++it; // skip the escaped quote
                break;
-            ++it;
+            }
+            default: {
+               ++it;
+            }
+            }
          }
       }
    }
@@ -392,10 +676,6 @@ namespace glz::detail
    template <char open, char close>
    GLZ_ALWAYS_INLINE void skip_until_closed(is_context auto&& ctx, auto&& it, auto&& end) noexcept
    {
-      if (bool(ctx.error)) [[unlikely]] {
-         return;
-      }
-
       ++it;
       size_t open_count = 1;
       size_t close_count = 0;
@@ -514,10 +794,6 @@ namespace glz::detail
    template <opts Opts>
    GLZ_ALWAYS_INLINE void skip_number(is_context auto&& ctx, auto&& it, auto&& end) noexcept
    {
-      if (bool(ctx.error)) [[unlikely]] {
-         return;
-      }
-
       if constexpr (!Opts.force_conformance) {
          it = std::find_if_not(it + 1, end, is_numeric<char>);
       }
@@ -536,7 +812,7 @@ namespace glz::detail
       if (bool(ctx.error)) [[unlikely]]
          return {};
 
-      match<'"'>(ctx, it, end);
+      match<'"'>(ctx, it);
       if (bool(ctx.error)) [[unlikely]]
          return {};
       auto start = it;
@@ -545,4 +821,134 @@ namespace glz::detail
          return {};
       return sv{start, static_cast<size_t>(it++ - start)};
    }
+
+   /* Copyright (c) 2022 Tero 'stedo' Liukko, MIT License */
+   GLZ_ALWAYS_INLINE unsigned char hex2dec(char hex) { return ((hex & 0xf) + (hex >> 6) * 9); }
+
+   GLZ_ALWAYS_INLINE char32_t hex4_to_char32(const char* hex)
+   {
+      uint32_t value = hex2dec(hex[3]);
+      value |= hex2dec(hex[2]) << 4;
+      value |= hex2dec(hex[1]) << 8;
+      value |= hex2dec(hex[0]) << 12;
+      return value;
+   }
+
+   GLZ_ALWAYS_INLINE bool handle_escaped_unicode(auto*& in, auto*& out)
+   {
+      in += 2;
+      // This is slow but who is escaping unicode nowadays
+      // codecvt is problematic on mingw hence mixing with the c character conversion functions
+      if (!std::all_of(in, in + 4, ::isxdigit)) [[unlikely]] {
+         return false;
+      }
+
+      char32_t codepoint = hex4_to_char32(in);
+
+      in += 4;
+
+      char8_t buffer[4];
+      auto& facet = std::use_facet<std::codecvt<char32_t, char8_t, mbstate_t>>(std::locale());
+      std::mbstate_t mbstate{};
+      const char32_t* from_next;
+      char8_t* to_next;
+      const auto result = facet.out(mbstate, &codepoint, &codepoint + 1, from_next, buffer, buffer + 4, to_next);
+      if (result != std::codecvt_base::ok) {
+         return false;
+      }
+
+      const auto offset = size_t(to_next - buffer);
+      std::memcpy(out, buffer, offset);
+      out += offset;
+      return true;
+   }
+
+   // errors return the 'in' pointer for better error reporting
+   template <size_t Bytes>
+      requires(Bytes == 8)
+   GLZ_ALWAYS_INLINE const char* parse_string(const auto* in, auto* out, context& ctx) noexcept
+   {
+      uint64_t swar;
+      while (true) {
+         std::memcpy(&swar, in, Bytes);
+         std::memcpy(out, in, Bytes);
+         auto next = has_quote(swar) | has_escape(swar);
+
+         if (next) {
+            next = std::countr_zero(next) >> 3;
+            auto escape_char = in[next];
+            if (escape_char == '"') {
+               return out + next;
+            }
+            else if (escape_char == '\\') {
+               escape_char = in[next + 1];
+               if (escape_char == 'u') [[unlikely]] {
+                  in += next;
+                  out += next;
+                  if (!handle_escaped_unicode(in, out)) {
+                     ctx.error = error_code::unicode_escape_conversion_failure;
+                     return in;
+                  }
+                  continue;
+               }
+               escape_char = char_unescape_table[escape_char];
+               if (escape_char == 0) [[unlikely]] {
+                  ctx.error = error_code::invalid_escape;
+                  return in;
+               }
+               out[next] = escape_char;
+               out += next + 1;
+               in += next + 2;
+            }
+         }
+         else {
+            out += 8;
+            in += 8;
+         }
+      }
+   }
+
+   // errors return the 'in' pointer for better error reporting
+   template <size_t Bytes>
+      requires(Bytes == 1)
+   GLZ_ALWAYS_INLINE const char* parse_string(const auto* in, auto* out, context& ctx) noexcept
+   {
+      while (true) {
+         *out = *in;
+         if (*in == '"' || *in == '\\') {
+            auto escape_char = *in;
+            if (escape_char == '"') {
+               return out;
+            }
+            else if (escape_char == '\\') {
+               escape_char = in[1];
+               if (escape_char == 'u') {
+                  if (!handle_escaped_unicode(in, out)) {
+                     ctx.error = error_code::unicode_escape_conversion_failure;
+                     return in;
+                  }
+                  continue;
+               }
+               escape_char = char_unescape_table[escape_char];
+               if (escape_char == 0) {
+                  ctx.error = error_code::invalid_escape;
+                  return in;
+               }
+               out[0] = escape_char;
+               out += 1;
+               in += 2;
+            }
+         }
+         else {
+            ++out;
+            ++in;
+         }
+      }
+   }
+
+   template <size_t multiple>
+   GLZ_ALWAYS_INLINE constexpr auto round_up_to_multiple(const std::integral auto val) noexcept
+   {
+      return val + (multiple - (val % multiple)) % multiple;
+   }
 }
diff --git a/src/core/include/glaze/util/poly.hpp b/src/core/include/glaze/util/poly.hpp
index 171aa990..55fcd219 100644
--- a/src/core/include/glaze/util/poly.hpp
+++ b/src/core/include/glaze/util/poly.hpp
@@ -13,7 +13,7 @@ namespace glz
    {
       return map_tuple(
          [](auto& v) {
-            using mem_fn_t = std::decay_t<decltype(tuplet::get<1>(v))>;
+            using mem_fn_t = std::decay_t<decltype(get<1>(v))>;
             return typename function_signature<mem_fn_t>::type{};
          },
          meta_v<Spec>);
@@ -26,9 +26,8 @@ namespace glz
    inline constexpr auto make_mem_fn_wrapper_map_impl(std::index_sequence<I...>)
    {
       constexpr auto N = std::tuple_size_v<meta_t<Spec>>;
-      return detail::normal_map<sv, fn_variant<Spec>, N>(
-         {std::make_pair<sv, fn_variant<Spec>>(sv(tuplet::get<0>(tuplet::get<I>(meta_v<Spec>))),
-                                               get_argument<tuplet::get<1>(tuplet::get<I>(meta_v<Spec>))>())...});
+      return detail::normal_map<sv, fn_variant<Spec>, N>({std::make_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>
@@ -57,13 +56,13 @@ namespace glz
          for_each<N>([&](auto I) {
             static constexpr auto spec = meta_v<Spec>;
 
-            static constexpr sv key = tuplet::get<0>(tuplet::get<I>(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(tuplet::get<1>(tuplet::get<I>(spec)))>;
+               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>) {
diff --git a/src/core/include/glaze/util/stoui64.hpp b/src/core/include/glaze/util/stoui64.hpp
index e67a83c0..c7309a67 100644
--- a/src/core/include/glaze/util/stoui64.hpp
+++ b/src/core/include/glaze/util/stoui64.hpp
@@ -6,6 +6,7 @@
 #include <iterator>
 
 #include "glaze/util/inline.hpp"
+#include "glaze/util/strod.hpp"
 
 namespace glz::detail
 {
@@ -13,12 +14,12 @@ 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;
+      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;
+      constexpr auto b = (std::numeric_limits<uint64_t>::max)() / 10;
       return a <= b;
    }
 
@@ -131,4 +132,235 @@ namespace glz::detail
 
       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(T& val, const CharType*& cur) noexcept
+   {
+      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<T>(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<T>(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) {
+         val *= T(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 = T(0);
+         return true;
+      }
+
+      val = static_cast<T>(sig);
+      if (exp >= 0) {
+         val *= T(powers_of_ten_int[exp]);
+      }
+      else {
+         val /= T(powers_of_ten_int[-exp]);
+      }
+      return true;
+   }
 }
diff --git a/src/core/include/glaze/util/string_literal.hpp b/src/core/include/glaze/util/string_literal.hpp
index 8a4674a6..889297cd 100644
--- a/src/core/include/glaze/util/string_literal.hpp
+++ b/src/core/include/glaze/util/string_literal.hpp
@@ -10,16 +10,23 @@ namespace glz
    template <size_t N>
    struct string_literal
    {
-      static constexpr size_t size = (N > 0) ? (N - 1) : 0;
+      static constexpr size_t length = (N > 0) ? (N - 1) : 0;
 
-      constexpr string_literal() = default;
+      constexpr size_t size() const noexcept { return length; }
 
-      constexpr string_literal(const char (&str)[N]) { std::copy_n(str, N, value); }
+      constexpr string_literal() noexcept = default;
+
+      constexpr string_literal(const char (&str)[N]) noexcept { std::copy_n(str, N, value); }
 
       char value[N];
-      constexpr const char* end() const noexcept { return value + size; }
+      constexpr const char* begin() const noexcept { return value; }
+      constexpr const char* end() const noexcept { return value + length; }
+
+      [[nodiscard]] constexpr auto operator<=>(const string_literal&) const = default;
+
+      constexpr const std::string_view sv() const noexcept { return {value, length}; }
 
-      constexpr const std::string_view sv() const noexcept { return {value, size}; }
+      constexpr operator std::string_view() const noexcept { return {value, length}; }
    };
 
    template <size_t N>
@@ -46,12 +53,17 @@ namespace glz
    template <string_literal Str>
    inline constexpr std::string_view chars = chars_impl<Str>::value;
 
-   template <const std::string_view& Str>
-   struct stringer_impl
+   template <size_t N>
+   struct fixed_string final
    {
-      static constexpr std::string_view value = Str;
+      constexpr explicit(true) fixed_string(const auto... cs) : data{cs...} {}
+      constexpr explicit(false) fixed_string(const char (&str)[N + 1]) { std::copy_n(str, N + 1, data.data()); }
+      [[nodiscard]] constexpr auto operator<=>(const fixed_string&) const = default;
+      [[nodiscard]] constexpr explicit(false) operator std::string_view() const { return {data.data(), N}; }
+      [[nodiscard]] constexpr auto size() const -> std::size_t { return N; }
+      std::array<char, N + 1> data{};
    };
 
-   template <const std::string_view& Str>
-   inline constexpr std::string_view stringer = stringer_impl<Str>::value;
+   template <size_t N>
+   fixed_string(const char (&str)[N]) -> fixed_string<N - 1>;
 }
diff --git a/src/core/include/glaze/util/string_view.hpp b/src/core/include/glaze/util/string_view.hpp
index 0f0ee01c..6c6abc62 100644
--- a/src/core/include/glaze/util/string_view.hpp
+++ b/src/core/include/glaze/util/string_view.hpp
@@ -11,4 +11,14 @@ namespace glz
 
    template <class T>
    concept sv_convertible = std::convertible_to<std::decay_t<T>, std::string_view>;
+
+   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/src/core/include/glaze/util/strod.hpp b/src/core/include/glaze/util/strod.hpp
index 5d58dffc..3151f9a9 100644
--- a/src/core/include/glaze/util/strod.hpp
+++ b/src/core/include/glaze/util/strod.hpp
@@ -65,7 +65,7 @@ namespace glz::detail
 #elif defined(_M_X64) || defined(_M_ARM64)
 #define mulhi64 __umulh
 #else
-   uint64_t mulhi64(uint64_t a, uint64_t b) noexcept
+   inline uint64_t mulhi64(uint64_t a, uint64_t b) noexcept
    {
       uint64_t a_lo = (uint32_t)a;
       uint64_t a_hi = a >> 32;
@@ -397,7 +397,8 @@ namespace glz::detail
    };
 
    template <std::floating_point T, bool force_conformance = false>
-   inline bool parse_float(T& val, auto*& cur) noexcept
+      requires(sizeof(T) <= 8)
+   inline bool parse_float(T& val, const uint8_t*& cur) noexcept
    {
       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 */
@@ -743,4 +744,17 @@ namespace glz::detail
       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(T& 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/src/core/include/glaze/util/tuple.hpp b/src/core/include/glaze/util/tuple.hpp
index a5d21915..561a36d2 100644
--- a/src/core/include/glaze/util/tuple.hpp
+++ b/src/core/include/glaze/util/tuple.hpp
@@ -5,6 +5,7 @@
 
 #include <tuple>
 
+#include "glaze/reflection/get_name.hpp"
 #include "glaze/tuplet/tuple.hpp"
 #include "glaze/util/for_each.hpp"
 #include "glaze/util/string_view.hpp"
@@ -49,23 +50,48 @@ namespace glz
 
    template <class Type>
    concept is_schema_class = requires {
-                                requires std::is_class_v<Type>;
-                                requires Type::schema_attributes;
-                             };
+      requires std::is_class_v<Type>;
+      requires Type::schema_attributes;
+   };
 
    template <class Tuple>
    constexpr auto filter()
    {
       constexpr auto n = std::tuple_size_v<Tuple>;
-      std::array<size_t, n> indices{};
+      std::array<uint64_t, n> indices{};
       size_t i = 0;
       for_each<n>([&](auto I) {
          using V = std::decay_t<std::tuple_element_t<I, Tuple>>;
-         if constexpr (!(std::convertible_to<V, std::string_view> || is_schema_class<V>)) {
+         if constexpr (std::is_member_object_pointer_v<V>) {
+            if constexpr (I == 0) {
+               indices[i++] = 0;
+            }
+            else if constexpr (std::convertible_to<std::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<std::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);
+      return std::make_pair(indices, i); // indices for groups and the number of groups
    }
 
    namespace detail
@@ -73,7 +99,7 @@ namespace glz
       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(tuplet::get<Is>(tuple))...);
+         return tuplet::make_tuple(f(get<Is>(tuple))...);
       }
    }
 
@@ -84,26 +110,6 @@ namespace glz
       return detail::map_tuple(f, tuple, std::make_index_sequence<N>{});
    }
 
-   template <class M>
-   inline constexpr void check_member()
-   {
-      constexpr auto N = std::tuple_size_v<M>;
-
-      static_assert(N == 0 || N > 1, "members need at least a name and a member pointer");
-      static_assert(N < 4, "only member_ptr (or enum, or lambda), name, and comment are supported at the momment");
-
-      if constexpr (N > 0)
-         static_assert(sv_convertible<std::tuple_element_t<0, M>>, "first element should be the name");
-      /*if constexpr (N > 1) {
-       TODO: maybe someday add better error messaging that handles lambdas
-         using E = std::tuple_element_t<1, M>;
-         static_assert(std::is_member_pointer_v<E> || std::is_enum_v<E>>,
-                       "second element should be the member pointer");
-      }*/
-      if constexpr (N > 2)
-         static_assert(sv_convertible<std::tuple_element_t<2, M>>, "third element should be a string comment");
-   }
-
    template <size_t n_groups>
    constexpr auto group_sizes(const std::array<size_t, n_groups>& indices, size_t n_total)
    {
@@ -119,19 +125,20 @@ namespace glz
    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 I = decltype(i)::value;
-         using type = decltype(glz::tuplet::get<Start + I>(t));
-         if constexpr (I == 0 || std::convertible_to<type, std::string_view>) {
-            return std::string_view(glz::tuplet::get<Start + I>(t));
+      auto get_elem = [&](auto I) {
+         using type = decltype(glz::get<Start + I>(t));
+         using T = std::decay_t<type>;
+         if constexpr (std::convertible_to<type, std::string_view>) {
+            return std::string_view(glz::get<Start + I>(t));
+         }
+         else if constexpr (std::same_as<T, comment>) {
+            return glz::get<Start + I>(t).value;
          }
          else {
-            return glz::tuplet::get<Start + I>(t);
+            return glz::get<Start + I>(t);
          }
       };
-      auto r = glz::tuplet::make_copy_tuple(get_elem(std::integral_constant<size_t, Is>{})...);
-      // check_member<decltype(r)>();
-      return r;
+      return glz::tuplet::make_copy_tuple(get_elem(std::integral_constant<size_t, Is>{})...);
    }
 
    template <auto& GroupStartArr, auto& GroupSizeArr, class Tuple, size_t... GroupNumber>
@@ -157,8 +164,8 @@ namespace glz
    struct group_builder
    {
       static constexpr auto h = make_groups_helper<Tuple>();
-      static constexpr auto starts = glz::tuplet::get<0>(h);
-      static constexpr auto sizes = glz::tuplet::get<1>(h);
+      static constexpr auto starts = glz::get<0>(h);
+      static constexpr auto sizes = glz::get<1>(h);
 
       static constexpr auto op(Tuple&& t)
       {
diff --git a/src/core/include/glaze/util/type_traits.hpp b/src/core/include/glaze/util/type_traits.hpp
index b35aceae..db8ce9da 100644
--- a/src/core/include/glaze/util/type_traits.hpp
+++ b/src/core/include/glaze/util/type_traits.hpp
@@ -67,6 +67,12 @@ namespace glz
       using type = Result (*)(void*, std::decay_t<Args>&&...);
    };
 
+   template <class ClassType, class Result, class... Args>
+   struct function_signature<Result (ClassType::*)(Args...) const>
+   {
+      using type = Result (*)(void*, std::decay_t<Args>&&...);
+   };
+
    template <class T>
    struct std_function_signature;
 
@@ -76,6 +82,12 @@ namespace glz
       using type = std::function<Result(Args...)>;
    };
 
+   template <class ClassType, class Result, class... Args>
+   struct std_function_signature<Result (ClassType::*)(Args...) const>
+   {
+      using type = std::function<Result(Args...)>;
+   };
+
    template <class T>
    struct keep_non_const_ref
    {
@@ -95,6 +107,12 @@ namespace glz
       using type = std::function<Result(keep_non_const_ref_t<Args>...)>;
    };
 
+   template <class ClassType, class Result, class... Args>
+   struct std_function_signature_decayed_keep_non_const_ref<Result (ClassType::*)(Args...) const>
+   {
+      using type = std::function<Result(keep_non_const_ref_t<Args>...)>;
+   };
+
    template <class T>
    struct return_type;
 
@@ -104,6 +122,12 @@ namespace glz
       using type = Result;
    };
 
+   template <class ClassType, class Result, class... Args>
+   struct return_type<Result (ClassType::*)(Args...) const>
+   {
+      using type = Result;
+   };
+
    template <class T>
    struct inputs_as_tuple;
 
@@ -113,6 +137,12 @@ namespace glz
       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 T>
    struct parent_of_fn;
 
@@ -122,6 +152,12 @@ namespace glz
       using type = ClassType;
    };
 
+   template <class ClassType, class Result, class... Args>
+   struct parent_of_fn<Result (ClassType::*)(Args...) const>
+   {
+      using type = ClassType;
+   };
+
    template <auto MemPtr, class T>
    struct arguments;
 
@@ -141,6 +177,16 @@ namespace glz
       }
    };
 
+   template <auto MemPtr, class T, class R, class... Args>
+   struct arguments<MemPtr, R (T::*)(Args...) const>
+   {
+      static constexpr auto op(void* ptr, std::decay_t<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()
    {
@@ -152,4 +198,34 @@ namespace glz
          return typename arguments<MemPtr, Type>::type{};
       }
    }
+
+   template <class>
+   struct lambda_traits : std::false_type
+   {};
+
+   template <class R, class T, class... Args>
+   struct lambda_traits<R (T::*)(Args...) const> : std::true_type
+   {
+      using result_type = R;
+      using arguments = std::tuple<Args...>;
+      using object_type = T;
+   };
+
+   template <class R, class T, class... Args>
+   struct lambda_traits<R (T::*)(Args...)> : std::true_type
+   {
+      using result_type = R;
+      using arguments = std::tuple<Args...>;
+      using object_type = T;
+   };
+
+   template <class T>
+   using lambda_args_t = typename lambda_traits<decltype(&T::operator())>::arguments;
+
+   template <class T>
+   using lambda_result_t = typename lambda_traits<decltype(&T::operator())>::result_type;
+
+   // checks if type is a lambda with all known arguments
+   template <class T>
+   concept is_lambda_concrete = requires { typename lambda_traits<decltype(&T::operator())>::result_type; };
 }
diff --git a/src/core/include/glaze/util/validate.hpp b/src/core/include/glaze/util/validate.hpp
index 4e775b67..54f506c2 100644
--- a/src/core/include/glaze/util/validate.hpp
+++ b/src/core/include/glaze/util/validate.hpp
@@ -75,6 +75,7 @@ namespace glz
                                                const std::string_view filename = "")
       {
          std::string s{};
+         s.reserve(error.size() + info.context.size() + filename.size() + 128);
 
          if (!filename.empty()) {
             s += filename;
@@ -112,5 +113,5 @@ namespace glz
          fmt::format_to(it, FMT_COMPILE("{: <{}}^\n"), "", info.column - 1);*/
          return s;
       }
-   } // namespace detail
-} // namespace test
+   }
+}
diff --git a/src/core/src/signal.cpp b/src/core/src/signal.cpp
index ba61b6e4..1d1ece97 100644
--- a/src/core/src/signal.cpp
+++ b/src/core/src/signal.cpp
@@ -102,7 +102,7 @@ namespace b {
     };
 
 #ifdef B_OS_WINDOWS
-    static int windows_handler(DWORD dwCtrlType) {  // Separate function instead of lambda: We need the function pointer twice
+    static int __stdcall windows_handler(DWORD dwCtrlType) {  // Separate function instead of lambda: We need the function pointer twice
         switch (dwCtrlType) {
             case CTRL_C_EVENT:
             case CTRL_BREAK_EVENT:
diff --git a/src/core/src/thread.cpp b/src/core/src/thread.cpp
index ca5cd1fa..365848d4 100644
--- a/src/core/src/thread.cpp
+++ b/src/core/src/thread.cpp
@@ -7,9 +7,10 @@
 namespace b {
 
     void thread::closeApplicationIfExists() {
-        if (b::Application::instanceExists()) {
-            b::Application::get().close();
-        }
+        b::log::error("thread::closeApplicationIfExists() not implemented");
+        // if (b::Application::instanceExists()) {
+        //     b::Application::get().close();
+        // }
     }
 
 } // namespace b
diff --git a/src/core/src/window.cpp b/src/core/src/window.cpp
index 8c699826..7eef35bc 100644
--- a/src/core/src/window.cpp
+++ b/src/core/src/window.cpp
@@ -238,15 +238,15 @@ namespace b {
     }
 
 #ifdef B_OS_WINDOWS
-    static BOOL GetWin32MonitorsImpl(HMONITOR hMonitor, HDC hdcMonitor, LPRECT lprcMonitor, LPARAM dwData) {
-        auto *monitors = reinterpret_cast<std::vector<HMONITOR>*>(dwData);
+    static BOOL __stdcall GetWin32MonitorsImpl(HMONITOR hMonitor, HDC hdcMonitor, LPRECT lprcMonitor, LPARAM dwData) {
+        auto *monitors = std::bit_cast<std::vector<HMONITOR>*>(dwData);
         monitors->push_back(hMonitor);
         return TRUE;
     }
 
     static std::vector<HMONITOR> GetAllWin32Monitors() {
         std::vector<HMONITOR> monitors;
-        if (EnumDisplayMonitors(nullptr, nullptr, GetWin32MonitorsImpl, reinterpret_cast<LPARAM>(&monitors)) == 0) {
+        if (EnumDisplayMonitors(NULL, NULL, (MONITORENUMPROC)GetWin32MonitorsImpl, std::bit_cast<LPARAM>(&monitors)) == 0) {
             return {};
         }
         return monitors;