LLVMFuzzerTestOneInput:
  143|  20.3k|{
  144|  20.3k|   const std::string_view input{reinterpret_cast<const char*>(Data), Size};
  145|       |
  146|       |   // Raw bytes: the batch split, the syntax check, and the envelope read.
  147|  20.3k|   {
  148|  20.3k|      const auto buf = exact_buffer(input);
  149|  20.3k|      drive({buf.data(), buf.size()});
  150|  20.3k|   }
  151|       |
  152|  20.3k|   if (Size < 1) {
  ------------------
  |  Branch (152:8): [True: 0, False: 20.3k]
  ------------------
  153|      0|      return 0;
  154|      0|   }
  155|       |
  156|       |   // Wrapped: the input becomes the params of an envelope that is otherwise well formed, so the
  157|       |   // params reader is reached even when the fuzzer has not yet learned the envelope's shape. The
  158|       |   // first byte picks the method, since which one is registered decides what the params must parse
  159|       |   // as, and a params reader is only interesting once it has a destination type.
  160|       |   // "" is the root method, which reads the whole registered object in one document -- every nested
  161|       |   // struct, container, optional and variant at once, and the deepest reader nesting on offer.
  162|  20.3k|   static constexpr std::string_view methods[] = {
  163|  20.3k|      "",        "value", "name",     "position", "position/x", "inner",   "series", "table", "maybe", "measure",
  164|  20.3k|      "doubled", "greet", "midpoint", "total",    "reset",      "counter", "scale",  "bump",  "shift", "absent"};
  165|  20.3k|   const std::string_view method = methods[Data[0] % (sizeof(methods) / sizeof(methods[0]))];
  166|  20.3k|   const std::string_view params = input.substr(1);
  167|       |
  168|  20.3k|   {
  169|  20.3k|      std::string request;
  170|  20.3k|      request += R"({"jsonrpc":"2.0","method":")";
  171|  20.3k|      request += method;
  172|  20.3k|      request += R"(","params":)";
  173|  20.3k|      request += params;
  174|  20.3k|      request += R"(,"id":1})";
  175|       |
  176|  20.3k|      const auto buf = exact_buffer(request);
  177|  20.3k|      drive({buf.data(), buf.size()});
  178|  20.3k|   }
  179|       |
  180|       |   // The same envelope inside a batch, which takes a different path: the array is split into raw
  181|       |   // views first and each element is read on its own.
  182|  20.3k|   {
  183|  20.3k|      std::string request;
  184|  20.3k|      request += R"([{"jsonrpc":"2.0","method":")";
  185|  20.3k|      request += method;
  186|  20.3k|      request += R"(","params":)";
  187|  20.3k|      request += params;
  188|  20.3k|      request += R"(,"id":1},{"jsonrpc":"2.0","method":")";
  189|  20.3k|      request += method;
  190|  20.3k|      request += R"("}])"; // second element is a notification, so it takes the no-response path
  191|       |
  192|  20.3k|      const auto buf = exact_buffer(request);
  193|  20.3k|      drive({buf.data(), buf.size()});
  194|  20.3k|   }
  195|       |
  196|  20.3k|   return 0;
  197|  20.3k|}
jsonrpc_registry.cpp:_ZN12_GLOBAL__N_112exact_bufferENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEE:
  111|   119k|   {
  112|   119k|      std::vector<char> buf(bytes.size());
  113|   119k|      if (!bytes.empty()) {
  ------------------
  |  Branch (113:11): [True: 119k, False: 0]
  ------------------
  114|   119k|         std::memcpy(buf.data(), bytes.data(), bytes.size());
  115|   119k|      }
  116|   119k|      return buf;
  117|   119k|   }
jsonrpc_registry.cpp:_ZN12_GLOBAL__N_15driveENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEE:
  120|  61.1k|   {
  121|  61.1k|      glz::registry<glz::opts{}, glz::JSONRPC> registry;
  122|  61.1k|      fuzz_api api{};
  123|  61.1k|      jsonrpc_fuzz::member_api members{};
  124|       |      // members first, so the last registration -- and therefore the root endpoint -- is the wider
  125|       |      // of the two objects. Root reads the whole object in one document, so it should be the one
  126|       |      // with the nested struct, containers, optional and variant in it.
  127|  61.1k|      registry.on(members);
  128|  61.1k|      registry.on(api);
  129|       |
  130|  61.1k|      const auto response = registry.call(request);
  131|  61.1k|      if (!response.empty()) {
  ------------------
  |  Branch (131:11): [True: 58.0k, False: 3.08k]
  ------------------
  132|       |         // The response is JSON the registry itself produced, so reading it back checks that what
  133|       |         // goes out is well formed even when what came in was not.
  134|  58.0k|         const auto buf = exact_buffer(response);
  135|  58.0k|         glz::generic parsed{};
  136|  58.0k|         [[maybe_unused]] auto ec =
  137|  58.0k|            glz::read<glz::opts{.null_terminated = false}>(parsed, std::string_view{buf.data(), buf.size()});
  138|  58.0k|      }
  139|  61.1k|   }
_ZNK12jsonrpc_fuzz8fuzz_api7doubledMUliE_clEi:
   66|    897|      std::function<int32_t(int32_t)> doubled = [](int32_t v) { return int32_t(uint32_t(v) * 2u); };
_ZNK12jsonrpc_fuzz8fuzz_api5greetMUlRKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEE_clESA_:
   67|  2.40k|      std::function<std::string(const std::string&)> greet = [](const std::string& who) { return "hi " + who; };
_ZNK12jsonrpc_fuzz8fuzz_api8midpointMUlRKNS_5pointEE_clES4_:
   68|    706|      std::function<point(const point&)> midpoint = [](const point& p) -> point { return {p.x / 2, p.y / 2}; };
_ZNK12jsonrpc_fuzz8fuzz_api5totalMUlRNSt3__16vectorIdNS2_9allocatorIdEEEEE_clES7_:
   69|  4.12k|      std::function<double(std::vector<double>&)> total = [](std::vector<double>& v) {
   70|  4.12k|         double sum{};
   71|   168k|         for (auto d : v) sum += d;
  ------------------
  |  Branch (71:22): [True: 168k, False: 4.12k]
  ------------------
   72|  4.12k|         return sum;
   73|  4.12k|      };
_ZNK12jsonrpc_fuzz8fuzz_api5resetMUlvE_clEv:
   74|    517|      std::function<void()> reset = [] {};
_ZN12jsonrpc_fuzz10member_api5scaleEi:
   89|    688|      {
   90|    688|         counter = int32_t(uint32_t(counter) + uint32_t(v));
   91|    688|         return int32_t(uint32_t(v) * 3u);
   92|    688|      }
_ZN12jsonrpc_fuzz10member_api4bumpEv:
   93|    312|      void bump() { counter = int32_t(uint32_t(counter) + 1u); }
_ZN12jsonrpc_fuzz10member_api5shiftERKNS_5pointE:
   94|    581|      point shift(const point& p) { return {p.x + 1, p.y + 1}; }

_ZN3glz11empty_rangeITkNS_5rangeERNSt3__16vectorIiNS1_9allocatorIiEEEEEEbOT_:
  284|    190|   {
  285|    190|#ifdef __cpp_lib_ranges
  286|    190|      return std::ranges::empty(rng);
  287|       |#else
  288|       |      // in lieu of std::ranges::empty
  289|       |      if constexpr (requires() {
  290|       |                       { rng.empty() } -> std::convertible_to<bool>;
  291|       |                    }) {
  292|       |         return rng.empty();
  293|       |      }
  294|       |      else if constexpr (requires() {
  295|       |                            { rng.size() } -> std::same_as<std::size_t>;
  296|       |                         }) {
  297|       |         return rng.size() == std::size_t{0};
  298|       |      }
  299|       |      else {
  300|       |         return std::cbegin(rng) == std::cend(rng);
  301|       |      }
  302|       |#endif
  303|    190|   }
_ZN3glz11empty_rangeITkNS_5rangeERNSt3__13mapINS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEiNS1_4lessIS8_EENS6_INS1_4pairIKS8_iEEEEEEEEbOT_:
  284|     75|   {
  285|     75|#ifdef __cpp_lib_ranges
  286|     75|      return std::ranges::empty(rng);
  287|       |#else
  288|       |      // in lieu of std::ranges::empty
  289|       |      if constexpr (requires() {
  290|       |                       { rng.empty() } -> std::convertible_to<bool>;
  291|       |                    }) {
  292|       |         return rng.empty();
  293|       |      }
  294|       |      else if constexpr (requires() {
  295|       |                            { rng.size() } -> std::same_as<std::size_t>;
  296|       |                         }) {
  297|       |         return rng.size() == std::size_t{0};
  298|       |      }
  299|       |      else {
  300|       |         return std::cbegin(rng) == std::cend(rng);
  301|       |      }
  302|       |#endif
  303|     75|   }

_ZN3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEEC2Ev:
  566|   507k|      ordered_small_map() = default;
_ZN3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEE9free_dataEv:
  266|  1.34M|      {
  267|  1.34M|         destroy_all();
  268|  1.34M|         ::operator delete(data_);
  269|  1.34M|         data_ = nullptr;
  270|  1.34M|         size_ = 0;
  271|  1.34M|         capacity_ = 0;
  272|  1.34M|      }
_ZN3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEE11destroy_allEv:
  259|  1.85M|      {
  260|  3.35M|         for (uint32_t i = 0; i < size_; ++i) {
  ------------------
  |  Branch (260:31): [True: 1.50M, False: 1.85M]
  ------------------
  261|  1.50M|            std::destroy_at(data_ + i);
  262|  1.50M|         }
  263|  1.85M|      }
_ZN3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEE10free_indexEv:
  308|  1.34M|      {
  309|  1.34M|         std::free(index_);
  310|  1.34M|         index_ = nullptr;
  311|  1.34M|      }
_ZN3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEEC2EOS4_:
  610|   836k|         : data_(other.data_), size_(other.size_), capacity_(other.capacity_), index_(other.index_)
  611|   836k|      {
  612|   836k|         other.data_ = nullptr;
  613|   836k|         other.size_ = 0;
  614|   836k|         other.capacity_ = 0;
  615|   836k|         other.index_ = nullptr;
  616|   836k|      }
_ZN3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEED2Ev:
  569|  1.34M|      {
  570|  1.34M|         free_data();
  571|  1.34M|         free_index();
  572|  1.34M|      }
_ZN3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEEixERKNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEE:
  932|  1.50M|      {
  933|  1.50M|         return subscript_or_insert(key, [&] { emplace_back_impl(key, mapped_type{}); });
  934|  1.50M|      }
_ZN3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEE19subscript_or_insertINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEZNS4_ixERKSC_EUlvE_EERS3_RKT_OT0_:
  491|  1.50M|      {
  492|  1.50M|         if (size_ <= linear_search_threshold) {
  ------------------
  |  Branch (492:14): [True: 1.50M, False: 129]
  ------------------
  493|  1.50M|            auto it = linear_find(key);
  494|  1.50M|            if (it != end()) return it->second;
  ------------------
  |  Branch (494:17): [True: 0, False: 1.50M]
  ------------------
  495|  1.50M|            append_fn();
  496|  1.50M|            return data_[size_ - 1].second;
  497|  1.50M|         }
  498|       |
  499|    129|         const uint32_t h = hash_key(key);
  500|    129|         if (try_bloom_insert(h, append_fn)) {
  ------------------
  |  Branch (500:14): [True: 86, False: 43]
  ------------------
  501|     86|            return data_[size_ - 1].second;
  502|     86|         }
  503|       |
  504|     43|         auto [it, pos, _] = index_find_or_pos(key, h);
  505|     43|         if (it != end()) return it->second;
  ------------------
  |  Branch (505:14): [True: 0, False: 43]
  ------------------
  506|       |
  507|     43|         append_fn();
  508|     43|         bloom_set(h);
  509|     43|         if (index_size() > 0) {
  ------------------
  |  Branch (509:14): [True: 43, False: 0]
  ------------------
  510|     43|            const uint32_t n = index_->size;
  511|     43|            ensure_index_capacity(static_cast<size_type>(n) + 1);
  512|     43|            auto* entries = index_entries();
  513|     43|            if (pos < n) {
  ------------------
  |  Branch (513:17): [True: 0, False: 43]
  ------------------
  514|      0|               std::memmove(entries + pos + 1, entries + pos, (n - pos) * sizeof(hash_index_entry));
  515|      0|            }
  516|     43|            entries[pos] = {h, size_ - 1};
  517|     43|            index_->size = size_;
  518|     43|         }
  519|     43|         return data_[size_ - 1].second;
  520|     43|      }
_ZN3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEE11linear_findINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEEEPNS6_4pairISC_S3_EERKT_:
  421|  1.50M|      {
  422|  2.98M|         for (uint32_t i = 0; i < size_; ++i) {
  ------------------
  |  Branch (422:31): [True: 1.48M, False: 1.50M]
  ------------------
  423|  1.48M|            if (data_[i].first == key) return data_ + i;
  ------------------
  |  Branch (423:17): [True: 0, False: 1.48M]
  ------------------
  424|  1.48M|         }
  425|  1.50M|         return data_ + size_;
  426|  1.50M|      }
_ZN3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEE3endEv:
  649|  1.50M|      iterator end() noexcept { return data_ + size_; }
_ZZN3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEEixERKNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEENKUlvE_clEv:
  933|  1.50M|         return subscript_or_insert(key, [&] { emplace_back_impl(key, mapped_type{}); });
_ZN3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEE17emplace_back_implIJRKNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEES3_EEEvDpOT_:
  243|  1.50M|      {
  244|  1.50M|         grow_if_needed();
  245|  1.50M|         std::construct_at(data_ + size_, std::forward<Args>(args)...);
  246|  1.50M|         ++size_;
  247|  1.50M|      }
_ZN3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEE14grow_if_neededEv:
  217|  1.50M|      {
  218|  1.50M|         if (size_ == capacity_) {
  ------------------
  |  Branch (218:14): [True: 507k, False: 993k]
  ------------------
  219|   507k|            if (size_ == max_u32) {
  ------------------
  |  Branch (219:17): [True: 0, False: 507k]
  ------------------
  220|      0|               throw_capacity_overflow();
  221|      0|            }
  222|   507k|            const uint32_t new_cap = next_data_capacity(capacity_);
  223|   507k|            reallocate_data(new_cap);
  224|   507k|         }
  225|  1.50M|      }
_ZN3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEE18next_data_capacityEj:
  120|   507k|      {
  121|   507k|         if (current == 0) return 4;
  ------------------
  |  Branch (121:14): [True: 507k, False: 86]
  ------------------
  122|     86|         if (current > (max_u32 / 2)) return max_u32;
  ------------------
  |  Branch (122:14): [True: 0, False: 86]
  ------------------
  123|     86|         return current * 2;
  124|     86|      }
_ZN3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEE15reallocate_dataEj:
  205|   507k|      {
  206|   507k|         if (new_cap < size_) {
  ------------------
  |  Branch (206:14): [True: 0, False: 507k]
  ------------------
  207|      0|            throw_capacity_overflow();
  208|      0|         }
  209|   507k|         auto* new_data = allocate_and_relocate(new_cap);
  210|   507k|         destroy_all();
  211|   507k|         ::operator delete(data_);
  212|   507k|         data_ = new_data;
  213|   507k|         capacity_ = new_cap;
  214|   507k|      }
_ZN3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEE21allocate_and_relocateEj:
  159|   507k|      {
  160|   507k|         auto* new_data = static_cast<value_type*>(::operator new(checked_data_allocation_bytes(new_cap)));
  161|   507k|#if __cpp_exceptions
  162|   507k|         uint32_t constructed = 0;
  163|   507k|         try {
  164|   508k|            for (; constructed < size_; ++constructed) {
  ------------------
  |  Branch (164:20): [True: 516, False: 507k]
  ------------------
  165|    516|               std::construct_at(new_data + constructed, std::move_if_noexcept(data_[constructed]));
  166|    516|            }
  167|   507k|         }
  168|   507k|         catch (...) {
  169|      0|            destroy_range(new_data, constructed);
  170|      0|            ::operator delete(new_data);
  171|      0|            throw;
  172|      0|         }
  173|       |#else
  174|       |         for (uint32_t i = 0; i < size_; ++i) {
  175|       |            std::construct_at(new_data + i, std::move_if_noexcept(data_[i]));
  176|       |         }
  177|       |#endif
  178|   507k|         return new_data;
  179|   507k|      }
_ZN3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEE29checked_data_allocation_bytesEj:
  134|   507k|      {
  135|   507k|         if (count > ((std::numeric_limits<size_t>::max)() / sizeof(value_type))) {
  ------------------
  |  Branch (135:14): [True: 0, False: 507k]
  ------------------
  136|      0|            GLZ_THROW_OR_ABORT(std::bad_alloc{});
  ------------------
  |  |    8|      0|#define GLZ_THROW_OR_ABORT(EXC) (throw(EXC))
  ------------------
  137|      0|         }
  138|   507k|         return static_cast<size_t>(count) * sizeof(value_type);
  139|   507k|      }
_ZN3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEE8hash_keyENSt3__117basic_string_viewIcNS5_11char_traitsIcEEEE:
   97|    516|      static uint32_t hash_key(std::string_view key) noexcept { return sweethash::sweet32(key); }
_ZN3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEE16try_bloom_insertIRZNS4_ixERKNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEEUlvE_EEbjOT_:
  529|    129|      {
  530|    129|         if (index_ && size_ <= bloom_threshold && !bloom_maybe_contains(h)) {
  ------------------
  |  Branch (530:14): [True: 86, False: 43]
  |  Branch (530:24): [True: 86, False: 0]
  |  Branch (530:52): [True: 86, False: 0]
  ------------------
  531|       |            // Definitely not present — skip the search
  532|     86|            append_fn();
  533|     86|            bloom_set(h);
  534|       |            // Index is now stale (index_->size < size_), will rebuild on next lookup or false positive
  535|     86|            return true;
  536|     86|         }
  537|     43|         return false;
  538|    129|      }
_ZNK3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEE20bloom_maybe_containsEj:
  285|     86|      {
  286|     86|         const uint32_t a = h & bloom_mask;
  287|     86|         const uint32_t b = (h >> 10) & bloom_mask;
  288|     86|         return (index_->bloom[a >> 3] & (uint8_t(1) << (a & 7))) && (index_->bloom[b >> 3] & (uint8_t(1) << (b & 7)));
  ------------------
  |  Branch (288:17): [True: 0, False: 86]
  |  Branch (288:70): [True: 0, False: 0]
  ------------------
  289|     86|      }
_ZN3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEE17index_find_or_posINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEEENS4_17index_find_resultERKT_j:
  400|     43|      {
  401|     43|         ensure_index();
  402|       |
  403|     43|         const auto* base = index_entries();
  404|     43|         const auto* idx_end = base + index_->size;
  405|     43|         const auto* p = branchless_lower_bound(base, index_->size, h);
  406|     43|         const size_t pos = static_cast<size_t>(p - base);
  407|       |
  408|       |         // Scan adjacent entries with matching hash
  409|     43|         for (auto* scan = p; scan != idx_end && scan->key_hash == h; ++scan) {
  ------------------
  |  Branch (409:31): [True: 0, False: 43]
  |  Branch (409:50): [True: 0, False: 0]
  ------------------
  410|      0|            if (data_[scan->index].first == key) {
  ------------------
  |  Branch (410:17): [True: 0, False: 0]
  ------------------
  411|      0|               return {data_ + scan->index, pos, h};
  412|      0|            }
  413|      0|         }
  414|       |
  415|     43|         return {data_ + size_, pos, h};
  416|     43|      }
_ZNK3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEE12ensure_indexEv:
  360|     43|      {
  361|     43|         if (size_ <= linear_search_threshold) return;
  ------------------
  |  Branch (361:14): [True: 0, False: 43]
  ------------------
  362|     43|         const auto current = index_size();
  363|     43|         if (current == size_) return; // fully current
  ------------------
  |  Branch (363:14): [True: 0, False: 43]
  ------------------
  364|       |
  365|     43|         if (current == 0 || (size_ - current) > linear_search_threshold) {
  ------------------
  |  Branch (365:14): [True: 43, False: 0]
  |  Branch (365:30): [True: 0, False: 0]
  ------------------
  366|     43|            rebuild_index(); // full rebuild
  367|     43|            return;
  368|     43|         }
  369|       |
  370|       |         // Incrementally insert-sort the few new entries
  371|      0|         for (uint32_t i = current; i < size_; ++i) {
  ------------------
  |  Branch (371:37): [True: 0, False: 0]
  ------------------
  372|      0|            const hash_index_entry entry{hash_key(data_[i].first), i};
  373|      0|            const auto* base = index_entries();
  374|      0|            const auto* p = branchless_lower_bound(base, index_->size, entry.key_hash);
  375|      0|            auto pos = static_cast<size_t>(p - base);
  376|       |
  377|      0|            const uint32_t m = index_->size;
  378|      0|            ensure_index_capacity(static_cast<size_type>(m) + 1);
  379|      0|            auto* entries = index_entries();
  380|      0|            if (pos < m) {
  ------------------
  |  Branch (380:17): [True: 0, False: 0]
  ------------------
  381|      0|               std::memmove(entries + pos + 1, entries + pos, (m - pos) * sizeof(hash_index_entry));
  382|      0|            }
  383|      0|            entries[pos] = entry;
  384|      0|            index_->size = i + 1;
  385|      0|         }
  386|      0|      }
_ZNK3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEE13rebuild_indexEv:
  343|     43|      {
  344|     43|         ensure_index_capacity(static_cast<size_type>(size_));
  345|     43|         bloom_clear();
  346|     43|         auto* entries = index_entries();
  347|    430|         for (uint32_t i = 0; i < size_; ++i) {
  ------------------
  |  Branch (347:31): [True: 387, False: 43]
  ------------------
  348|    387|            const uint32_t h = hash_key(data_[i].first);
  349|    387|            entries[i] = {h, i};
  350|    387|            bloom_set(h);
  351|    387|         }
  352|     43|         std::sort(entries, entries + size_, [](const auto& a, const auto& b) { return a.key_hash < b.key_hash; });
  353|     43|         index_->size = size_;
  354|     43|      }
_ZNK3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEE11bloom_clearEv:
  291|     43|      void bloom_clear() const noexcept { std::memset(index_->bloom, 0, bloom_bytes); }
_ZZNK3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEE13rebuild_indexEvENKUlRKT_RKT0_E_clINS4_16hash_index_entryESD_EEDaS7_SA_:
  352|  1.07k|         std::sort(entries, entries + size_, [](const auto& a, const auto& b) { return a.key_hash < b.key_hash; });
_ZN3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEE22branchless_lower_boundEPKNS4_16hash_index_entryEmj:
  440|     43|      {
  441|    215|         while (len > 1) {
  ------------------
  |  Branch (441:17): [True: 172, False: 43]
  ------------------
  442|    172|            size_t half = len / 2;
  443|    172|            p += (p[half - 1].key_hash < target) * half;
  444|    172|            len -= half;
  445|    172|         }
  446|       |         // Final element check: advance past it if it's less than target
  447|     43|         p += (len == 1 && p->key_hash < target);
  ------------------
  |  Branch (447:16): [True: 43, False: 0]
  |  Branch (447:28): [True: 43, False: 0]
  ------------------
  448|     43|         return p;
  449|     43|      }
_ZNK3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEE9bloom_setEj:
  277|    516|      {
  278|    516|         const uint32_t a = h & bloom_mask;
  279|    516|         const uint32_t b = (h >> 10) & bloom_mask;
  280|    516|         index_->bloom[a >> 3] |= uint8_t(1) << (a & 7);
  281|    516|         index_->bloom[b >> 3] |= uint8_t(1) << (b & 7);
  282|    516|      }
_ZNK3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEE10index_sizeEv:
  300|     86|      uint32_t index_size() const noexcept { return index_ ? index_->size : 0; }
  ------------------
  |  Branch (300:53): [True: 43, False: 43]
  ------------------
_ZNK3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEE21ensure_index_capacityEm:
  314|     86|      {
  315|     86|         if (needed == 0) return;
  ------------------
  |  Branch (315:14): [True: 0, False: 86]
  ------------------
  316|     86|         if (needed > static_cast<size_type>(max_u32)) {
  ------------------
  |  Branch (316:14): [True: 0, False: 86]
  ------------------
  317|      0|            throw_index_overflow();
  318|      0|         }
  319|     86|         const auto needed_u32 = static_cast<uint32_t>(needed);
  320|     86|         if (index_ && index_->capacity >= needed_u32) return;
  ------------------
  |  Branch (320:14): [True: 43, False: 43]
  |  Branch (320:24): [True: 43, False: 0]
  ------------------
  321|     43|         uint32_t cap = index_ ? index_->capacity : 0;
  ------------------
  |  Branch (321:25): [True: 0, False: 43]
  ------------------
  322|     86|         while (cap < needed_u32) {
  ------------------
  |  Branch (322:17): [True: 43, False: 43]
  ------------------
  323|     43|            const uint32_t next = next_index_capacity(cap);
  324|     43|            if (next <= cap) {
  ------------------
  |  Branch (324:17): [True: 0, False: 43]
  ------------------
  325|      0|               throw_index_overflow();
  326|      0|            }
  327|     43|            cap = next;
  328|     43|         }
  329|     43|         auto* block = static_cast<index_header*>(std::realloc(index_, checked_index_allocation_bytes(cap)));
  330|     43|         if (!block) GLZ_THROW_OR_ABORT(std::bad_alloc{});
  ------------------
  |  |    8|      0|#define GLZ_THROW_OR_ABORT(EXC) (throw(EXC))
  ------------------
  |  Branch (330:14): [True: 0, False: 43]
  ------------------
  331|     43|         if (!index_) {
  ------------------
  |  Branch (331:14): [True: 43, False: 0]
  ------------------
  332|     43|            block->size = 0;
  333|     43|            std::memset(block->bloom, 0, bloom_bytes);
  334|     43|         }
  335|     43|         block->capacity = cap;
  336|     43|         index_ = block;
  337|     43|      }
_ZN3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEE19next_index_capacityEj:
  127|     43|      {
  128|     43|         if (current == 0) return 16;
  ------------------
  |  Branch (128:14): [True: 43, False: 0]
  ------------------
  129|      0|         if (current > (max_u32 / 2)) return max_u32;
  ------------------
  |  Branch (129:14): [True: 0, False: 0]
  ------------------
  130|      0|         return current * 2;
  131|      0|      }
_ZN3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEE30checked_index_allocation_bytesEj:
  142|     43|      {
  143|     43|         constexpr size_t header = sizeof(index_header);
  144|     43|         constexpr size_t entry = sizeof(hash_index_entry);
  145|     43|         if (count > (((std::numeric_limits<size_t>::max)() - header) / entry)) {
  ------------------
  |  Branch (145:14): [True: 0, False: 43]
  ------------------
  146|      0|            GLZ_THROW_OR_ABORT(std::bad_alloc{});
  ------------------
  |  |    8|      0|#define GLZ_THROW_OR_ABORT(EXC) (throw(EXC))
  ------------------
  147|      0|         }
  148|     43|         return header + static_cast<size_t>(count) * entry;
  149|     43|      }
_ZNK3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEE13index_entriesEv:
  296|    129|      {
  297|    129|         return static_cast<hash_index_entry*>(static_cast<void*>(index_ + 1));
  298|    129|      }

_ZN3glz12ensure_spaceINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEETkNS_10is_contextENS_7contextEEEbRT0_RT_m:
  181|  4.20M|   {
  182|  4.20M|      using Buffer = std::remove_cvref_t<B>;
  183|       |
  184|  4.20M|      if constexpr (vector_like<Buffer>) {
  185|  4.20M|         if (required > b.size()) [[unlikely]] {
  ------------------
  |  Branch (185:14): [True: 1.34k, False: 4.19M]
  ------------------
  186|       |            // 2× growth amortizes repeated reallocations to O(n) total cost.
  187|  1.34k|            b.resize(2 * required);
  188|  1.34k|         }
  189|  4.20M|         return true;
  190|       |      }
  191|       |      else if constexpr (has_bounded_capacity<Buffer>) {
  192|       |         if (required > buffer_traits<Buffer>::capacity(b)) [[unlikely]] {
  193|       |            ctx.error = error_code::buffer_overflow;
  194|       |            return false;
  195|       |         }
  196|       |         return true;
  197|       |      }
  198|       |      else {
  199|       |         return true; // Raw pointer or other - trust caller
  200|       |      }
  201|  4.20M|   }
_ZN3glz13buffer_traitsINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE8finalizeERS7_m:
   58|  4.19M|      {
   59|  4.19M|         if constexpr (is_resizable) {
   60|  4.19M|            b.resize(written);
   61|  4.19M|         }
   62|       |         // For fixed buffers: no-op, count is returned in result
   63|  4.19M|      }

_ZN3glz10get_memberIRN12jsonrpc_fuzz10member_apiERKMS2_iEEDcOT_OT0_:
  616|  61.1k|   {
  617|  61.1k|      using V = std::decay_t<decltype(element)>;
  618|  61.1k|      if constexpr (std::is_member_object_pointer_v<V>) {
  619|  61.1k|         return value.*element;
  620|       |      }
  621|       |      else if constexpr (std::is_member_function_pointer_v<V>) {
  622|       |         return element;
  623|       |      }
  624|       |      else if constexpr (std::invocable<Element, Value> && not eigen_t<Element>) {
  625|       |         // Eigen places a static_assert inside of the operator()(), so we must target
  626|       |         // matrix types and reject them from the invocable check
  627|       |         // Eigen ought to put the check in the `enable_if` for operator()()
  628|       |         return std::invoke(std::forward<Element>(element), std::forward<Value>(value));
  629|       |      }
  630|       |      else if constexpr (std::is_pointer_v<V> && !std::is_reference_v<Element>) {
  631|       |         if constexpr (std::invocable<decltype(*element), Value>) {
  632|       |            return std::invoke(*element, std::forward<Value>(value));
  633|       |         }
  634|       |         else {
  635|       |            return *element;
  636|       |         }
  637|       |      }
  638|       |      else {
  639|       |         return element;
  640|       |      }
  641|  61.1k|   }
_ZN3glz8str_viewINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERKS7_EENS1_17basic_string_viewIcS4_EEOT0_:
  288|  49.3k|   {
  289|       |      if constexpr (std::same_as<std::decay_t<T>, std::string_view>) {
  290|       |         return value; // already the answer; rebuilding it from data() and size() costs instructions
  291|       |      }
  292|       |      else if constexpr (!char_array_t<T> && std::is_pointer_v<std::decay_t<T>>) {
  293|       |         return value ? std::string_view{value} : std::string_view{};
  294|       |      }
  295|  49.3k|      else if constexpr (has_data<T> && has_size<T>) {
  296|  49.3k|         return std::string_view{value.data(), value.size()};
  297|       |      }
  298|       |      else {
  299|       |         return std::string_view{value};
  300|       |      }
  301|  49.3k|   }
_ZN3glz8str_viewINSt3__117basic_string_viewIcNS1_11char_traitsIcEEEERS5_EES5_OT0_:
  288|  5.77k|   {
  289|  5.77k|      if constexpr (std::same_as<std::decay_t<T>, std::string_view>) {
  290|  5.77k|         return value; // already the answer; rebuilding it from data() and size() costs instructions
  291|       |      }
  292|       |      else if constexpr (!char_array_t<T> && std::is_pointer_v<std::decay_t<T>>) {
  293|       |         return value ? std::string_view{value} : std::string_view{};
  294|       |      }
  295|       |      else if constexpr (has_data<T> && has_size<T>) {
  296|       |         return std::string_view{value.data(), value.size()};
  297|       |      }
  298|       |      else {
  299|       |         return std::string_view{value};
  300|       |      }
  301|  5.77k|   }
_ZN3glz10get_memberIRN12jsonrpc_fuzz10member_apiERKMS2_FiiEEEDcOT_OT0_:
  616|  61.1k|   {
  617|  61.1k|      using V = std::decay_t<decltype(element)>;
  618|       |      if constexpr (std::is_member_object_pointer_v<V>) {
  619|       |         return value.*element;
  620|       |      }
  621|  61.1k|      else if constexpr (std::is_member_function_pointer_v<V>) {
  622|  61.1k|         return element;
  623|       |      }
  624|       |      else if constexpr (std::invocable<Element, Value> && not eigen_t<Element>) {
  625|       |         // Eigen places a static_assert inside of the operator()(), so we must target
  626|       |         // matrix types and reject them from the invocable check
  627|       |         // Eigen ought to put the check in the `enable_if` for operator()()
  628|       |         return std::invoke(std::forward<Element>(element), std::forward<Value>(value));
  629|       |      }
  630|       |      else if constexpr (std::is_pointer_v<V> && !std::is_reference_v<Element>) {
  631|       |         if constexpr (std::invocable<decltype(*element), Value>) {
  632|       |            return std::invoke(*element, std::forward<Value>(value));
  633|       |         }
  634|       |         else {
  635|       |            return *element;
  636|       |         }
  637|       |      }
  638|       |      else {
  639|       |         return element;
  640|       |      }
  641|  61.1k|   }
_ZN3glz10get_memberIRN12jsonrpc_fuzz10member_apiERKMS2_FvvEEEDcOT_OT0_:
  616|  61.1k|   {
  617|  61.1k|      using V = std::decay_t<decltype(element)>;
  618|       |      if constexpr (std::is_member_object_pointer_v<V>) {
  619|       |         return value.*element;
  620|       |      }
  621|  61.1k|      else if constexpr (std::is_member_function_pointer_v<V>) {
  622|  61.1k|         return element;
  623|       |      }
  624|       |      else if constexpr (std::invocable<Element, Value> && not eigen_t<Element>) {
  625|       |         // Eigen places a static_assert inside of the operator()(), so we must target
  626|       |         // matrix types and reject them from the invocable check
  627|       |         // Eigen ought to put the check in the `enable_if` for operator()()
  628|       |         return std::invoke(std::forward<Element>(element), std::forward<Value>(value));
  629|       |      }
  630|       |      else if constexpr (std::is_pointer_v<V> && !std::is_reference_v<Element>) {
  631|       |         if constexpr (std::invocable<decltype(*element), Value>) {
  632|       |            return std::invoke(*element, std::forward<Value>(value));
  633|       |         }
  634|       |         else {
  635|       |            return *element;
  636|       |         }
  637|       |      }
  638|       |      else {
  639|       |         return element;
  640|       |      }
  641|  61.1k|   }
_ZN3glz10get_memberIRN12jsonrpc_fuzz10member_apiERKMS2_FNS1_5pointERKS4_EEEDcOT_OT0_:
  616|  61.1k|   {
  617|  61.1k|      using V = std::decay_t<decltype(element)>;
  618|       |      if constexpr (std::is_member_object_pointer_v<V>) {
  619|       |         return value.*element;
  620|       |      }
  621|  61.1k|      else if constexpr (std::is_member_function_pointer_v<V>) {
  622|  61.1k|         return element;
  623|       |      }
  624|       |      else if constexpr (std::invocable<Element, Value> && not eigen_t<Element>) {
  625|       |         // Eigen places a static_assert inside of the operator()(), so we must target
  626|       |         // matrix types and reject them from the invocable check
  627|       |         // Eigen ought to put the check in the `enable_if` for operator()()
  628|       |         return std::invoke(std::forward<Element>(element), std::forward<Value>(value));
  629|       |      }
  630|       |      else if constexpr (std::is_pointer_v<V> && !std::is_reference_v<Element>) {
  631|       |         if constexpr (std::invocable<decltype(*element), Value>) {
  632|       |            return std::invoke(*element, std::forward<Value>(value));
  633|       |         }
  634|       |         else {
  635|       |            return *element;
  636|       |         }
  637|       |      }
  638|       |      else {
  639|       |         return element;
  640|       |      }
  641|  61.1k|   }
_ZN3glz10get_memberIRN12jsonrpc_fuzz5pointERdEEDcOT_OT0_:
  616|   130k|   {
  617|   130k|      using V = std::decay_t<decltype(element)>;
  618|       |      if constexpr (std::is_member_object_pointer_v<V>) {
  619|       |         return value.*element;
  620|       |      }
  621|       |      else if constexpr (std::is_member_function_pointer_v<V>) {
  622|       |         return element;
  623|       |      }
  624|       |      else if constexpr (std::invocable<Element, Value> && not eigen_t<Element>) {
  625|       |         // Eigen places a static_assert inside of the operator()(), so we must target
  626|       |         // matrix types and reject them from the invocable check
  627|       |         // Eigen ought to put the check in the `enable_if` for operator()()
  628|       |         return std::invoke(std::forward<Element>(element), std::forward<Value>(value));
  629|       |      }
  630|       |      else if constexpr (std::is_pointer_v<V> && !std::is_reference_v<Element>) {
  631|       |         if constexpr (std::invocable<decltype(*element), Value>) {
  632|       |            return std::invoke(*element, std::forward<Value>(value));
  633|       |         }
  634|       |         else {
  635|       |            return *element;
  636|       |         }
  637|       |      }
  638|   130k|      else {
  639|   130k|         return element;
  640|   130k|      }
  641|   130k|   }
_ZN3glz10get_memberIRN12jsonrpc_fuzz8fuzz_apiERiEEDcOT_OT0_:
  616|  75.2k|   {
  617|  75.2k|      using V = std::decay_t<decltype(element)>;
  618|       |      if constexpr (std::is_member_object_pointer_v<V>) {
  619|       |         return value.*element;
  620|       |      }
  621|       |      else if constexpr (std::is_member_function_pointer_v<V>) {
  622|       |         return element;
  623|       |      }
  624|       |      else if constexpr (std::invocable<Element, Value> && not eigen_t<Element>) {
  625|       |         // Eigen places a static_assert inside of the operator()(), so we must target
  626|       |         // matrix types and reject them from the invocable check
  627|       |         // Eigen ought to put the check in the `enable_if` for operator()()
  628|       |         return std::invoke(std::forward<Element>(element), std::forward<Value>(value));
  629|       |      }
  630|       |      else if constexpr (std::is_pointer_v<V> && !std::is_reference_v<Element>) {
  631|       |         if constexpr (std::invocable<decltype(*element), Value>) {
  632|       |            return std::invoke(*element, std::forward<Value>(value));
  633|       |         }
  634|       |         else {
  635|       |            return *element;
  636|       |         }
  637|       |      }
  638|  75.2k|      else {
  639|  75.2k|         return element;
  640|  75.2k|      }
  641|  75.2k|   }
_ZN3glz10get_memberIRN12jsonrpc_fuzz8fuzz_apiERNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEDcOT_OT0_:
  616|  61.3k|   {
  617|  61.3k|      using V = std::decay_t<decltype(element)>;
  618|       |      if constexpr (std::is_member_object_pointer_v<V>) {
  619|       |         return value.*element;
  620|       |      }
  621|       |      else if constexpr (std::is_member_function_pointer_v<V>) {
  622|       |         return element;
  623|       |      }
  624|       |      else if constexpr (std::invocable<Element, Value> && not eigen_t<Element>) {
  625|       |         // Eigen places a static_assert inside of the operator()(), so we must target
  626|       |         // matrix types and reject them from the invocable check
  627|       |         // Eigen ought to put the check in the `enable_if` for operator()()
  628|       |         return std::invoke(std::forward<Element>(element), std::forward<Value>(value));
  629|       |      }
  630|       |      else if constexpr (std::is_pointer_v<V> && !std::is_reference_v<Element>) {
  631|       |         if constexpr (std::invocable<decltype(*element), Value>) {
  632|       |            return std::invoke(*element, std::forward<Value>(value));
  633|       |         }
  634|       |         else {
  635|       |            return *element;
  636|       |         }
  637|       |      }
  638|  61.3k|      else {
  639|  61.3k|         return element;
  640|  61.3k|      }
  641|  61.3k|   }
_ZN3glz10get_memberIRN12jsonrpc_fuzz8fuzz_apiERNS1_5pointEEEDcOT_OT0_:
  616|  61.8k|   {
  617|  61.8k|      using V = std::decay_t<decltype(element)>;
  618|       |      if constexpr (std::is_member_object_pointer_v<V>) {
  619|       |         return value.*element;
  620|       |      }
  621|       |      else if constexpr (std::is_member_function_pointer_v<V>) {
  622|       |         return element;
  623|       |      }
  624|       |      else if constexpr (std::invocable<Element, Value> && not eigen_t<Element>) {
  625|       |         // Eigen places a static_assert inside of the operator()(), so we must target
  626|       |         // matrix types and reject them from the invocable check
  627|       |         // Eigen ought to put the check in the `enable_if` for operator()()
  628|       |         return std::invoke(std::forward<Element>(element), std::forward<Value>(value));
  629|       |      }
  630|       |      else if constexpr (std::is_pointer_v<V> && !std::is_reference_v<Element>) {
  631|       |         if constexpr (std::invocable<decltype(*element), Value>) {
  632|       |            return std::invoke(*element, std::forward<Value>(value));
  633|       |         }
  634|       |         else {
  635|       |            return *element;
  636|       |         }
  637|       |      }
  638|  61.8k|      else {
  639|  61.8k|         return element;
  640|  61.8k|      }
  641|  61.8k|   }
_ZN3glz10get_memberIRN12jsonrpc_fuzz6nestedERiEEDcOT_OT0_:
  616|  73.6k|   {
  617|  73.6k|      using V = std::decay_t<decltype(element)>;
  618|       |      if constexpr (std::is_member_object_pointer_v<V>) {
  619|       |         return value.*element;
  620|       |      }
  621|       |      else if constexpr (std::is_member_function_pointer_v<V>) {
  622|       |         return element;
  623|       |      }
  624|       |      else if constexpr (std::invocable<Element, Value> && not eigen_t<Element>) {
  625|       |         // Eigen places a static_assert inside of the operator()(), so we must target
  626|       |         // matrix types and reject them from the invocable check
  627|       |         // Eigen ought to put the check in the `enable_if` for operator()()
  628|       |         return std::invoke(std::forward<Element>(element), std::forward<Value>(value));
  629|       |      }
  630|       |      else if constexpr (std::is_pointer_v<V> && !std::is_reference_v<Element>) {
  631|       |         if constexpr (std::invocable<decltype(*element), Value>) {
  632|       |            return std::invoke(*element, std::forward<Value>(value));
  633|       |         }
  634|       |         else {
  635|       |            return *element;
  636|       |         }
  637|       |      }
  638|  73.6k|      else {
  639|  73.6k|         return element;
  640|  73.6k|      }
  641|  73.6k|   }
_ZN3glz10get_memberIRN12jsonrpc_fuzz6nestedERNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEDcOT_OT0_:
  616|  61.6k|   {
  617|  61.6k|      using V = std::decay_t<decltype(element)>;
  618|       |      if constexpr (std::is_member_object_pointer_v<V>) {
  619|       |         return value.*element;
  620|       |      }
  621|       |      else if constexpr (std::is_member_function_pointer_v<V>) {
  622|       |         return element;
  623|       |      }
  624|       |      else if constexpr (std::invocable<Element, Value> && not eigen_t<Element>) {
  625|       |         // Eigen places a static_assert inside of the operator()(), so we must target
  626|       |         // matrix types and reject them from the invocable check
  627|       |         // Eigen ought to put the check in the `enable_if` for operator()()
  628|       |         return std::invoke(std::forward<Element>(element), std::forward<Value>(value));
  629|       |      }
  630|       |      else if constexpr (std::is_pointer_v<V> && !std::is_reference_v<Element>) {
  631|       |         if constexpr (std::invocable<decltype(*element), Value>) {
  632|       |            return std::invoke(*element, std::forward<Value>(value));
  633|       |         }
  634|       |         else {
  635|       |            return *element;
  636|       |         }
  637|       |      }
  638|  61.6k|      else {
  639|  61.6k|         return element;
  640|  61.6k|      }
  641|  61.6k|   }
_ZN3glz10get_memberIRN12jsonrpc_fuzz8fuzz_apiERNS1_6nestedEEEDcOT_OT0_:
  616|  61.9k|   {
  617|  61.9k|      using V = std::decay_t<decltype(element)>;
  618|       |      if constexpr (std::is_member_object_pointer_v<V>) {
  619|       |         return value.*element;
  620|       |      }
  621|       |      else if constexpr (std::is_member_function_pointer_v<V>) {
  622|       |         return element;
  623|       |      }
  624|       |      else if constexpr (std::invocable<Element, Value> && not eigen_t<Element>) {
  625|       |         // Eigen places a static_assert inside of the operator()(), so we must target
  626|       |         // matrix types and reject them from the invocable check
  627|       |         // Eigen ought to put the check in the `enable_if` for operator()()
  628|       |         return std::invoke(std::forward<Element>(element), std::forward<Value>(value));
  629|       |      }
  630|       |      else if constexpr (std::is_pointer_v<V> && !std::is_reference_v<Element>) {
  631|       |         if constexpr (std::invocable<decltype(*element), Value>) {
  632|       |            return std::invoke(*element, std::forward<Value>(value));
  633|       |         }
  634|       |         else {
  635|       |            return *element;
  636|       |         }
  637|       |      }
  638|  61.9k|      else {
  639|  61.9k|         return element;
  640|  61.9k|      }
  641|  61.9k|   }
_ZN3glz10get_memberIRN12jsonrpc_fuzz8fuzz_apiERNSt3__16vectorIiNS4_9allocatorIiEEEEEEDcOT_OT0_:
  616|  61.1k|   {
  617|  61.1k|      using V = std::decay_t<decltype(element)>;
  618|       |      if constexpr (std::is_member_object_pointer_v<V>) {
  619|       |         return value.*element;
  620|       |      }
  621|       |      else if constexpr (std::is_member_function_pointer_v<V>) {
  622|       |         return element;
  623|       |      }
  624|       |      else if constexpr (std::invocable<Element, Value> && not eigen_t<Element>) {
  625|       |         // Eigen places a static_assert inside of the operator()(), so we must target
  626|       |         // matrix types and reject them from the invocable check
  627|       |         // Eigen ought to put the check in the `enable_if` for operator()()
  628|       |         return std::invoke(std::forward<Element>(element), std::forward<Value>(value));
  629|       |      }
  630|       |      else if constexpr (std::is_pointer_v<V> && !std::is_reference_v<Element>) {
  631|       |         if constexpr (std::invocable<decltype(*element), Value>) {
  632|       |            return std::invoke(*element, std::forward<Value>(value));
  633|       |         }
  634|       |         else {
  635|       |            return *element;
  636|       |         }
  637|       |      }
  638|  61.1k|      else {
  639|  61.1k|         return element;
  640|  61.1k|      }
  641|  61.1k|   }
_ZN3glz10get_memberIRN12jsonrpc_fuzz8fuzz_apiERNSt3__13mapINS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEiNS4_4lessISB_EENS9_INS4_4pairIKSB_iEEEEEEEEDcOT_OT0_:
  616|  62.2k|   {
  617|  62.2k|      using V = std::decay_t<decltype(element)>;
  618|       |      if constexpr (std::is_member_object_pointer_v<V>) {
  619|       |         return value.*element;
  620|       |      }
  621|       |      else if constexpr (std::is_member_function_pointer_v<V>) {
  622|       |         return element;
  623|       |      }
  624|       |      else if constexpr (std::invocable<Element, Value> && not eigen_t<Element>) {
  625|       |         // Eigen places a static_assert inside of the operator()(), so we must target
  626|       |         // matrix types and reject them from the invocable check
  627|       |         // Eigen ought to put the check in the `enable_if` for operator()()
  628|       |         return std::invoke(std::forward<Element>(element), std::forward<Value>(value));
  629|       |      }
  630|       |      else if constexpr (std::is_pointer_v<V> && !std::is_reference_v<Element>) {
  631|       |         if constexpr (std::invocable<decltype(*element), Value>) {
  632|       |            return std::invoke(*element, std::forward<Value>(value));
  633|       |         }
  634|       |         else {
  635|       |            return *element;
  636|       |         }
  637|       |      }
  638|  62.2k|      else {
  639|  62.2k|         return element;
  640|  62.2k|      }
  641|  62.2k|   }
_ZN3glz10get_memberIRN12jsonrpc_fuzz8fuzz_apiERNSt3__18optionalIdEEEEDcOT_OT0_:
  616|  62.6k|   {
  617|  62.6k|      using V = std::decay_t<decltype(element)>;
  618|       |      if constexpr (std::is_member_object_pointer_v<V>) {
  619|       |         return value.*element;
  620|       |      }
  621|       |      else if constexpr (std::is_member_function_pointer_v<V>) {
  622|       |         return element;
  623|       |      }
  624|       |      else if constexpr (std::invocable<Element, Value> && not eigen_t<Element>) {
  625|       |         // Eigen places a static_assert inside of the operator()(), so we must target
  626|       |         // matrix types and reject them from the invocable check
  627|       |         // Eigen ought to put the check in the `enable_if` for operator()()
  628|       |         return std::invoke(std::forward<Element>(element), std::forward<Value>(value));
  629|       |      }
  630|       |      else if constexpr (std::is_pointer_v<V> && !std::is_reference_v<Element>) {
  631|       |         if constexpr (std::invocable<decltype(*element), Value>) {
  632|       |            return std::invoke(*element, std::forward<Value>(value));
  633|       |         }
  634|       |         else {
  635|       |            return *element;
  636|       |         }
  637|       |      }
  638|  62.6k|      else {
  639|  62.6k|         return element;
  640|  62.6k|      }
  641|  62.6k|   }
_ZN3glz10get_memberIRN12jsonrpc_fuzz6amountERdEEDcOT_OT0_:
  616|    303|   {
  617|    303|      using V = std::decay_t<decltype(element)>;
  618|       |      if constexpr (std::is_member_object_pointer_v<V>) {
  619|       |         return value.*element;
  620|       |      }
  621|       |      else if constexpr (std::is_member_function_pointer_v<V>) {
  622|       |         return element;
  623|       |      }
  624|       |      else if constexpr (std::invocable<Element, Value> && not eigen_t<Element>) {
  625|       |         // Eigen places a static_assert inside of the operator()(), so we must target
  626|       |         // matrix types and reject them from the invocable check
  627|       |         // Eigen ought to put the check in the `enable_if` for operator()()
  628|       |         return std::invoke(std::forward<Element>(element), std::forward<Value>(value));
  629|       |      }
  630|       |      else if constexpr (std::is_pointer_v<V> && !std::is_reference_v<Element>) {
  631|       |         if constexpr (std::invocable<decltype(*element), Value>) {
  632|       |            return std::invoke(*element, std::forward<Value>(value));
  633|       |         }
  634|       |         else {
  635|       |            return *element;
  636|       |         }
  637|       |      }
  638|    303|      else {
  639|    303|         return element;
  640|    303|      }
  641|    303|   }
_ZN3glz10get_memberIRN12jsonrpc_fuzz8fuzz_apiERNSt3__17variantIJNS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS1_6amountEEEEEEDcOT_OT0_:
  616|  61.8k|   {
  617|  61.8k|      using V = std::decay_t<decltype(element)>;
  618|       |      if constexpr (std::is_member_object_pointer_v<V>) {
  619|       |         return value.*element;
  620|       |      }
  621|       |      else if constexpr (std::is_member_function_pointer_v<V>) {
  622|       |         return element;
  623|       |      }
  624|       |      else if constexpr (std::invocable<Element, Value> && not eigen_t<Element>) {
  625|       |         // Eigen places a static_assert inside of the operator()(), so we must target
  626|       |         // matrix types and reject them from the invocable check
  627|       |         // Eigen ought to put the check in the `enable_if` for operator()()
  628|       |         return std::invoke(std::forward<Element>(element), std::forward<Value>(value));
  629|       |      }
  630|       |      else if constexpr (std::is_pointer_v<V> && !std::is_reference_v<Element>) {
  631|       |         if constexpr (std::invocable<decltype(*element), Value>) {
  632|       |            return std::invoke(*element, std::forward<Value>(value));
  633|       |         }
  634|       |         else {
  635|       |            return *element;
  636|       |         }
  637|       |      }
  638|  61.8k|      else {
  639|  61.8k|         return element;
  640|  61.8k|      }
  641|  61.8k|   }
_ZN3glz10get_memberIRN12jsonrpc_fuzz8fuzz_apiERNSt3__18functionIFiiEEEEEDcOT_OT0_:
  616|  61.3k|   {
  617|  61.3k|      using V = std::decay_t<decltype(element)>;
  618|       |      if constexpr (std::is_member_object_pointer_v<V>) {
  619|       |         return value.*element;
  620|       |      }
  621|       |      else if constexpr (std::is_member_function_pointer_v<V>) {
  622|       |         return element;
  623|       |      }
  624|       |      else if constexpr (std::invocable<Element, Value> && not eigen_t<Element>) {
  625|       |         // Eigen places a static_assert inside of the operator()(), so we must target
  626|       |         // matrix types and reject them from the invocable check
  627|       |         // Eigen ought to put the check in the `enable_if` for operator()()
  628|       |         return std::invoke(std::forward<Element>(element), std::forward<Value>(value));
  629|       |      }
  630|       |      else if constexpr (std::is_pointer_v<V> && !std::is_reference_v<Element>) {
  631|       |         if constexpr (std::invocable<decltype(*element), Value>) {
  632|       |            return std::invoke(*element, std::forward<Value>(value));
  633|       |         }
  634|       |         else {
  635|       |            return *element;
  636|       |         }
  637|       |      }
  638|  61.3k|      else {
  639|  61.3k|         return element;
  640|  61.3k|      }
  641|  61.3k|   }
_ZN3glz10get_memberIRN12jsonrpc_fuzz8fuzz_apiERNSt3__18functionIFNS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERKSB_EEEEEDcOT_OT0_:
  616|  69.3k|   {
  617|  69.3k|      using V = std::decay_t<decltype(element)>;
  618|       |      if constexpr (std::is_member_object_pointer_v<V>) {
  619|       |         return value.*element;
  620|       |      }
  621|       |      else if constexpr (std::is_member_function_pointer_v<V>) {
  622|       |         return element;
  623|       |      }
  624|       |      else if constexpr (std::invocable<Element, Value> && not eigen_t<Element>) {
  625|       |         // Eigen places a static_assert inside of the operator()(), so we must target
  626|       |         // matrix types and reject them from the invocable check
  627|       |         // Eigen ought to put the check in the `enable_if` for operator()()
  628|       |         return std::invoke(std::forward<Element>(element), std::forward<Value>(value));
  629|       |      }
  630|       |      else if constexpr (std::is_pointer_v<V> && !std::is_reference_v<Element>) {
  631|       |         if constexpr (std::invocable<decltype(*element), Value>) {
  632|       |            return std::invoke(*element, std::forward<Value>(value));
  633|       |         }
  634|       |         else {
  635|       |            return *element;
  636|       |         }
  637|       |      }
  638|  69.3k|      else {
  639|  69.3k|         return element;
  640|  69.3k|      }
  641|  69.3k|   }
_ZN3glz10get_memberIRN12jsonrpc_fuzz8fuzz_apiERNSt3__18functionIFNS1_5pointERKS6_EEEEEDcOT_OT0_:
  616|  61.2k|   {
  617|  61.2k|      using V = std::decay_t<decltype(element)>;
  618|       |      if constexpr (std::is_member_object_pointer_v<V>) {
  619|       |         return value.*element;
  620|       |      }
  621|       |      else if constexpr (std::is_member_function_pointer_v<V>) {
  622|       |         return element;
  623|       |      }
  624|       |      else if constexpr (std::invocable<Element, Value> && not eigen_t<Element>) {
  625|       |         // Eigen places a static_assert inside of the operator()(), so we must target
  626|       |         // matrix types and reject them from the invocable check
  627|       |         // Eigen ought to put the check in the `enable_if` for operator()()
  628|       |         return std::invoke(std::forward<Element>(element), std::forward<Value>(value));
  629|       |      }
  630|       |      else if constexpr (std::is_pointer_v<V> && !std::is_reference_v<Element>) {
  631|       |         if constexpr (std::invocable<decltype(*element), Value>) {
  632|       |            return std::invoke(*element, std::forward<Value>(value));
  633|       |         }
  634|       |         else {
  635|       |            return *element;
  636|       |         }
  637|       |      }
  638|  61.2k|      else {
  639|  61.2k|         return element;
  640|  61.2k|      }
  641|  61.2k|   }
_ZN3glz10get_memberIRN12jsonrpc_fuzz8fuzz_apiERNSt3__18functionIFdRNS4_6vectorIdNS4_9allocatorIdEEEEEEEEEDcOT_OT0_:
  616|  61.1k|   {
  617|  61.1k|      using V = std::decay_t<decltype(element)>;
  618|       |      if constexpr (std::is_member_object_pointer_v<V>) {
  619|       |         return value.*element;
  620|       |      }
  621|       |      else if constexpr (std::is_member_function_pointer_v<V>) {
  622|       |         return element;
  623|       |      }
  624|       |      else if constexpr (std::invocable<Element, Value> && not eigen_t<Element>) {
  625|       |         // Eigen places a static_assert inside of the operator()(), so we must target
  626|       |         // matrix types and reject them from the invocable check
  627|       |         // Eigen ought to put the check in the `enable_if` for operator()()
  628|       |         return std::invoke(std::forward<Element>(element), std::forward<Value>(value));
  629|       |      }
  630|       |      else if constexpr (std::is_pointer_v<V> && !std::is_reference_v<Element>) {
  631|       |         if constexpr (std::invocable<decltype(*element), Value>) {
  632|       |            return std::invoke(*element, std::forward<Value>(value));
  633|       |         }
  634|       |         else {
  635|       |            return *element;
  636|       |         }
  637|       |      }
  638|  61.1k|      else {
  639|  61.1k|         return element;
  640|  61.1k|      }
  641|  61.1k|   }
_ZN3glz10get_memberIRN12jsonrpc_fuzz8fuzz_apiERNSt3__18functionIFvvEEEEEDcOT_OT0_:
  616|  61.2k|   {
  617|  61.2k|      using V = std::decay_t<decltype(element)>;
  618|       |      if constexpr (std::is_member_object_pointer_v<V>) {
  619|       |         return value.*element;
  620|       |      }
  621|       |      else if constexpr (std::is_member_function_pointer_v<V>) {
  622|       |         return element;
  623|       |      }
  624|       |      else if constexpr (std::invocable<Element, Value> && not eigen_t<Element>) {
  625|       |         // Eigen places a static_assert inside of the operator()(), so we must target
  626|       |         // matrix types and reject them from the invocable check
  627|       |         // Eigen ought to put the check in the `enable_if` for operator()()
  628|       |         return std::invoke(std::forward<Element>(element), std::forward<Value>(value));
  629|       |      }
  630|       |      else if constexpr (std::is_pointer_v<V> && !std::is_reference_v<Element>) {
  631|       |         if constexpr (std::invocable<decltype(*element), Value>) {
  632|       |            return std::invoke(*element, std::forward<Value>(value));
  633|       |         }
  634|       |         else {
  635|       |            return *element;
  636|       |         }
  637|       |      }
  638|  61.2k|      else {
  639|  61.2k|         return element;
  640|  61.2k|      }
  641|  61.2k|   }
_ZN3glz8str_viewINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERS7_EENS1_17basic_string_viewIcS4_EEOT0_:
  288|  4.09M|   {
  289|       |      if constexpr (std::same_as<std::decay_t<T>, std::string_view>) {
  290|       |         return value; // already the answer; rebuilding it from data() and size() costs instructions
  291|       |      }
  292|       |      else if constexpr (!char_array_t<T> && std::is_pointer_v<std::decay_t<T>>) {
  293|       |         return value ? std::string_view{value} : std::string_view{};
  294|       |      }
  295|  4.09M|      else if constexpr (has_data<T> && has_size<T>) {
  296|  4.09M|         return std::string_view{value.data(), value.size()};
  297|       |      }
  298|       |      else {
  299|       |         return std::string_view{value};
  300|       |      }
  301|  4.09M|   }
_ZN3glz14basic_raw_jsonINSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEEC2Ev:
  178|  9.08M|      basic_raw_json() = default;
_ZN3glz10get_memberIRNS_3rpc18request_envelope_tERKMS2_NSt3__18optionalINS4_17basic_string_viewIcNS4_11char_traitsIcEEEEEEEEDcOT_OT0_:
  616|   110k|   {
  617|   110k|      using V = std::decay_t<decltype(element)>;
  618|   110k|      if constexpr (std::is_member_object_pointer_v<V>) {
  619|   110k|         return value.*element;
  620|       |      }
  621|       |      else if constexpr (std::is_member_function_pointer_v<V>) {
  622|       |         return element;
  623|       |      }
  624|       |      else if constexpr (std::invocable<Element, Value> && not eigen_t<Element>) {
  625|       |         // Eigen places a static_assert inside of the operator()(), so we must target
  626|       |         // matrix types and reject them from the invocable check
  627|       |         // Eigen ought to put the check in the `enable_if` for operator()()
  628|       |         return std::invoke(std::forward<Element>(element), std::forward<Value>(value));
  629|       |      }
  630|       |      else if constexpr (std::is_pointer_v<V> && !std::is_reference_v<Element>) {
  631|       |         if constexpr (std::invocable<decltype(*element), Value>) {
  632|       |            return std::invoke(*element, std::forward<Value>(value));
  633|       |         }
  634|       |         else {
  635|       |            return *element;
  636|       |         }
  637|       |      }
  638|       |      else {
  639|       |         return element;
  640|       |      }
  641|   110k|   }
_ZN3glz10get_memberIRNS_3rpc18request_envelope_tERKMS2_NS_14basic_raw_jsonINSt3__117basic_string_viewIcNS5_11char_traitsIcEEEEEEEEDcOT_OT0_:
  616|  36.1k|   {
  617|  36.1k|      using V = std::decay_t<decltype(element)>;
  618|  36.1k|      if constexpr (std::is_member_object_pointer_v<V>) {
  619|  36.1k|         return value.*element;
  620|       |      }
  621|       |      else if constexpr (std::is_member_function_pointer_v<V>) {
  622|       |         return element;
  623|       |      }
  624|       |      else if constexpr (std::invocable<Element, Value> && not eigen_t<Element>) {
  625|       |         // Eigen places a static_assert inside of the operator()(), so we must target
  626|       |         // matrix types and reject them from the invocable check
  627|       |         // Eigen ought to put the check in the `enable_if` for operator()()
  628|       |         return std::invoke(std::forward<Element>(element), std::forward<Value>(value));
  629|       |      }
  630|       |      else if constexpr (std::is_pointer_v<V> && !std::is_reference_v<Element>) {
  631|       |         if constexpr (std::invocable<decltype(*element), Value>) {
  632|       |            return std::invoke(*element, std::forward<Value>(value));
  633|       |         }
  634|       |         else {
  635|       |            return *element;
  636|       |         }
  637|       |      }
  638|       |      else {
  639|       |         return element;
  640|       |      }
  641|  36.1k|   }
_ZN3glz10get_memberIRNS_3rpc18request_envelope_tERKMS2_NSt3__17variantIJDnNS4_17basic_string_viewIcNS4_11char_traitsIcEEEElEEEEEDcOT_OT0_:
  616|  89.5k|   {
  617|  89.5k|      using V = std::decay_t<decltype(element)>;
  618|  89.5k|      if constexpr (std::is_member_object_pointer_v<V>) {
  619|  89.5k|         return value.*element;
  620|       |      }
  621|       |      else if constexpr (std::is_member_function_pointer_v<V>) {
  622|       |         return element;
  623|       |      }
  624|       |      else if constexpr (std::invocable<Element, Value> && not eigen_t<Element>) {
  625|       |         // Eigen places a static_assert inside of the operator()(), so we must target
  626|       |         // matrix types and reject them from the invocable check
  627|       |         // Eigen ought to put the check in the `enable_if` for operator()()
  628|       |         return std::invoke(std::forward<Element>(element), std::forward<Value>(value));
  629|       |      }
  630|       |      else if constexpr (std::is_pointer_v<V> && !std::is_reference_v<Element>) {
  631|       |         if constexpr (std::invocable<decltype(*element), Value>) {
  632|       |            return std::invoke(*element, std::forward<Value>(value));
  633|       |         }
  634|       |         else {
  635|       |            return *element;
  636|       |         }
  637|       |      }
  638|       |      else {
  639|       |         return element;
  640|       |      }
  641|  89.5k|   }
_ZN3glz8str_viewINSt3__117basic_string_viewIcNS1_11char_traitsIcEEEERKS5_EES5_OT0_:
  288|     40|   {
  289|     40|      if constexpr (std::same_as<std::decay_t<T>, std::string_view>) {
  290|     40|         return value; // already the answer; rebuilding it from data() and size() costs instructions
  291|       |      }
  292|       |      else if constexpr (!char_array_t<T> && std::is_pointer_v<std::decay_t<T>>) {
  293|       |         return value ? std::string_view{value} : std::string_view{};
  294|       |      }
  295|       |      else if constexpr (has_data<T> && has_size<T>) {
  296|       |         return std::string_view{value.data(), value.size()};
  297|       |      }
  298|       |      else {
  299|       |         return std::string_view{value};
  300|       |      }
  301|     40|   }
_ZN3glz10get_memberIRNS_12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEERKMS4_NSt3__17variantIJDndNS6_12basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEbNS6_6vectorIS4_NSB_IS4_EEEENS3_IS4_EEEEEEEDcOT_OT0_:
  616|  1.77M|   {
  617|  1.77M|      using V = std::decay_t<decltype(element)>;
  618|  1.77M|      if constexpr (std::is_member_object_pointer_v<V>) {
  619|  1.77M|         return value.*element;
  620|       |      }
  621|       |      else if constexpr (std::is_member_function_pointer_v<V>) {
  622|       |         return element;
  623|       |      }
  624|       |      else if constexpr (std::invocable<Element, Value> && not eigen_t<Element>) {
  625|       |         // Eigen places a static_assert inside of the operator()(), so we must target
  626|       |         // matrix types and reject them from the invocable check
  627|       |         // Eigen ought to put the check in the `enable_if` for operator()()
  628|       |         return std::invoke(std::forward<Element>(element), std::forward<Value>(value));
  629|       |      }
  630|       |      else if constexpr (std::is_pointer_v<V> && !std::is_reference_v<Element>) {
  631|       |         if constexpr (std::invocable<decltype(*element), Value>) {
  632|       |            return std::invoke(*element, std::forward<Value>(value));
  633|       |         }
  634|       |         else {
  635|       |            return *element;
  636|       |         }
  637|       |      }
  638|       |      else {
  639|       |         return element;
  640|       |      }
  641|  1.77M|   }

_ZN3glz11enter_depthITkNS_10is_contextENS_7contextEEEbRT_:
  281|  1.15M|   {
  282|  1.15M|      if (ctx.depth >= max_recursive_depth_limit) [[unlikely]] {
  ------------------
  |  Branch (282:11): [True: 782, False: 1.15M]
  ------------------
  283|    782|         ctx.error = error_code::exceeded_max_recursive_depth;
  284|    782|         return true;
  285|    782|      }
  286|  1.15M|      ++ctx.depth;
  287|  1.15M|      return false;
  288|  1.15M|   }
_ZNK3glz9error_ctxcvbEv:
  136|  12.5M|      operator bool() const noexcept { return ec != error_code::none; }
_ZN3glz18charge_speculationITkNS_10is_contextENS_7contextEEEbRT_m:
  249|  62.4k|   {
  250|  62.4k|      if constexpr (requires { ctx.speculation_budget; }) {
  251|  62.4k|         if (ctx.speculation_budget == 0) {
  ------------------
  |  Branch (251:14): [True: 0, False: 62.4k]
  ------------------
  252|      0|            return true;
  253|      0|         }
  254|  62.4k|         ctx.speculation_budget = consumed >= ctx.speculation_budget ? 1 : ctx.speculation_budget - consumed;
  ------------------
  |  Branch (254:35): [True: 0, False: 62.4k]
  ------------------
  255|  62.4k|         return ctx.speculation_budget > 1;
  256|       |      }
  257|       |      else {
  258|       |         return true;
  259|       |      }
  260|  62.4k|   }
_ZN3glz21speculation_exhaustedITkNS_10is_contextENS_7contextEEEbRT_:
  266|  1.99k|   {
  267|  1.99k|      if constexpr (requires { ctx.speculation_budget; }) {
  268|  1.99k|         return ctx.speculation_budget == 1; // the latched floor; 0 means unbudgeted
  269|       |      }
  270|       |      else {
  271|       |         return false;
  272|       |      }
  273|  1.99k|   }

_ZN3glz14read_iteratorsITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELb0ETkNS_10contiguousERNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEEEDaOT1_:
   40|   654k|   {
   41|   654k|      static_assert(sizeof(decltype(*buffer.data())) == 1);
   42|       |
   43|   654k|      auto it = reinterpret_cast<const char*>(buffer.data());
   44|   654k|      auto end = reinterpret_cast<const char*>(buffer.data()); // to be incremented
   45|       |
   46|       |      if constexpr (Padded) {
   47|       |         end += buffer.size() - padding_bytes;
   48|       |      }
   49|   654k|      else {
   50|   654k|         end += buffer.size();
   51|   654k|      }
   52|       |
   53|   654k|      return std::pair{it, end};
   54|   654k|   }
_ZN3glz23finalize_top_level_readITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETkNS_10is_contextERNS_7contextEEEvOT0_PKcS7_S7_:
  115|   551k|   {
  116|   551k|      if constexpr (Opts.format == JSON && !check_null_terminated(Opts)) {
  117|       |         // Deliberately not [[unlikely]]: a body that ends with the buffer lands here on every
  118|       |         // successful read, which is the ordinary case for a registry parsing a wire span.
  119|       |         // start < it, not !=, because a streaming origin can be empty or overshoot on an error
  120|       |         // path; neither is an absent value.
  121|   551k|         if (ctx.error == error_code::end_reached && ctx.depth == 0 && it == end && start < it) {
  ------------------
  |  Branch (121:14): [True: 90.3k, False: 461k]
  |  Branch (121:54): [True: 89.6k, False: 707]
  |  Branch (121:72): [True: 88.6k, False: 963]
  |  Branch (121:85): [True: 88.6k, False: 0]
  ------------------
  122|  88.6k|            context ws_ctx{}; // only written to when skip_ws parses a comment; the result is unused
  123|  88.6k|            const char* consumed = start;
  124|  88.6k|            skip_ws<Opts>(ws_ctx, consumed, it);
  125|  88.6k|            if (consumed == it) {
  ------------------
  |  Branch (125:17): [True: 15, False: 88.6k]
  ------------------
  126|     15|               ctx.error = error_code::no_read_input;
  127|     15|            }
  128|  88.6k|         }
  129|   551k|      }
  130|   551k|      finalize_read_context<Opts>(ctx);
  131|   551k|   }
_ZN3glz21finalize_read_contextITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETkNS_10is_contextERNS_7contextEEEvOT0_:
   76|   551k|   {
   77|       |      // A partial read stops as soon as it has the fields it was asked for, so it unwinds through
   78|       |      // its enclosing containers on an error code rather than through their closing braces, and
   79|       |      // none of them decrement depth on the way out. Depth is left standing at whatever nesting the
   80|       |      // last field sat at.
   81|       |      //
   82|       |      // That has to be cleared here rather than left for the next read to trip over. This is the
   83|       |      // one path that reports success with depth still raised, and depth is what settle_end_reached
   84|       |      // reads to tell a completed parse from a truncated one -- so a context reused after a partial
   85|       |      // read would see a later well-formed buffer settle to unexpected_end. Reads that end any
   86|       |      // other way either return depth to zero themselves or carry an error, and a context holding
   87|       |      // an error short-circuits the next read before it parses anything.
   88|       |      if constexpr (check_partial_read(Opts)) {
   89|       |         if (ctx.error == error_code::partial_read_complete) [[likely]] {
   90|       |            ctx.error = error_code::none;
   91|       |            ctx.depth = 0;
   92|       |            return;
   93|       |         }
   94|       |      }
   95|   551k|      settle_end_reached(ctx);
   96|   551k|   }
_ZN3glz18settle_end_reachedITkNS_10is_contextERNS_7contextEEEvOT_:
   68|   916k|   {
   69|   916k|      if (ctx.error == error_code::end_reached) {
  ------------------
  |  Branch (69:11): [True: 118k, False: 798k]
  ------------------
   70|   118k|         ctx.error = (ctx.depth == 0) ? error_code::none : error_code::unexpected_end;
  ------------------
  |  Branch (70:22): [True: 117k, False: 881]
  ------------------
   71|   118k|      }
   72|   916k|   }
_ZN3glz4readITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEiTkNS_10contiguousERNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEQaa14read_supportedIT0_XdtT_6formatEEnt18is_input_streamingIT1_EEENS_9error_ctxERS8_OS9_:
  219|  1.30k|   {
  220|  1.30k|      format_context_t<Opts.format> ctx{};
  221|  1.30k|      return read<Opts>(value, buffer, ctx);
  222|  1.30k|   }
_ZN3glz4readITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEiTkNS_10contiguousERNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEETkNS_10is_contextERNS_7contextEQaa14read_supportedIT0_XdtT_6formatEEnt18is_input_streamingIT1_EEENS_9error_ctxERSA_OSB_OT2_:
  136|  1.30k|   {
  137|  1.30k|      static_assert(sizeof(decltype(*buffer.data())) == 1);
  138|  1.30k|      using Buffer = std::remove_reference_t<decltype(buffer)>;
  139|       |
  140|  1.30k|      if constexpr (Opts.format != NDJSON) {
  141|  1.30k|         if (buffer.empty()) [[unlikely]] {
  ------------------
  |  Branch (141:14): [True: 0, False: 1.30k]
  ------------------
  142|      0|            ctx.error = error_code::no_read_input;
  143|      0|            return {0, ctx.error, ctx.custom_error_message};
  144|      0|         }
  145|  1.30k|      }
  146|       |
  147|  1.30k|      constexpr bool use_padded = resizable<Buffer> && non_const_buffer<Buffer> && !check_disable_padding(Opts);
  ------------------
  |  Branch (147:35): [Folded, False: 1.30k]
  |  Branch (147:56): [True: 0, Folded]
  |  Branch (147:84): [True: 0, Folded]
  ------------------
  148|       |
  149|  1.30k|      [[maybe_unused]] size_t original_size{};
  150|       |      if constexpr (use_padded) {
  151|       |         // Pad the buffer for SWAR
  152|       |         original_size = buffer.size();
  153|       |         buffer.resize(original_size + padding_bytes);
  154|       |      }
  155|       |
  156|  1.30k|      auto [it, end] = read_iterators<Opts, use_padded>(buffer);
  157|  1.30k|      auto start = it;
  158|  1.30k|      if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (158:11): [True: 0, False: 1.30k]
  ------------------
  159|      0|         goto finish;
  160|      0|      }
  161|       |
  162|       |      // Bound the speculative re-parsing a variant resolution may do, in bytes, relative to this
  163|       |      // input. Seeded per read so a reused context starts fresh. See charge_speculation.
  164|  1.30k|      if constexpr (requires { ctx.speculation_budget; }) {
  165|  1.30k|         const size_t proportional = max_speculative_parse_factor * size_t(end - it);
  166|  1.30k|         ctx.speculation_budget =
  167|  1.30k|            (proportional > min_speculative_parse_bytes ? proportional : min_speculative_parse_bytes) + 2;
  ------------------
  |  Branch (167:14): [True: 9, False: 1.29k]
  ------------------
  168|  1.30k|      }
  169|       |
  170|       |      // A YAML context marks its outermost parse with stream_begin and seeds its expansion budgets
  171|       |      // there, so clearing it here is what makes those budgets per-read like the one above. A
  172|       |      // reused context would otherwise carry a spent budget into the next document and reject a
  173|       |      // valid one, and would leave stream_begin pointing into the buffer of the previous read.
  174|       |      // Nested YAML parses do not route through glz::read, so they still cannot reseed themselves.
  175|       |      if constexpr (requires { ctx.stream_begin; }) {
  176|       |         ctx.stream_begin = nullptr;
  177|       |      }
  178|       |
  179|       |      if constexpr (use_padded) {
  180|       |         parse<Opts.format>::template op<is_padded_on<Opts>()>(value, ctx, it, end);
  181|       |      }
  182|  1.30k|      else {
  183|  1.30k|         parse<Opts.format>::template op<is_padded_off<Opts>()>(value, ctx, it, end);
  184|  1.30k|      }
  185|       |
  186|  1.30k|      if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (186:11): [True: 1.15k, False: 146]
  ------------------
  187|  1.15k|         goto finish;
  188|  1.15k|      }
  189|       |
  190|       |      // The JSON RFC 8259 defines: JSON-text = ws value ws
  191|       |      // So, trailing whitespace is permitted and sometimes we want to
  192|       |      // validate this, even though this memory will not affect Glaze.
  193|       |      if constexpr (check_validate_trailing_whitespace(Opts)) {
  194|       |         if (it < end) {
  195|       |            skip_ws<Opts>(ctx, it, end);
  196|       |            if (bool(ctx.error)) [[unlikely]] {
  197|       |               goto finish;
  198|       |            }
  199|       |            if (it != end) [[unlikely]] {
  200|       |               ctx.error = error_code::syntax_error;
  201|       |            }
  202|       |         }
  203|       |      }
  204|       |
  205|  1.30k|   finish:
  206|  1.30k|      finalize_top_level_read<Opts>(ctx, start, it, end);
  207|       |
  208|       |      if constexpr (use_padded) {
  209|       |         // Restore the original buffer state
  210|       |         buffer.resize(original_size);
  211|       |      }
  212|       |
  213|  1.30k|      return {size_t(it - start), ctx.error, ctx.custom_error_message};
  214|    146|   }
_ZN3glz4readITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz5pointETkNS_10contiguousERNSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEQaa14read_supportedIT0_XdtT_6formatEEnt18is_input_streamingIT1_EEENS_9error_ctxERSA_OSB_:
  219|  1.18k|   {
  220|  1.18k|      format_context_t<Opts.format> ctx{};
  221|  1.18k|      return read<Opts>(value, buffer, ctx);
  222|  1.18k|   }
_ZN3glz4readITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz5pointETkNS_10contiguousERNSt3__117basic_string_viewIcNS4_11char_traitsIcEEEETkNS_10is_contextERNS_7contextEQaa14read_supportedIT0_XdtT_6formatEEnt18is_input_streamingIT1_EEENS_9error_ctxERSC_OSD_OT2_:
  136|  1.18k|   {
  137|  1.18k|      static_assert(sizeof(decltype(*buffer.data())) == 1);
  138|  1.18k|      using Buffer = std::remove_reference_t<decltype(buffer)>;
  139|       |
  140|  1.18k|      if constexpr (Opts.format != NDJSON) {
  141|  1.18k|         if (buffer.empty()) [[unlikely]] {
  ------------------
  |  Branch (141:14): [True: 0, False: 1.18k]
  ------------------
  142|      0|            ctx.error = error_code::no_read_input;
  143|      0|            return {0, ctx.error, ctx.custom_error_message};
  144|      0|         }
  145|  1.18k|      }
  146|       |
  147|  1.18k|      constexpr bool use_padded = resizable<Buffer> && non_const_buffer<Buffer> && !check_disable_padding(Opts);
  ------------------
  |  Branch (147:35): [Folded, False: 1.18k]
  |  Branch (147:56): [True: 0, Folded]
  |  Branch (147:84): [True: 0, Folded]
  ------------------
  148|       |
  149|  1.18k|      [[maybe_unused]] size_t original_size{};
  150|       |      if constexpr (use_padded) {
  151|       |         // Pad the buffer for SWAR
  152|       |         original_size = buffer.size();
  153|       |         buffer.resize(original_size + padding_bytes);
  154|       |      }
  155|       |
  156|  1.18k|      auto [it, end] = read_iterators<Opts, use_padded>(buffer);
  157|  1.18k|      auto start = it;
  158|  1.18k|      if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (158:11): [True: 0, False: 1.18k]
  ------------------
  159|      0|         goto finish;
  160|      0|      }
  161|       |
  162|       |      // Bound the speculative re-parsing a variant resolution may do, in bytes, relative to this
  163|       |      // input. Seeded per read so a reused context starts fresh. See charge_speculation.
  164|  1.18k|      if constexpr (requires { ctx.speculation_budget; }) {
  165|  1.18k|         const size_t proportional = max_speculative_parse_factor * size_t(end - it);
  166|  1.18k|         ctx.speculation_budget =
  167|  1.18k|            (proportional > min_speculative_parse_bytes ? proportional : min_speculative_parse_bytes) + 2;
  ------------------
  |  Branch (167:14): [True: 7, False: 1.17k]
  ------------------
  168|  1.18k|      }
  169|       |
  170|       |      // A YAML context marks its outermost parse with stream_begin and seeds its expansion budgets
  171|       |      // there, so clearing it here is what makes those budgets per-read like the one above. A
  172|       |      // reused context would otherwise carry a spent budget into the next document and reject a
  173|       |      // valid one, and would leave stream_begin pointing into the buffer of the previous read.
  174|       |      // Nested YAML parses do not route through glz::read, so they still cannot reseed themselves.
  175|       |      if constexpr (requires { ctx.stream_begin; }) {
  176|       |         ctx.stream_begin = nullptr;
  177|       |      }
  178|       |
  179|       |      if constexpr (use_padded) {
  180|       |         parse<Opts.format>::template op<is_padded_on<Opts>()>(value, ctx, it, end);
  181|       |      }
  182|  1.18k|      else {
  183|  1.18k|         parse<Opts.format>::template op<is_padded_off<Opts>()>(value, ctx, it, end);
  184|  1.18k|      }
  185|       |
  186|  1.18k|      if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (186:11): [True: 1.18k, False: 0]
  ------------------
  187|  1.18k|         goto finish;
  188|  1.18k|      }
  189|       |
  190|       |      // The JSON RFC 8259 defines: JSON-text = ws value ws
  191|       |      // So, trailing whitespace is permitted and sometimes we want to
  192|       |      // validate this, even though this memory will not affect Glaze.
  193|       |      if constexpr (check_validate_trailing_whitespace(Opts)) {
  194|       |         if (it < end) {
  195|       |            skip_ws<Opts>(ctx, it, end);
  196|       |            if (bool(ctx.error)) [[unlikely]] {
  197|       |               goto finish;
  198|       |            }
  199|       |            if (it != end) [[unlikely]] {
  200|       |               ctx.error = error_code::syntax_error;
  201|       |            }
  202|       |         }
  203|       |      }
  204|       |
  205|  1.18k|   finish:
  206|  1.18k|      finalize_top_level_read<Opts>(ctx, start, it, end);
  207|       |
  208|       |      if constexpr (use_padded) {
  209|       |         // Restore the original buffer state
  210|       |         buffer.resize(original_size);
  211|       |      }
  212|       |
  213|  1.18k|      return {size_t(it - start), ctx.error, ctx.custom_error_message};
  214|      0|   }
_ZN3glz4readITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiETkNS_10contiguousERNSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEQaa14read_supportedIT0_XdtT_6formatEEnt18is_input_streamingIT1_EEENS_9error_ctxERSA_OSB_:
  219|  5.21k|   {
  220|  5.21k|      format_context_t<Opts.format> ctx{};
  221|  5.21k|      return read<Opts>(value, buffer, ctx);
  222|  5.21k|   }
_ZN3glz4readITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiETkNS_10contiguousERNSt3__117basic_string_viewIcNS4_11char_traitsIcEEEETkNS_10is_contextERNS_7contextEQaa14read_supportedIT0_XdtT_6formatEEnt18is_input_streamingIT1_EEENS_9error_ctxERSC_OSD_OT2_:
  136|  5.21k|   {
  137|  5.21k|      static_assert(sizeof(decltype(*buffer.data())) == 1);
  138|  5.21k|      using Buffer = std::remove_reference_t<decltype(buffer)>;
  139|       |
  140|  5.21k|      if constexpr (Opts.format != NDJSON) {
  141|  5.21k|         if (buffer.empty()) [[unlikely]] {
  ------------------
  |  Branch (141:14): [True: 0, False: 5.21k]
  ------------------
  142|      0|            ctx.error = error_code::no_read_input;
  143|      0|            return {0, ctx.error, ctx.custom_error_message};
  144|      0|         }
  145|  5.21k|      }
  146|       |
  147|  5.21k|      constexpr bool use_padded = resizable<Buffer> && non_const_buffer<Buffer> && !check_disable_padding(Opts);
  ------------------
  |  Branch (147:35): [Folded, False: 5.21k]
  |  Branch (147:56): [True: 0, Folded]
  |  Branch (147:84): [True: 0, Folded]
  ------------------
  148|       |
  149|  5.21k|      [[maybe_unused]] size_t original_size{};
  150|       |      if constexpr (use_padded) {
  151|       |         // Pad the buffer for SWAR
  152|       |         original_size = buffer.size();
  153|       |         buffer.resize(original_size + padding_bytes);
  154|       |      }
  155|       |
  156|  5.21k|      auto [it, end] = read_iterators<Opts, use_padded>(buffer);
  157|  5.21k|      auto start = it;
  158|  5.21k|      if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (158:11): [True: 0, False: 5.21k]
  ------------------
  159|      0|         goto finish;
  160|      0|      }
  161|       |
  162|       |      // Bound the speculative re-parsing a variant resolution may do, in bytes, relative to this
  163|       |      // input. Seeded per read so a reused context starts fresh. See charge_speculation.
  164|  5.21k|      if constexpr (requires { ctx.speculation_budget; }) {
  165|  5.21k|         const size_t proportional = max_speculative_parse_factor * size_t(end - it);
  166|  5.21k|         ctx.speculation_budget =
  167|  5.21k|            (proportional > min_speculative_parse_bytes ? proportional : min_speculative_parse_bytes) + 2;
  ------------------
  |  Branch (167:14): [True: 53, False: 5.16k]
  ------------------
  168|  5.21k|      }
  169|       |
  170|       |      // A YAML context marks its outermost parse with stream_begin and seeds its expansion budgets
  171|       |      // there, so clearing it here is what makes those budgets per-read like the one above. A
  172|       |      // reused context would otherwise carry a spent budget into the next document and reject a
  173|       |      // valid one, and would leave stream_begin pointing into the buffer of the previous read.
  174|       |      // Nested YAML parses do not route through glz::read, so they still cannot reseed themselves.
  175|       |      if constexpr (requires { ctx.stream_begin; }) {
  176|       |         ctx.stream_begin = nullptr;
  177|       |      }
  178|       |
  179|       |      if constexpr (use_padded) {
  180|       |         parse<Opts.format>::template op<is_padded_on<Opts>()>(value, ctx, it, end);
  181|       |      }
  182|  5.21k|      else {
  183|  5.21k|         parse<Opts.format>::template op<is_padded_off<Opts>()>(value, ctx, it, end);
  184|  5.21k|      }
  185|       |
  186|  5.21k|      if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (186:11): [True: 5.21k, False: 0]
  ------------------
  187|  5.21k|         goto finish;
  188|  5.21k|      }
  189|       |
  190|       |      // The JSON RFC 8259 defines: JSON-text = ws value ws
  191|       |      // So, trailing whitespace is permitted and sometimes we want to
  192|       |      // validate this, even though this memory will not affect Glaze.
  193|       |      if constexpr (check_validate_trailing_whitespace(Opts)) {
  194|       |         if (it < end) {
  195|       |            skip_ws<Opts>(ctx, it, end);
  196|       |            if (bool(ctx.error)) [[unlikely]] {
  197|       |               goto finish;
  198|       |            }
  199|       |            if (it != end) [[unlikely]] {
  200|       |               ctx.error = error_code::syntax_error;
  201|       |            }
  202|       |         }
  203|       |      }
  204|       |
  205|  5.21k|   finish:
  206|  5.21k|      finalize_top_level_read<Opts>(ctx, start, it, end);
  207|       |
  208|       |      if constexpr (use_padded) {
  209|       |         // Restore the original buffer state
  210|       |         buffer.resize(original_size);
  211|       |      }
  212|       |
  213|  5.21k|      return {size_t(it - start), ctx.error, ctx.custom_error_message};
  214|      0|   }
_ZN3glz4readITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEETkNS_10contiguousERNS2_17basic_string_viewIcS5_EEQaa14read_supportedIT0_XdtT_6formatEEnt18is_input_streamingIT1_EEENS_9error_ctxERSC_OSD_:
  219|  1.28k|   {
  220|  1.28k|      format_context_t<Opts.format> ctx{};
  221|  1.28k|      return read<Opts>(value, buffer, ctx);
  222|  1.28k|   }
_ZN3glz4readITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEETkNS_10contiguousERNS2_17basic_string_viewIcS5_EETkNS_10is_contextERNS_7contextEQaa14read_supportedIT0_XdtT_6formatEEnt18is_input_streamingIT1_EEENS_9error_ctxERSE_OSF_OT2_:
  136|  1.28k|   {
  137|  1.28k|      static_assert(sizeof(decltype(*buffer.data())) == 1);
  138|  1.28k|      using Buffer = std::remove_reference_t<decltype(buffer)>;
  139|       |
  140|  1.28k|      if constexpr (Opts.format != NDJSON) {
  141|  1.28k|         if (buffer.empty()) [[unlikely]] {
  ------------------
  |  Branch (141:14): [True: 0, False: 1.28k]
  ------------------
  142|      0|            ctx.error = error_code::no_read_input;
  143|      0|            return {0, ctx.error, ctx.custom_error_message};
  144|      0|         }
  145|  1.28k|      }
  146|       |
  147|  1.28k|      constexpr bool use_padded = resizable<Buffer> && non_const_buffer<Buffer> && !check_disable_padding(Opts);
  ------------------
  |  Branch (147:35): [Folded, False: 1.28k]
  |  Branch (147:56): [True: 0, Folded]
  |  Branch (147:84): [True: 0, Folded]
  ------------------
  148|       |
  149|  1.28k|      [[maybe_unused]] size_t original_size{};
  150|       |      if constexpr (use_padded) {
  151|       |         // Pad the buffer for SWAR
  152|       |         original_size = buffer.size();
  153|       |         buffer.resize(original_size + padding_bytes);
  154|       |      }
  155|       |
  156|  1.28k|      auto [it, end] = read_iterators<Opts, use_padded>(buffer);
  157|  1.28k|      auto start = it;
  158|  1.28k|      if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (158:11): [True: 0, False: 1.28k]
  ------------------
  159|      0|         goto finish;
  160|      0|      }
  161|       |
  162|       |      // Bound the speculative re-parsing a variant resolution may do, in bytes, relative to this
  163|       |      // input. Seeded per read so a reused context starts fresh. See charge_speculation.
  164|  1.28k|      if constexpr (requires { ctx.speculation_budget; }) {
  165|  1.28k|         const size_t proportional = max_speculative_parse_factor * size_t(end - it);
  166|  1.28k|         ctx.speculation_budget =
  167|  1.28k|            (proportional > min_speculative_parse_bytes ? proportional : min_speculative_parse_bytes) + 2;
  ------------------
  |  Branch (167:14): [True: 29, False: 1.25k]
  ------------------
  168|  1.28k|      }
  169|       |
  170|       |      // A YAML context marks its outermost parse with stream_begin and seeds its expansion budgets
  171|       |      // there, so clearing it here is what makes those budgets per-read like the one above. A
  172|       |      // reused context would otherwise carry a spent budget into the next document and reject a
  173|       |      // valid one, and would leave stream_begin pointing into the buffer of the previous read.
  174|       |      // Nested YAML parses do not route through glz::read, so they still cannot reseed themselves.
  175|       |      if constexpr (requires { ctx.stream_begin; }) {
  176|       |         ctx.stream_begin = nullptr;
  177|       |      }
  178|       |
  179|       |      if constexpr (use_padded) {
  180|       |         parse<Opts.format>::template op<is_padded_on<Opts>()>(value, ctx, it, end);
  181|       |      }
  182|  1.28k|      else {
  183|  1.28k|         parse<Opts.format>::template op<is_padded_off<Opts>()>(value, ctx, it, end);
  184|  1.28k|      }
  185|       |
  186|  1.28k|      if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (186:11): [True: 855, False: 432]
  ------------------
  187|    855|         goto finish;
  188|    855|      }
  189|       |
  190|       |      // The JSON RFC 8259 defines: JSON-text = ws value ws
  191|       |      // So, trailing whitespace is permitted and sometimes we want to
  192|       |      // validate this, even though this memory will not affect Glaze.
  193|       |      if constexpr (check_validate_trailing_whitespace(Opts)) {
  194|       |         if (it < end) {
  195|       |            skip_ws<Opts>(ctx, it, end);
  196|       |            if (bool(ctx.error)) [[unlikely]] {
  197|       |               goto finish;
  198|       |            }
  199|       |            if (it != end) [[unlikely]] {
  200|       |               ctx.error = error_code::syntax_error;
  201|       |            }
  202|       |         }
  203|       |      }
  204|       |
  205|  1.28k|   finish:
  206|  1.28k|      finalize_top_level_read<Opts>(ctx, start, it, end);
  207|       |
  208|       |      if constexpr (use_padded) {
  209|       |         // Restore the original buffer state
  210|       |         buffer.resize(original_size);
  211|       |      }
  212|       |
  213|  1.28k|      return {size_t(it - start), ctx.error, ctx.custom_error_message};
  214|    432|   }
_ZN3glz4readITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEdTkNS_10contiguousERNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEQaa14read_supportedIT0_XdtT_6formatEEnt18is_input_streamingIT1_EEENS_9error_ctxERS8_OS9_:
  219|    559|   {
  220|    559|      format_context_t<Opts.format> ctx{};
  221|    559|      return read<Opts>(value, buffer, ctx);
  222|    559|   }
_ZN3glz4readITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEdTkNS_10contiguousERNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEETkNS_10is_contextERNS_7contextEQaa14read_supportedIT0_XdtT_6formatEEnt18is_input_streamingIT1_EEENS_9error_ctxERSA_OSB_OT2_:
  136|    559|   {
  137|    559|      static_assert(sizeof(decltype(*buffer.data())) == 1);
  138|    559|      using Buffer = std::remove_reference_t<decltype(buffer)>;
  139|       |
  140|    559|      if constexpr (Opts.format != NDJSON) {
  141|    559|         if (buffer.empty()) [[unlikely]] {
  ------------------
  |  Branch (141:14): [True: 0, False: 559]
  ------------------
  142|      0|            ctx.error = error_code::no_read_input;
  143|      0|            return {0, ctx.error, ctx.custom_error_message};
  144|      0|         }
  145|    559|      }
  146|       |
  147|    559|      constexpr bool use_padded = resizable<Buffer> && non_const_buffer<Buffer> && !check_disable_padding(Opts);
  ------------------
  |  Branch (147:35): [Folded, False: 559]
  |  Branch (147:56): [True: 0, Folded]
  |  Branch (147:84): [True: 0, Folded]
  ------------------
  148|       |
  149|    559|      [[maybe_unused]] size_t original_size{};
  150|       |      if constexpr (use_padded) {
  151|       |         // Pad the buffer for SWAR
  152|       |         original_size = buffer.size();
  153|       |         buffer.resize(original_size + padding_bytes);
  154|       |      }
  155|       |
  156|    559|      auto [it, end] = read_iterators<Opts, use_padded>(buffer);
  157|    559|      auto start = it;
  158|    559|      if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (158:11): [True: 0, False: 559]
  ------------------
  159|      0|         goto finish;
  160|      0|      }
  161|       |
  162|       |      // Bound the speculative re-parsing a variant resolution may do, in bytes, relative to this
  163|       |      // input. Seeded per read so a reused context starts fresh. See charge_speculation.
  164|    559|      if constexpr (requires { ctx.speculation_budget; }) {
  165|    559|         const size_t proportional = max_speculative_parse_factor * size_t(end - it);
  166|    559|         ctx.speculation_budget =
  167|    559|            (proportional > min_speculative_parse_bytes ? proportional : min_speculative_parse_bytes) + 2;
  ------------------
  |  Branch (167:14): [True: 0, False: 559]
  ------------------
  168|    559|      }
  169|       |
  170|       |      // A YAML context marks its outermost parse with stream_begin and seeds its expansion budgets
  171|       |      // there, so clearing it here is what makes those budgets per-read like the one above. A
  172|       |      // reused context would otherwise carry a spent budget into the next document and reject a
  173|       |      // valid one, and would leave stream_begin pointing into the buffer of the previous read.
  174|       |      // Nested YAML parses do not route through glz::read, so they still cannot reseed themselves.
  175|       |      if constexpr (requires { ctx.stream_begin; }) {
  176|       |         ctx.stream_begin = nullptr;
  177|       |      }
  178|       |
  179|       |      if constexpr (use_padded) {
  180|       |         parse<Opts.format>::template op<is_padded_on<Opts>()>(value, ctx, it, end);
  181|       |      }
  182|    559|      else {
  183|    559|         parse<Opts.format>::template op<is_padded_off<Opts>()>(value, ctx, it, end);
  184|    559|      }
  185|       |
  186|    559|      if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (186:11): [True: 494, False: 65]
  ------------------
  187|    494|         goto finish;
  188|    494|      }
  189|       |
  190|       |      // The JSON RFC 8259 defines: JSON-text = ws value ws
  191|       |      // So, trailing whitespace is permitted and sometimes we want to
  192|       |      // validate this, even though this memory will not affect Glaze.
  193|       |      if constexpr (check_validate_trailing_whitespace(Opts)) {
  194|       |         if (it < end) {
  195|       |            skip_ws<Opts>(ctx, it, end);
  196|       |            if (bool(ctx.error)) [[unlikely]] {
  197|       |               goto finish;
  198|       |            }
  199|       |            if (it != end) [[unlikely]] {
  200|       |               ctx.error = error_code::syntax_error;
  201|       |            }
  202|       |         }
  203|       |      }
  204|       |
  205|    559|   finish:
  206|    559|      finalize_top_level_read<Opts>(ctx, start, it, end);
  207|       |
  208|       |      if constexpr (use_padded) {
  209|       |         // Restore the original buffer state
  210|       |         buffer.resize(original_size);
  211|       |      }
  212|       |
  213|    559|      return {size_t(it - start), ctx.error, ctx.custom_error_message};
  214|     65|   }
_ZN3glz4readITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz6nestedETkNS_10contiguousERNSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEQaa14read_supportedIT0_XdtT_6formatEEnt18is_input_streamingIT1_EEENS_9error_ctxERSA_OSB_:
  219|  1.56k|   {
  220|  1.56k|      format_context_t<Opts.format> ctx{};
  221|  1.56k|      return read<Opts>(value, buffer, ctx);
  222|  1.56k|   }
_ZN3glz4readITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz6nestedETkNS_10contiguousERNSt3__117basic_string_viewIcNS4_11char_traitsIcEEEETkNS_10is_contextERNS_7contextEQaa14read_supportedIT0_XdtT_6formatEEnt18is_input_streamingIT1_EEENS_9error_ctxERSC_OSD_OT2_:
  136|  1.56k|   {
  137|  1.56k|      static_assert(sizeof(decltype(*buffer.data())) == 1);
  138|  1.56k|      using Buffer = std::remove_reference_t<decltype(buffer)>;
  139|       |
  140|  1.56k|      if constexpr (Opts.format != NDJSON) {
  141|  1.56k|         if (buffer.empty()) [[unlikely]] {
  ------------------
  |  Branch (141:14): [True: 0, False: 1.56k]
  ------------------
  142|      0|            ctx.error = error_code::no_read_input;
  143|      0|            return {0, ctx.error, ctx.custom_error_message};
  144|      0|         }
  145|  1.56k|      }
  146|       |
  147|  1.56k|      constexpr bool use_padded = resizable<Buffer> && non_const_buffer<Buffer> && !check_disable_padding(Opts);
  ------------------
  |  Branch (147:35): [Folded, False: 1.56k]
  |  Branch (147:56): [True: 0, Folded]
  |  Branch (147:84): [True: 0, Folded]
  ------------------
  148|       |
  149|  1.56k|      [[maybe_unused]] size_t original_size{};
  150|       |      if constexpr (use_padded) {
  151|       |         // Pad the buffer for SWAR
  152|       |         original_size = buffer.size();
  153|       |         buffer.resize(original_size + padding_bytes);
  154|       |      }
  155|       |
  156|  1.56k|      auto [it, end] = read_iterators<Opts, use_padded>(buffer);
  157|  1.56k|      auto start = it;
  158|  1.56k|      if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (158:11): [True: 0, False: 1.56k]
  ------------------
  159|      0|         goto finish;
  160|      0|      }
  161|       |
  162|       |      // Bound the speculative re-parsing a variant resolution may do, in bytes, relative to this
  163|       |      // input. Seeded per read so a reused context starts fresh. See charge_speculation.
  164|  1.56k|      if constexpr (requires { ctx.speculation_budget; }) {
  165|  1.56k|         const size_t proportional = max_speculative_parse_factor * size_t(end - it);
  166|  1.56k|         ctx.speculation_budget =
  167|  1.56k|            (proportional > min_speculative_parse_bytes ? proportional : min_speculative_parse_bytes) + 2;
  ------------------
  |  Branch (167:14): [True: 11, False: 1.54k]
  ------------------
  168|  1.56k|      }
  169|       |
  170|       |      // A YAML context marks its outermost parse with stream_begin and seeds its expansion budgets
  171|       |      // there, so clearing it here is what makes those budgets per-read like the one above. A
  172|       |      // reused context would otherwise carry a spent budget into the next document and reject a
  173|       |      // valid one, and would leave stream_begin pointing into the buffer of the previous read.
  174|       |      // Nested YAML parses do not route through glz::read, so they still cannot reseed themselves.
  175|       |      if constexpr (requires { ctx.stream_begin; }) {
  176|       |         ctx.stream_begin = nullptr;
  177|       |      }
  178|       |
  179|       |      if constexpr (use_padded) {
  180|       |         parse<Opts.format>::template op<is_padded_on<Opts>()>(value, ctx, it, end);
  181|       |      }
  182|  1.56k|      else {
  183|  1.56k|         parse<Opts.format>::template op<is_padded_off<Opts>()>(value, ctx, it, end);
  184|  1.56k|      }
  185|       |
  186|  1.56k|      if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (186:11): [True: 1.56k, False: 0]
  ------------------
  187|  1.56k|         goto finish;
  188|  1.56k|      }
  189|       |
  190|       |      // The JSON RFC 8259 defines: JSON-text = ws value ws
  191|       |      // So, trailing whitespace is permitted and sometimes we want to
  192|       |      // validate this, even though this memory will not affect Glaze.
  193|       |      if constexpr (check_validate_trailing_whitespace(Opts)) {
  194|       |         if (it < end) {
  195|       |            skip_ws<Opts>(ctx, it, end);
  196|       |            if (bool(ctx.error)) [[unlikely]] {
  197|       |               goto finish;
  198|       |            }
  199|       |            if (it != end) [[unlikely]] {
  200|       |               ctx.error = error_code::syntax_error;
  201|       |            }
  202|       |         }
  203|       |      }
  204|       |
  205|  1.56k|   finish:
  206|  1.56k|      finalize_top_level_read<Opts>(ctx, start, it, end);
  207|       |
  208|       |      if constexpr (use_padded) {
  209|       |         // Restore the original buffer state
  210|       |         buffer.resize(original_size);
  211|       |      }
  212|       |
  213|  1.56k|      return {size_t(it - start), ctx.error, ctx.custom_error_message};
  214|      0|   }
_ZN3glz4readITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENSt3__16vectorIiNS2_9allocatorIiEEEETkNS_10contiguousERNS2_17basic_string_viewIcNS2_11char_traitsIcEEEEQaa14read_supportedIT0_XdtT_6formatEEnt18is_input_streamingIT1_EEENS_9error_ctxERSC_OSD_:
  219|  1.99k|   {
  220|  1.99k|      format_context_t<Opts.format> ctx{};
  221|  1.99k|      return read<Opts>(value, buffer, ctx);
  222|  1.99k|   }
_ZN3glz4readITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENSt3__16vectorIiNS2_9allocatorIiEEEETkNS_10contiguousERNS2_17basic_string_viewIcNS2_11char_traitsIcEEEETkNS_10is_contextERNS_7contextEQaa14read_supportedIT0_XdtT_6formatEEnt18is_input_streamingIT1_EEENS_9error_ctxERSE_OSF_OT2_:
  136|  1.99k|   {
  137|  1.99k|      static_assert(sizeof(decltype(*buffer.data())) == 1);
  138|  1.99k|      using Buffer = std::remove_reference_t<decltype(buffer)>;
  139|       |
  140|  1.99k|      if constexpr (Opts.format != NDJSON) {
  141|  1.99k|         if (buffer.empty()) [[unlikely]] {
  ------------------
  |  Branch (141:14): [True: 0, False: 1.99k]
  ------------------
  142|      0|            ctx.error = error_code::no_read_input;
  143|      0|            return {0, ctx.error, ctx.custom_error_message};
  144|      0|         }
  145|  1.99k|      }
  146|       |
  147|  1.99k|      constexpr bool use_padded = resizable<Buffer> && non_const_buffer<Buffer> && !check_disable_padding(Opts);
  ------------------
  |  Branch (147:35): [Folded, False: 1.99k]
  |  Branch (147:56): [True: 0, Folded]
  |  Branch (147:84): [True: 0, Folded]
  ------------------
  148|       |
  149|  1.99k|      [[maybe_unused]] size_t original_size{};
  150|       |      if constexpr (use_padded) {
  151|       |         // Pad the buffer for SWAR
  152|       |         original_size = buffer.size();
  153|       |         buffer.resize(original_size + padding_bytes);
  154|       |      }
  155|       |
  156|  1.99k|      auto [it, end] = read_iterators<Opts, use_padded>(buffer);
  157|  1.99k|      auto start = it;
  158|  1.99k|      if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (158:11): [True: 0, False: 1.99k]
  ------------------
  159|      0|         goto finish;
  160|      0|      }
  161|       |
  162|       |      // Bound the speculative re-parsing a variant resolution may do, in bytes, relative to this
  163|       |      // input. Seeded per read so a reused context starts fresh. See charge_speculation.
  164|  1.99k|      if constexpr (requires { ctx.speculation_budget; }) {
  165|  1.99k|         const size_t proportional = max_speculative_parse_factor * size_t(end - it);
  166|  1.99k|         ctx.speculation_budget =
  167|  1.99k|            (proportional > min_speculative_parse_bytes ? proportional : min_speculative_parse_bytes) + 2;
  ------------------
  |  Branch (167:14): [True: 29, False: 1.96k]
  ------------------
  168|  1.99k|      }
  169|       |
  170|       |      // A YAML context marks its outermost parse with stream_begin and seeds its expansion budgets
  171|       |      // there, so clearing it here is what makes those budgets per-read like the one above. A
  172|       |      // reused context would otherwise carry a spent budget into the next document and reject a
  173|       |      // valid one, and would leave stream_begin pointing into the buffer of the previous read.
  174|       |      // Nested YAML parses do not route through glz::read, so they still cannot reseed themselves.
  175|       |      if constexpr (requires { ctx.stream_begin; }) {
  176|       |         ctx.stream_begin = nullptr;
  177|       |      }
  178|       |
  179|       |      if constexpr (use_padded) {
  180|       |         parse<Opts.format>::template op<is_padded_on<Opts>()>(value, ctx, it, end);
  181|       |      }
  182|  1.99k|      else {
  183|  1.99k|         parse<Opts.format>::template op<is_padded_off<Opts>()>(value, ctx, it, end);
  184|  1.99k|      }
  185|       |
  186|  1.99k|      if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (186:11): [True: 1.55k, False: 435]
  ------------------
  187|  1.55k|         goto finish;
  188|  1.55k|      }
  189|       |
  190|       |      // The JSON RFC 8259 defines: JSON-text = ws value ws
  191|       |      // So, trailing whitespace is permitted and sometimes we want to
  192|       |      // validate this, even though this memory will not affect Glaze.
  193|       |      if constexpr (check_validate_trailing_whitespace(Opts)) {
  194|       |         if (it < end) {
  195|       |            skip_ws<Opts>(ctx, it, end);
  196|       |            if (bool(ctx.error)) [[unlikely]] {
  197|       |               goto finish;
  198|       |            }
  199|       |            if (it != end) [[unlikely]] {
  200|       |               ctx.error = error_code::syntax_error;
  201|       |            }
  202|       |         }
  203|       |      }
  204|       |
  205|  1.99k|   finish:
  206|  1.99k|      finalize_top_level_read<Opts>(ctx, start, it, end);
  207|       |
  208|       |      if constexpr (use_padded) {
  209|       |         // Restore the original buffer state
  210|       |         buffer.resize(original_size);
  211|       |      }
  212|       |
  213|  1.99k|      return {size_t(it - start), ctx.error, ctx.custom_error_message};
  214|    435|   }
_ZN3glz4readITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENSt3__13mapINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEiNS2_4lessIS9_EENS7_INS2_4pairIKS9_iEEEEEETkNS_10contiguousERNS2_17basic_string_viewIcS6_EEQaa14read_supportedIT0_XdtT_6formatEEnt18is_input_streamingIT1_EEENS_9error_ctxERSK_OSL_:
  219|  1.84k|   {
  220|  1.84k|      format_context_t<Opts.format> ctx{};
  221|  1.84k|      return read<Opts>(value, buffer, ctx);
  222|  1.84k|   }
_ZN3glz4readITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENSt3__13mapINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEiNS2_4lessIS9_EENS7_INS2_4pairIKS9_iEEEEEETkNS_10contiguousERNS2_17basic_string_viewIcS6_EETkNS_10is_contextERNS_7contextEQaa14read_supportedIT0_XdtT_6formatEEnt18is_input_streamingIT1_EEENS_9error_ctxERSM_OSN_OT2_:
  136|  1.84k|   {
  137|  1.84k|      static_assert(sizeof(decltype(*buffer.data())) == 1);
  138|  1.84k|      using Buffer = std::remove_reference_t<decltype(buffer)>;
  139|       |
  140|  1.84k|      if constexpr (Opts.format != NDJSON) {
  141|  1.84k|         if (buffer.empty()) [[unlikely]] {
  ------------------
  |  Branch (141:14): [True: 0, False: 1.84k]
  ------------------
  142|      0|            ctx.error = error_code::no_read_input;
  143|      0|            return {0, ctx.error, ctx.custom_error_message};
  144|      0|         }
  145|  1.84k|      }
  146|       |
  147|  1.84k|      constexpr bool use_padded = resizable<Buffer> && non_const_buffer<Buffer> && !check_disable_padding(Opts);
  ------------------
  |  Branch (147:35): [Folded, False: 1.84k]
  |  Branch (147:56): [True: 0, Folded]
  |  Branch (147:84): [True: 0, Folded]
  ------------------
  148|       |
  149|  1.84k|      [[maybe_unused]] size_t original_size{};
  150|       |      if constexpr (use_padded) {
  151|       |         // Pad the buffer for SWAR
  152|       |         original_size = buffer.size();
  153|       |         buffer.resize(original_size + padding_bytes);
  154|       |      }
  155|       |
  156|  1.84k|      auto [it, end] = read_iterators<Opts, use_padded>(buffer);
  157|  1.84k|      auto start = it;
  158|  1.84k|      if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (158:11): [True: 0, False: 1.84k]
  ------------------
  159|      0|         goto finish;
  160|      0|      }
  161|       |
  162|       |      // Bound the speculative re-parsing a variant resolution may do, in bytes, relative to this
  163|       |      // input. Seeded per read so a reused context starts fresh. See charge_speculation.
  164|  1.84k|      if constexpr (requires { ctx.speculation_budget; }) {
  165|  1.84k|         const size_t proportional = max_speculative_parse_factor * size_t(end - it);
  166|  1.84k|         ctx.speculation_budget =
  167|  1.84k|            (proportional > min_speculative_parse_bytes ? proportional : min_speculative_parse_bytes) + 2;
  ------------------
  |  Branch (167:14): [True: 20, False: 1.82k]
  ------------------
  168|  1.84k|      }
  169|       |
  170|       |      // A YAML context marks its outermost parse with stream_begin and seeds its expansion budgets
  171|       |      // there, so clearing it here is what makes those budgets per-read like the one above. A
  172|       |      // reused context would otherwise carry a spent budget into the next document and reject a
  173|       |      // valid one, and would leave stream_begin pointing into the buffer of the previous read.
  174|       |      // Nested YAML parses do not route through glz::read, so they still cannot reseed themselves.
  175|       |      if constexpr (requires { ctx.stream_begin; }) {
  176|       |         ctx.stream_begin = nullptr;
  177|       |      }
  178|       |
  179|       |      if constexpr (use_padded) {
  180|       |         parse<Opts.format>::template op<is_padded_on<Opts>()>(value, ctx, it, end);
  181|       |      }
  182|  1.84k|      else {
  183|  1.84k|         parse<Opts.format>::template op<is_padded_off<Opts>()>(value, ctx, it, end);
  184|  1.84k|      }
  185|       |
  186|  1.84k|      if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (186:11): [True: 1.84k, False: 0]
  ------------------
  187|  1.84k|         goto finish;
  188|  1.84k|      }
  189|       |
  190|       |      // The JSON RFC 8259 defines: JSON-text = ws value ws
  191|       |      // So, trailing whitespace is permitted and sometimes we want to
  192|       |      // validate this, even though this memory will not affect Glaze.
  193|       |      if constexpr (check_validate_trailing_whitespace(Opts)) {
  194|       |         if (it < end) {
  195|       |            skip_ws<Opts>(ctx, it, end);
  196|       |            if (bool(ctx.error)) [[unlikely]] {
  197|       |               goto finish;
  198|       |            }
  199|       |            if (it != end) [[unlikely]] {
  200|       |               ctx.error = error_code::syntax_error;
  201|       |            }
  202|       |         }
  203|       |      }
  204|       |
  205|  1.84k|   finish:
  206|  1.84k|      finalize_top_level_read<Opts>(ctx, start, it, end);
  207|       |
  208|       |      if constexpr (use_padded) {
  209|       |         // Restore the original buffer state
  210|       |         buffer.resize(original_size);
  211|       |      }
  212|       |
  213|  1.84k|      return {size_t(it - start), ctx.error, ctx.custom_error_message};
  214|      0|   }
_ZN3glz4readITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENSt3__18optionalIdEETkNS_10contiguousERNS2_17basic_string_viewIcNS2_11char_traitsIcEEEEQaa14read_supportedIT0_XdtT_6formatEEnt18is_input_streamingIT1_EEENS_9error_ctxERSA_OSB_:
  219|  2.00k|   {
  220|  2.00k|      format_context_t<Opts.format> ctx{};
  221|  2.00k|      return read<Opts>(value, buffer, ctx);
  222|  2.00k|   }
_ZN3glz4readITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENSt3__18optionalIdEETkNS_10contiguousERNS2_17basic_string_viewIcNS2_11char_traitsIcEEEETkNS_10is_contextERNS_7contextEQaa14read_supportedIT0_XdtT_6formatEEnt18is_input_streamingIT1_EEENS_9error_ctxERSC_OSD_OT2_:
  136|  2.00k|   {
  137|  2.00k|      static_assert(sizeof(decltype(*buffer.data())) == 1);
  138|  2.00k|      using Buffer = std::remove_reference_t<decltype(buffer)>;
  139|       |
  140|  2.00k|      if constexpr (Opts.format != NDJSON) {
  141|  2.00k|         if (buffer.empty()) [[unlikely]] {
  ------------------
  |  Branch (141:14): [True: 0, False: 2.00k]
  ------------------
  142|      0|            ctx.error = error_code::no_read_input;
  143|      0|            return {0, ctx.error, ctx.custom_error_message};
  144|      0|         }
  145|  2.00k|      }
  146|       |
  147|  2.00k|      constexpr bool use_padded = resizable<Buffer> && non_const_buffer<Buffer> && !check_disable_padding(Opts);
  ------------------
  |  Branch (147:35): [Folded, False: 2.00k]
  |  Branch (147:56): [True: 0, Folded]
  |  Branch (147:84): [True: 0, Folded]
  ------------------
  148|       |
  149|  2.00k|      [[maybe_unused]] size_t original_size{};
  150|       |      if constexpr (use_padded) {
  151|       |         // Pad the buffer for SWAR
  152|       |         original_size = buffer.size();
  153|       |         buffer.resize(original_size + padding_bytes);
  154|       |      }
  155|       |
  156|  2.00k|      auto [it, end] = read_iterators<Opts, use_padded>(buffer);
  157|  2.00k|      auto start = it;
  158|  2.00k|      if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (158:11): [True: 0, False: 2.00k]
  ------------------
  159|      0|         goto finish;
  160|      0|      }
  161|       |
  162|       |      // Bound the speculative re-parsing a variant resolution may do, in bytes, relative to this
  163|       |      // input. Seeded per read so a reused context starts fresh. See charge_speculation.
  164|  2.00k|      if constexpr (requires { ctx.speculation_budget; }) {
  165|  2.00k|         const size_t proportional = max_speculative_parse_factor * size_t(end - it);
  166|  2.00k|         ctx.speculation_budget =
  167|  2.00k|            (proportional > min_speculative_parse_bytes ? proportional : min_speculative_parse_bytes) + 2;
  ------------------
  |  Branch (167:14): [True: 22, False: 1.98k]
  ------------------
  168|  2.00k|      }
  169|       |
  170|       |      // A YAML context marks its outermost parse with stream_begin and seeds its expansion budgets
  171|       |      // there, so clearing it here is what makes those budgets per-read like the one above. A
  172|       |      // reused context would otherwise carry a spent budget into the next document and reject a
  173|       |      // valid one, and would leave stream_begin pointing into the buffer of the previous read.
  174|       |      // Nested YAML parses do not route through glz::read, so they still cannot reseed themselves.
  175|       |      if constexpr (requires { ctx.stream_begin; }) {
  176|       |         ctx.stream_begin = nullptr;
  177|       |      }
  178|       |
  179|       |      if constexpr (use_padded) {
  180|       |         parse<Opts.format>::template op<is_padded_on<Opts>()>(value, ctx, it, end);
  181|       |      }
  182|  2.00k|      else {
  183|  2.00k|         parse<Opts.format>::template op<is_padded_off<Opts>()>(value, ctx, it, end);
  184|  2.00k|      }
  185|       |
  186|  2.00k|      if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (186:11): [True: 1.76k, False: 246]
  ------------------
  187|  1.76k|         goto finish;
  188|  1.76k|      }
  189|       |
  190|       |      // The JSON RFC 8259 defines: JSON-text = ws value ws
  191|       |      // So, trailing whitespace is permitted and sometimes we want to
  192|       |      // validate this, even though this memory will not affect Glaze.
  193|       |      if constexpr (check_validate_trailing_whitespace(Opts)) {
  194|       |         if (it < end) {
  195|       |            skip_ws<Opts>(ctx, it, end);
  196|       |            if (bool(ctx.error)) [[unlikely]] {
  197|       |               goto finish;
  198|       |            }
  199|       |            if (it != end) [[unlikely]] {
  200|       |               ctx.error = error_code::syntax_error;
  201|       |            }
  202|       |         }
  203|       |      }
  204|       |
  205|  2.00k|   finish:
  206|  2.00k|      finalize_top_level_read<Opts>(ctx, start, it, end);
  207|       |
  208|       |      if constexpr (use_padded) {
  209|       |         // Restore the original buffer state
  210|       |         buffer.resize(original_size);
  211|       |      }
  212|       |
  213|  2.00k|      return {size_t(it - start), ctx.error, ctx.custom_error_message};
  214|    246|   }
_ZN3glz4readITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENSt3__17variantIJNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEN12jsonrpc_fuzz6amountEEEETkNS_10contiguousERNS2_17basic_string_viewIcS6_EEQaa14read_supportedIT0_XdtT_6formatEEnt18is_input_streamingIT1_EEENS_9error_ctxERSG_OSH_:
  219|  1.09k|   {
  220|  1.09k|      format_context_t<Opts.format> ctx{};
  221|  1.09k|      return read<Opts>(value, buffer, ctx);
  222|  1.09k|   }
_ZN3glz4readITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENSt3__17variantIJNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEN12jsonrpc_fuzz6amountEEEETkNS_10contiguousERNS2_17basic_string_viewIcS6_EETkNS_10is_contextERNS_7contextEQaa14read_supportedIT0_XdtT_6formatEEnt18is_input_streamingIT1_EEENS_9error_ctxERSI_OSJ_OT2_:
  136|  1.09k|   {
  137|  1.09k|      static_assert(sizeof(decltype(*buffer.data())) == 1);
  138|  1.09k|      using Buffer = std::remove_reference_t<decltype(buffer)>;
  139|       |
  140|  1.09k|      if constexpr (Opts.format != NDJSON) {
  141|  1.09k|         if (buffer.empty()) [[unlikely]] {
  ------------------
  |  Branch (141:14): [True: 0, False: 1.09k]
  ------------------
  142|      0|            ctx.error = error_code::no_read_input;
  143|      0|            return {0, ctx.error, ctx.custom_error_message};
  144|      0|         }
  145|  1.09k|      }
  146|       |
  147|  1.09k|      constexpr bool use_padded = resizable<Buffer> && non_const_buffer<Buffer> && !check_disable_padding(Opts);
  ------------------
  |  Branch (147:35): [Folded, False: 1.09k]
  |  Branch (147:56): [True: 0, Folded]
  |  Branch (147:84): [True: 0, Folded]
  ------------------
  148|       |
  149|  1.09k|      [[maybe_unused]] size_t original_size{};
  150|       |      if constexpr (use_padded) {
  151|       |         // Pad the buffer for SWAR
  152|       |         original_size = buffer.size();
  153|       |         buffer.resize(original_size + padding_bytes);
  154|       |      }
  155|       |
  156|  1.09k|      auto [it, end] = read_iterators<Opts, use_padded>(buffer);
  157|  1.09k|      auto start = it;
  158|  1.09k|      if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (158:11): [True: 0, False: 1.09k]
  ------------------
  159|      0|         goto finish;
  160|      0|      }
  161|       |
  162|       |      // Bound the speculative re-parsing a variant resolution may do, in bytes, relative to this
  163|       |      // input. Seeded per read so a reused context starts fresh. See charge_speculation.
  164|  1.09k|      if constexpr (requires { ctx.speculation_budget; }) {
  165|  1.09k|         const size_t proportional = max_speculative_parse_factor * size_t(end - it);
  166|  1.09k|         ctx.speculation_budget =
  167|  1.09k|            (proportional > min_speculative_parse_bytes ? proportional : min_speculative_parse_bytes) + 2;
  ------------------
  |  Branch (167:14): [True: 25, False: 1.07k]
  ------------------
  168|  1.09k|      }
  169|       |
  170|       |      // A YAML context marks its outermost parse with stream_begin and seeds its expansion budgets
  171|       |      // there, so clearing it here is what makes those budgets per-read like the one above. A
  172|       |      // reused context would otherwise carry a spent budget into the next document and reject a
  173|       |      // valid one, and would leave stream_begin pointing into the buffer of the previous read.
  174|       |      // Nested YAML parses do not route through glz::read, so they still cannot reseed themselves.
  175|       |      if constexpr (requires { ctx.stream_begin; }) {
  176|       |         ctx.stream_begin = nullptr;
  177|       |      }
  178|       |
  179|       |      if constexpr (use_padded) {
  180|       |         parse<Opts.format>::template op<is_padded_on<Opts>()>(value, ctx, it, end);
  181|       |      }
  182|  1.09k|      else {
  183|  1.09k|         parse<Opts.format>::template op<is_padded_off<Opts>()>(value, ctx, it, end);
  184|  1.09k|      }
  185|       |
  186|  1.09k|      if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (186:11): [True: 740, False: 355]
  ------------------
  187|    740|         goto finish;
  188|    740|      }
  189|       |
  190|       |      // The JSON RFC 8259 defines: JSON-text = ws value ws
  191|       |      // So, trailing whitespace is permitted and sometimes we want to
  192|       |      // validate this, even though this memory will not affect Glaze.
  193|       |      if constexpr (check_validate_trailing_whitespace(Opts)) {
  194|       |         if (it < end) {
  195|       |            skip_ws<Opts>(ctx, it, end);
  196|       |            if (bool(ctx.error)) [[unlikely]] {
  197|       |               goto finish;
  198|       |            }
  199|       |            if (it != end) [[unlikely]] {
  200|       |               ctx.error = error_code::syntax_error;
  201|       |            }
  202|       |         }
  203|       |      }
  204|       |
  205|  1.09k|   finish:
  206|  1.09k|      finalize_top_level_read<Opts>(ctx, start, it, end);
  207|       |
  208|       |      if constexpr (use_padded) {
  209|       |         // Restore the original buffer state
  210|       |         buffer.resize(original_size);
  211|       |      }
  212|       |
  213|  1.09k|      return {size_t(it - start), ctx.error, ctx.custom_error_message};
  214|    355|   }
_ZN3glz4readITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENSt3__16vectorIdNS2_9allocatorIdEEEETkNS_10contiguousERNS2_17basic_string_viewIcNS2_11char_traitsIcEEEEQaa14read_supportedIT0_XdtT_6formatEEnt18is_input_streamingIT1_EEENS_9error_ctxERSC_OSD_:
  219|  3.87k|   {
  220|  3.87k|      format_context_t<Opts.format> ctx{};
  221|  3.87k|      return read<Opts>(value, buffer, ctx);
  222|  3.87k|   }
_ZN3glz4readITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENSt3__16vectorIdNS2_9allocatorIdEEEETkNS_10contiguousERNS2_17basic_string_viewIcNS2_11char_traitsIcEEEETkNS_10is_contextERNS_7contextEQaa14read_supportedIT0_XdtT_6formatEEnt18is_input_streamingIT1_EEENS_9error_ctxERSE_OSF_OT2_:
  136|  3.87k|   {
  137|  3.87k|      static_assert(sizeof(decltype(*buffer.data())) == 1);
  138|  3.87k|      using Buffer = std::remove_reference_t<decltype(buffer)>;
  139|       |
  140|  3.87k|      if constexpr (Opts.format != NDJSON) {
  141|  3.87k|         if (buffer.empty()) [[unlikely]] {
  ------------------
  |  Branch (141:14): [True: 0, False: 3.87k]
  ------------------
  142|      0|            ctx.error = error_code::no_read_input;
  143|      0|            return {0, ctx.error, ctx.custom_error_message};
  144|      0|         }
  145|  3.87k|      }
  146|       |
  147|  3.87k|      constexpr bool use_padded = resizable<Buffer> && non_const_buffer<Buffer> && !check_disable_padding(Opts);
  ------------------
  |  Branch (147:35): [Folded, False: 3.87k]
  |  Branch (147:56): [True: 0, Folded]
  |  Branch (147:84): [True: 0, Folded]
  ------------------
  148|       |
  149|  3.87k|      [[maybe_unused]] size_t original_size{};
  150|       |      if constexpr (use_padded) {
  151|       |         // Pad the buffer for SWAR
  152|       |         original_size = buffer.size();
  153|       |         buffer.resize(original_size + padding_bytes);
  154|       |      }
  155|       |
  156|  3.87k|      auto [it, end] = read_iterators<Opts, use_padded>(buffer);
  157|  3.87k|      auto start = it;
  158|  3.87k|      if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (158:11): [True: 0, False: 3.87k]
  ------------------
  159|      0|         goto finish;
  160|      0|      }
  161|       |
  162|       |      // Bound the speculative re-parsing a variant resolution may do, in bytes, relative to this
  163|       |      // input. Seeded per read so a reused context starts fresh. See charge_speculation.
  164|  3.87k|      if constexpr (requires { ctx.speculation_budget; }) {
  165|  3.87k|         const size_t proportional = max_speculative_parse_factor * size_t(end - it);
  166|  3.87k|         ctx.speculation_budget =
  167|  3.87k|            (proportional > min_speculative_parse_bytes ? proportional : min_speculative_parse_bytes) + 2;
  ------------------
  |  Branch (167:14): [True: 42, False: 3.83k]
  ------------------
  168|  3.87k|      }
  169|       |
  170|       |      // A YAML context marks its outermost parse with stream_begin and seeds its expansion budgets
  171|       |      // there, so clearing it here is what makes those budgets per-read like the one above. A
  172|       |      // reused context would otherwise carry a spent budget into the next document and reject a
  173|       |      // valid one, and would leave stream_begin pointing into the buffer of the previous read.
  174|       |      // Nested YAML parses do not route through glz::read, so they still cannot reseed themselves.
  175|       |      if constexpr (requires { ctx.stream_begin; }) {
  176|       |         ctx.stream_begin = nullptr;
  177|       |      }
  178|       |
  179|       |      if constexpr (use_padded) {
  180|       |         parse<Opts.format>::template op<is_padded_on<Opts>()>(value, ctx, it, end);
  181|       |      }
  182|  3.87k|      else {
  183|  3.87k|         parse<Opts.format>::template op<is_padded_off<Opts>()>(value, ctx, it, end);
  184|  3.87k|      }
  185|       |
  186|  3.87k|      if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (186:11): [True: 2.12k, False: 1.74k]
  ------------------
  187|  2.12k|         goto finish;
  188|  2.12k|      }
  189|       |
  190|       |      // The JSON RFC 8259 defines: JSON-text = ws value ws
  191|       |      // So, trailing whitespace is permitted and sometimes we want to
  192|       |      // validate this, even though this memory will not affect Glaze.
  193|       |      if constexpr (check_validate_trailing_whitespace(Opts)) {
  194|       |         if (it < end) {
  195|       |            skip_ws<Opts>(ctx, it, end);
  196|       |            if (bool(ctx.error)) [[unlikely]] {
  197|       |               goto finish;
  198|       |            }
  199|       |            if (it != end) [[unlikely]] {
  200|       |               ctx.error = error_code::syntax_error;
  201|       |            }
  202|       |         }
  203|       |      }
  204|       |
  205|  3.87k|   finish:
  206|  3.87k|      finalize_top_level_read<Opts>(ctx, start, it, end);
  207|       |
  208|       |      if constexpr (use_padded) {
  209|       |         // Restore the original buffer state
  210|       |         buffer.resize(original_size);
  211|       |      }
  212|       |
  213|  3.87k|      return {size_t(it - start), ctx.error, ctx.custom_error_message};
  214|  1.74k|   }
_ZN3glz4readITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENSt3__16vectorINS_14basic_raw_jsonINS2_17basic_string_viewIcNS2_11char_traitsIcEEEEEENS2_9allocatorIS9_EEEETkNS_10contiguousERS8_Qaa14read_supportedIT0_XdtT_6formatEEnt18is_input_streamingIT1_EEENS_9error_ctxERSE_OSF_:
  219|  23.4k|   {
  220|  23.4k|      format_context_t<Opts.format> ctx{};
  221|  23.4k|      return read<Opts>(value, buffer, ctx);
  222|  23.4k|   }
_ZN3glz4readITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENSt3__16vectorINS_14basic_raw_jsonINS2_17basic_string_viewIcNS2_11char_traitsIcEEEEEENS2_9allocatorIS9_EEEETkNS_10contiguousERS8_TkNS_10is_contextERNS_7contextEQaa14read_supportedIT0_XdtT_6formatEEnt18is_input_streamingIT1_EEENS_9error_ctxERSG_OSH_OT2_:
  136|  23.4k|   {
  137|  23.4k|      static_assert(sizeof(decltype(*buffer.data())) == 1);
  138|  23.4k|      using Buffer = std::remove_reference_t<decltype(buffer)>;
  139|       |
  140|  23.4k|      if constexpr (Opts.format != NDJSON) {
  141|  23.4k|         if (buffer.empty()) [[unlikely]] {
  ------------------
  |  Branch (141:14): [True: 0, False: 23.4k]
  ------------------
  142|      0|            ctx.error = error_code::no_read_input;
  143|      0|            return {0, ctx.error, ctx.custom_error_message};
  144|      0|         }
  145|  23.4k|      }
  146|       |
  147|  23.4k|      constexpr bool use_padded = resizable<Buffer> && non_const_buffer<Buffer> && !check_disable_padding(Opts);
  ------------------
  |  Branch (147:35): [Folded, False: 23.4k]
  |  Branch (147:56): [True: 0, Folded]
  |  Branch (147:84): [True: 0, Folded]
  ------------------
  148|       |
  149|  23.4k|      [[maybe_unused]] size_t original_size{};
  150|       |      if constexpr (use_padded) {
  151|       |         // Pad the buffer for SWAR
  152|       |         original_size = buffer.size();
  153|       |         buffer.resize(original_size + padding_bytes);
  154|       |      }
  155|       |
  156|  23.4k|      auto [it, end] = read_iterators<Opts, use_padded>(buffer);
  157|  23.4k|      auto start = it;
  158|  23.4k|      if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (158:11): [True: 0, False: 23.4k]
  ------------------
  159|      0|         goto finish;
  160|      0|      }
  161|       |
  162|       |      // Bound the speculative re-parsing a variant resolution may do, in bytes, relative to this
  163|       |      // input. Seeded per read so a reused context starts fresh. See charge_speculation.
  164|  23.4k|      if constexpr (requires { ctx.speculation_budget; }) {
  165|  23.4k|         const size_t proportional = max_speculative_parse_factor * size_t(end - it);
  166|  23.4k|         ctx.speculation_budget =
  167|  23.4k|            (proportional > min_speculative_parse_bytes ? proportional : min_speculative_parse_bytes) + 2;
  ------------------
  |  Branch (167:14): [True: 515, False: 22.9k]
  ------------------
  168|  23.4k|      }
  169|       |
  170|       |      // A YAML context marks its outermost parse with stream_begin and seeds its expansion budgets
  171|       |      // there, so clearing it here is what makes those budgets per-read like the one above. A
  172|       |      // reused context would otherwise carry a spent budget into the next document and reject a
  173|       |      // valid one, and would leave stream_begin pointing into the buffer of the previous read.
  174|       |      // Nested YAML parses do not route through glz::read, so they still cannot reseed themselves.
  175|       |      if constexpr (requires { ctx.stream_begin; }) {
  176|       |         ctx.stream_begin = nullptr;
  177|       |      }
  178|       |
  179|       |      if constexpr (use_padded) {
  180|       |         parse<Opts.format>::template op<is_padded_on<Opts>()>(value, ctx, it, end);
  181|       |      }
  182|  23.4k|      else {
  183|  23.4k|         parse<Opts.format>::template op<is_padded_off<Opts>()>(value, ctx, it, end);
  184|  23.4k|      }
  185|       |
  186|  23.4k|      if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (186:11): [True: 6.75k, False: 16.6k]
  ------------------
  187|  6.75k|         goto finish;
  188|  6.75k|      }
  189|       |
  190|       |      // The JSON RFC 8259 defines: JSON-text = ws value ws
  191|       |      // So, trailing whitespace is permitted and sometimes we want to
  192|       |      // validate this, even though this memory will not affect Glaze.
  193|       |      if constexpr (check_validate_trailing_whitespace(Opts)) {
  194|       |         if (it < end) {
  195|       |            skip_ws<Opts>(ctx, it, end);
  196|       |            if (bool(ctx.error)) [[unlikely]] {
  197|       |               goto finish;
  198|       |            }
  199|       |            if (it != end) [[unlikely]] {
  200|       |               ctx.error = error_code::syntax_error;
  201|       |            }
  202|       |         }
  203|       |      }
  204|       |
  205|  23.4k|   finish:
  206|  23.4k|      finalize_top_level_read<Opts>(ctx, start, it, end);
  207|       |
  208|       |      if constexpr (use_padded) {
  209|       |         // Restore the original buffer state
  210|       |         buffer.resize(original_size);
  211|       |      }
  212|       |
  213|  23.4k|      return {size_t(it - start), ctx.error, ctx.custom_error_message};
  214|  16.6k|   }
_ZN3glz4readITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENS_3rpc18request_envelope_tETkNS_10contiguousERNSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEQaa14read_supportedIT0_XdtT_6formatEEnt18is_input_streamingIT1_EEENS_9error_ctxERSA_OSB_:
  219|  4.15M|   {
  220|  4.15M|      format_context_t<Opts.format> ctx{};
  221|  4.15M|      return read<Opts>(value, buffer, ctx);
  222|  4.15M|   }
_ZN3glz4readITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENS_3rpc18request_envelope_tETkNS_10contiguousERNSt3__117basic_string_viewIcNS4_11char_traitsIcEEEETkNS_10is_contextERNS_7contextEQaa14read_supportedIT0_XdtT_6formatEEnt18is_input_streamingIT1_EEENS_9error_ctxERSC_OSD_OT2_:
  136|  4.15M|   {
  137|  4.15M|      static_assert(sizeof(decltype(*buffer.data())) == 1);
  138|  4.15M|      using Buffer = std::remove_reference_t<decltype(buffer)>;
  139|       |
  140|  4.15M|      if constexpr (Opts.format != NDJSON) {
  141|  4.15M|         if (buffer.empty()) [[unlikely]] {
  ------------------
  |  Branch (141:14): [True: 3.72M, False: 428k]
  ------------------
  142|  3.72M|            ctx.error = error_code::no_read_input;
  143|  3.72M|            return {0, ctx.error, ctx.custom_error_message};
  144|  3.72M|         }
  145|  4.15M|      }
  146|       |
  147|  4.15M|      constexpr bool use_padded = resizable<Buffer> && non_const_buffer<Buffer> && !check_disable_padding(Opts);
  ------------------
  |  Branch (147:35): [Folded, False: 4.15M]
  |  Branch (147:56): [True: 0, Folded]
  |  Branch (147:84): [True: 0, Folded]
  ------------------
  148|       |
  149|  4.15M|      [[maybe_unused]] size_t original_size{};
  150|       |      if constexpr (use_padded) {
  151|       |         // Pad the buffer for SWAR
  152|       |         original_size = buffer.size();
  153|       |         buffer.resize(original_size + padding_bytes);
  154|       |      }
  155|       |
  156|  4.15M|      auto [it, end] = read_iterators<Opts, use_padded>(buffer);
  157|  4.15M|      auto start = it;
  158|  4.15M|      if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (158:11): [True: 0, False: 4.15M]
  ------------------
  159|      0|         goto finish;
  160|      0|      }
  161|       |
  162|       |      // Bound the speculative re-parsing a variant resolution may do, in bytes, relative to this
  163|       |      // input. Seeded per read so a reused context starts fresh. See charge_speculation.
  164|  4.15M|      if constexpr (requires { ctx.speculation_budget; }) {
  165|  4.15M|         const size_t proportional = max_speculative_parse_factor * size_t(end - it);
  166|  4.15M|         ctx.speculation_budget =
  167|  4.15M|            (proportional > min_speculative_parse_bytes ? proportional : min_speculative_parse_bytes) + 2;
  ------------------
  |  Branch (167:14): [True: 979, False: 4.15M]
  ------------------
  168|  4.15M|      }
  169|       |
  170|       |      // A YAML context marks its outermost parse with stream_begin and seeds its expansion budgets
  171|       |      // there, so clearing it here is what makes those budgets per-read like the one above. A
  172|       |      // reused context would otherwise carry a spent budget into the next document and reject a
  173|       |      // valid one, and would leave stream_begin pointing into the buffer of the previous read.
  174|       |      // Nested YAML parses do not route through glz::read, so they still cannot reseed themselves.
  175|       |      if constexpr (requires { ctx.stream_begin; }) {
  176|       |         ctx.stream_begin = nullptr;
  177|       |      }
  178|       |
  179|       |      if constexpr (use_padded) {
  180|       |         parse<Opts.format>::template op<is_padded_on<Opts>()>(value, ctx, it, end);
  181|       |      }
  182|  4.15M|      else {
  183|  4.15M|         parse<Opts.format>::template op<is_padded_off<Opts>()>(value, ctx, it, end);
  184|  4.15M|      }
  185|       |
  186|  4.15M|      if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (186:11): [True: 424k, False: 3.73M]
  ------------------
  187|   424k|         goto finish;
  188|   424k|      }
  189|       |
  190|       |      // The JSON RFC 8259 defines: JSON-text = ws value ws
  191|       |      // So, trailing whitespace is permitted and sometimes we want to
  192|       |      // validate this, even though this memory will not affect Glaze.
  193|       |      if constexpr (check_validate_trailing_whitespace(Opts)) {
  194|       |         if (it < end) {
  195|       |            skip_ws<Opts>(ctx, it, end);
  196|       |            if (bool(ctx.error)) [[unlikely]] {
  197|       |               goto finish;
  198|       |            }
  199|       |            if (it != end) [[unlikely]] {
  200|       |               ctx.error = error_code::syntax_error;
  201|       |            }
  202|       |         }
  203|       |      }
  204|       |
  205|  3.73M|   finish:
  206|   428k|      finalize_top_level_read<Opts>(ctx, start, it, end);
  207|       |
  208|       |      if constexpr (use_padded) {
  209|       |         // Restore the original buffer state
  210|       |         buffer.resize(original_size);
  211|       |      }
  212|       |
  213|   428k|      return {size_t(it - start), ctx.error, ctx.custom_error_message};
  214|  3.73M|   }
_ZN3glz4readITnDaXtlNS_22registry_validate_optsIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEEEtlS2_Lj10ELb0ELb0ELb1ELb1EELb1ELb1EEENS_4skipETkNS_10contiguousERNSt3__117basic_string_viewIcNS5_11char_traitsIcEEEETkNS_10is_contextERNS_7contextEQaa14read_supportedIT0_XdtT_6formatEEnt18is_input_streamingIT1_EEENS_9error_ctxERSD_OSE_OT2_:
  136|  4.09M|   {
  137|  4.09M|      static_assert(sizeof(decltype(*buffer.data())) == 1);
  138|  4.09M|      using Buffer = std::remove_reference_t<decltype(buffer)>;
  139|       |
  140|  4.09M|      if constexpr (Opts.format != NDJSON) {
  141|  4.09M|         if (buffer.empty()) [[unlikely]] {
  ------------------
  |  Branch (141:14): [True: 3.72M, False: 364k]
  ------------------
  142|  3.72M|            ctx.error = error_code::no_read_input;
  143|  3.72M|            return {0, ctx.error, ctx.custom_error_message};
  144|  3.72M|         }
  145|  4.09M|      }
  146|       |
  147|  4.09M|      constexpr bool use_padded = resizable<Buffer> && non_const_buffer<Buffer> && !check_disable_padding(Opts);
  ------------------
  |  Branch (147:35): [Folded, False: 4.09M]
  |  Branch (147:56): [True: 0, Folded]
  |  Branch (147:84): [True: 0, Folded]
  ------------------
  148|       |
  149|  4.09M|      [[maybe_unused]] size_t original_size{};
  150|       |      if constexpr (use_padded) {
  151|       |         // Pad the buffer for SWAR
  152|       |         original_size = buffer.size();
  153|       |         buffer.resize(original_size + padding_bytes);
  154|       |      }
  155|       |
  156|  4.09M|      auto [it, end] = read_iterators<Opts, use_padded>(buffer);
  157|  4.09M|      auto start = it;
  158|  4.09M|      if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (158:11): [True: 0, False: 4.09M]
  ------------------
  159|      0|         goto finish;
  160|      0|      }
  161|       |
  162|       |      // Bound the speculative re-parsing a variant resolution may do, in bytes, relative to this
  163|       |      // input. Seeded per read so a reused context starts fresh. See charge_speculation.
  164|  4.09M|      if constexpr (requires { ctx.speculation_budget; }) {
  165|  4.09M|         const size_t proportional = max_speculative_parse_factor * size_t(end - it);
  166|  4.09M|         ctx.speculation_budget =
  167|  4.09M|            (proportional > min_speculative_parse_bytes ? proportional : min_speculative_parse_bytes) + 2;
  ------------------
  |  Branch (167:14): [True: 560, False: 4.09M]
  ------------------
  168|  4.09M|      }
  169|       |
  170|       |      // A YAML context marks its outermost parse with stream_begin and seeds its expansion budgets
  171|       |      // there, so clearing it here is what makes those budgets per-read like the one above. A
  172|       |      // reused context would otherwise carry a spent budget into the next document and reject a
  173|       |      // valid one, and would leave stream_begin pointing into the buffer of the previous read.
  174|       |      // Nested YAML parses do not route through glz::read, so they still cannot reseed themselves.
  175|       |      if constexpr (requires { ctx.stream_begin; }) {
  176|       |         ctx.stream_begin = nullptr;
  177|       |      }
  178|       |
  179|       |      if constexpr (use_padded) {
  180|       |         parse<Opts.format>::template op<is_padded_on<Opts>()>(value, ctx, it, end);
  181|       |      }
  182|  4.09M|      else {
  183|  4.09M|         parse<Opts.format>::template op<is_padded_off<Opts>()>(value, ctx, it, end);
  184|  4.09M|      }
  185|       |
  186|  4.09M|      if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (186:11): [True: 266k, False: 3.82M]
  ------------------
  187|   266k|         goto finish;
  188|   266k|      }
  189|       |
  190|       |      // The JSON RFC 8259 defines: JSON-text = ws value ws
  191|       |      // So, trailing whitespace is permitted and sometimes we want to
  192|       |      // validate this, even though this memory will not affect Glaze.
  193|  3.82M|      if constexpr (check_validate_trailing_whitespace(Opts)) {
  194|  3.82M|         if (it < end) {
  ------------------
  |  Branch (194:14): [True: 4.16k, False: 3.82M]
  ------------------
  195|  4.16k|            skip_ws<Opts>(ctx, it, end);
  196|  4.16k|            if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (196:17): [True: 276, False: 3.88k]
  ------------------
  197|    276|               goto finish;
  198|    276|            }
  199|  3.88k|            if (it != end) [[unlikely]] {
  ------------------
  |  Branch (199:17): [True: 3.88k, False: 0]
  ------------------
  200|  3.88k|               ctx.error = error_code::syntax_error;
  201|  3.88k|            }
  202|  3.88k|         }
  203|  3.82M|      }
  204|       |
  205|  3.82M|   finish:
  206|   364k|      finalize_top_level_read<Opts>(ctx, start, it, end);
  207|       |
  208|       |      if constexpr (use_padded) {
  209|       |         // Restore the original buffer state
  210|       |         buffer.resize(original_size);
  211|       |      }
  212|       |
  213|   364k|      return {size_t(it - start), ctx.error, ctx.custom_error_message};
  214|  3.82M|   }
_ZN3glz14read_iteratorsITnDaXtlNS_22registry_validate_optsIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEEEtlS2_Lj10ELb0ELb0ELb1ELb1EELb1ELb1EEELb0ETkNS_10contiguousERNSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEEEDaOT1_:
   40|   364k|   {
   41|   364k|      static_assert(sizeof(decltype(*buffer.data())) == 1);
   42|       |
   43|   364k|      auto it = reinterpret_cast<const char*>(buffer.data());
   44|   364k|      auto end = reinterpret_cast<const char*>(buffer.data()); // to be incremented
   45|       |
   46|       |      if constexpr (Padded) {
   47|       |         end += buffer.size() - padding_bytes;
   48|       |      }
   49|   364k|      else {
   50|   364k|         end += buffer.size();
   51|   364k|      }
   52|       |
   53|   364k|      return std::pair{it, end};
   54|   364k|   }
_ZN3glz23finalize_top_level_readITnDaXtlNS_22registry_validate_optsIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEEEtlS2_Lj10ELb0ELb0ELb1ELb1EELb1ELb1EEETkNS_10is_contextERNS_7contextEEEvOT0_PKcS9_S9_:
  115|   364k|   {
  116|   364k|      if constexpr (Opts.format == JSON && !check_null_terminated(Opts)) {
  117|       |         // Deliberately not [[unlikely]]: a body that ends with the buffer lands here on every
  118|       |         // successful read, which is the ordinary case for a registry parsing a wire span.
  119|       |         // start < it, not !=, because a streaming origin can be empty or overshoot on an error
  120|       |         // path; neither is an absent value.
  121|   364k|         if (ctx.error == error_code::end_reached && ctx.depth == 0 && it == end && start < it) {
  ------------------
  |  Branch (121:14): [True: 28.0k, False: 336k]
  |  Branch (121:54): [True: 27.8k, False: 174]
  |  Branch (121:72): [True: 27.8k, False: 0]
  |  Branch (121:85): [True: 27.8k, False: 0]
  ------------------
  122|  27.8k|            context ws_ctx{}; // only written to when skip_ws parses a comment; the result is unused
  123|  27.8k|            const char* consumed = start;
  124|  27.8k|            skip_ws<Opts>(ws_ctx, consumed, it);
  125|  27.8k|            if (consumed == it) {
  ------------------
  |  Branch (125:17): [True: 15, False: 27.8k]
  ------------------
  126|     15|               ctx.error = error_code::no_read_input;
  127|     15|            }
  128|  27.8k|         }
  129|   364k|      }
  130|   364k|      finalize_read_context<Opts>(ctx);
  131|   364k|   }
_ZN3glz21finalize_read_contextITnDaXtlNS_22registry_validate_optsIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEEEtlS2_Lj10ELb0ELb0ELb1ELb1EELb1ELb1EEETkNS_10is_contextERNS_7contextEEEvOT0_:
   76|   364k|   {
   77|       |      // A partial read stops as soon as it has the fields it was asked for, so it unwinds through
   78|       |      // its enclosing containers on an error code rather than through their closing braces, and
   79|       |      // none of them decrement depth on the way out. Depth is left standing at whatever nesting the
   80|       |      // last field sat at.
   81|       |      //
   82|       |      // That has to be cleared here rather than left for the next read to trip over. This is the
   83|       |      // one path that reports success with depth still raised, and depth is what settle_end_reached
   84|       |      // reads to tell a completed parse from a truncated one -- so a context reused after a partial
   85|       |      // read would see a later well-formed buffer settle to unexpected_end. Reads that end any
   86|       |      // other way either return depth to zero themselves or carry an error, and a context holding
   87|       |      // an error short-circuits the next read before it parses anything.
   88|       |      if constexpr (check_partial_read(Opts)) {
   89|       |         if (ctx.error == error_code::partial_read_complete) [[likely]] {
   90|       |            ctx.error = error_code::none;
   91|       |            ctx.depth = 0;
   92|       |            return;
   93|       |         }
   94|       |      }
   95|   364k|      settle_end_reached(ctx);
   96|   364k|   }
_ZN3glz4readITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENSt3__17variantIJDnNS2_17basic_string_viewIcNS2_11char_traitsIcEEEElEEETkNS_10contiguousERKNS2_4spanIKcLm18446744073709551615EEETkNS_10is_contextERNS_7contextEQaa14read_supportedIT0_XdtT_6formatEEnt18is_input_streamingIT1_EEENS_9error_ctxERSG_OSH_OT2_:
  136|  19.7k|   {
  137|  19.7k|      static_assert(sizeof(decltype(*buffer.data())) == 1);
  138|  19.7k|      using Buffer = std::remove_reference_t<decltype(buffer)>;
  139|       |
  140|  19.7k|      if constexpr (Opts.format != NDJSON) {
  141|  19.7k|         if (buffer.empty()) [[unlikely]] {
  ------------------
  |  Branch (141:14): [True: 0, False: 19.7k]
  ------------------
  142|      0|            ctx.error = error_code::no_read_input;
  143|      0|            return {0, ctx.error, ctx.custom_error_message};
  144|      0|         }
  145|  19.7k|      }
  146|       |
  147|  19.7k|      constexpr bool use_padded = resizable<Buffer> && non_const_buffer<Buffer> && !check_disable_padding(Opts);
  ------------------
  |  Branch (147:35): [Folded, False: 19.7k]
  |  Branch (147:56): [Folded, False: 0]
  |  Branch (147:84): [True: 0, Folded]
  ------------------
  148|       |
  149|  19.7k|      [[maybe_unused]] size_t original_size{};
  150|       |      if constexpr (use_padded) {
  151|       |         // Pad the buffer for SWAR
  152|       |         original_size = buffer.size();
  153|       |         buffer.resize(original_size + padding_bytes);
  154|       |      }
  155|       |
  156|  19.7k|      auto [it, end] = read_iterators<Opts, use_padded>(buffer);
  157|  19.7k|      auto start = it;
  158|  19.7k|      if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (158:11): [True: 0, False: 19.7k]
  ------------------
  159|      0|         goto finish;
  160|      0|      }
  161|       |
  162|       |      // Bound the speculative re-parsing a variant resolution may do, in bytes, relative to this
  163|       |      // input. Seeded per read so a reused context starts fresh. See charge_speculation.
  164|  19.7k|      if constexpr (requires { ctx.speculation_budget; }) {
  165|  19.7k|         const size_t proportional = max_speculative_parse_factor * size_t(end - it);
  166|  19.7k|         ctx.speculation_budget =
  167|  19.7k|            (proportional > min_speculative_parse_bytes ? proportional : min_speculative_parse_bytes) + 2;
  ------------------
  |  Branch (167:14): [True: 24, False: 19.6k]
  ------------------
  168|  19.7k|      }
  169|       |
  170|       |      // A YAML context marks its outermost parse with stream_begin and seeds its expansion budgets
  171|       |      // there, so clearing it here is what makes those budgets per-read like the one above. A
  172|       |      // reused context would otherwise carry a spent budget into the next document and reject a
  173|       |      // valid one, and would leave stream_begin pointing into the buffer of the previous read.
  174|       |      // Nested YAML parses do not route through glz::read, so they still cannot reseed themselves.
  175|       |      if constexpr (requires { ctx.stream_begin; }) {
  176|       |         ctx.stream_begin = nullptr;
  177|       |      }
  178|       |
  179|       |      if constexpr (use_padded) {
  180|       |         parse<Opts.format>::template op<is_padded_on<Opts>()>(value, ctx, it, end);
  181|       |      }
  182|  19.7k|      else {
  183|  19.7k|         parse<Opts.format>::template op<is_padded_off<Opts>()>(value, ctx, it, end);
  184|  19.7k|      }
  185|       |
  186|  19.7k|      if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (186:11): [True: 17.6k, False: 2.04k]
  ------------------
  187|  17.6k|         goto finish;
  188|  17.6k|      }
  189|       |
  190|       |      // The JSON RFC 8259 defines: JSON-text = ws value ws
  191|       |      // So, trailing whitespace is permitted and sometimes we want to
  192|       |      // validate this, even though this memory will not affect Glaze.
  193|       |      if constexpr (check_validate_trailing_whitespace(Opts)) {
  194|       |         if (it < end) {
  195|       |            skip_ws<Opts>(ctx, it, end);
  196|       |            if (bool(ctx.error)) [[unlikely]] {
  197|       |               goto finish;
  198|       |            }
  199|       |            if (it != end) [[unlikely]] {
  200|       |               ctx.error = error_code::syntax_error;
  201|       |            }
  202|       |         }
  203|       |      }
  204|       |
  205|  19.7k|   finish:
  206|  19.7k|      finalize_top_level_read<Opts>(ctx, start, it, end);
  207|       |
  208|       |      if constexpr (use_padded) {
  209|       |         // Restore the original buffer state
  210|       |         buffer.resize(original_size);
  211|       |      }
  212|       |
  213|  19.7k|      return {size_t(it - start), ctx.error, ctx.custom_error_message};
  214|  2.04k|   }
_ZN3glz14read_iteratorsITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELb0ETkNS_10contiguousERKNSt3__14spanIKcLm18446744073709551615EEEEEDaOT1_:
   40|  19.7k|   {
   41|  19.7k|      static_assert(sizeof(decltype(*buffer.data())) == 1);
   42|       |
   43|  19.7k|      auto it = reinterpret_cast<const char*>(buffer.data());
   44|  19.7k|      auto end = reinterpret_cast<const char*>(buffer.data()); // to be incremented
   45|       |
   46|       |      if constexpr (Padded) {
   47|       |         end += buffer.size() - padding_bytes;
   48|       |      }
   49|  19.7k|      else {
   50|  19.7k|         end += buffer.size();
   51|  19.7k|      }
   52|       |
   53|  19.7k|      return std::pair{it, end};
   54|  19.7k|   }
_ZN3glz4readITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENS_12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEETkNS_10contiguousENSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEQaa14read_supportedIT0_XdtT_6formatEEnt18is_input_streamingIT1_EEENS_9error_ctxERSB_OSC_:
  219|  58.0k|   {
  220|  58.0k|      format_context_t<Opts.format> ctx{};
  221|  58.0k|      return read<Opts>(value, buffer, ctx);
  222|  58.0k|   }
_ZN3glz4readITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENS_12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEETkNS_10contiguousERNSt3__117basic_string_viewIcNS6_11char_traitsIcEEEETkNS_10is_contextERNS_7contextEQaa14read_supportedIT0_XdtT_6formatEEnt18is_input_streamingIT1_EEENS_9error_ctxERSE_OSF_OT2_:
  136|  58.0k|   {
  137|  58.0k|      static_assert(sizeof(decltype(*buffer.data())) == 1);
  138|  58.0k|      using Buffer = std::remove_reference_t<decltype(buffer)>;
  139|       |
  140|  58.0k|      if constexpr (Opts.format != NDJSON) {
  141|  58.0k|         if (buffer.empty()) [[unlikely]] {
  ------------------
  |  Branch (141:14): [True: 0, False: 58.0k]
  ------------------
  142|      0|            ctx.error = error_code::no_read_input;
  143|      0|            return {0, ctx.error, ctx.custom_error_message};
  144|      0|         }
  145|  58.0k|      }
  146|       |
  147|  58.0k|      constexpr bool use_padded = resizable<Buffer> && non_const_buffer<Buffer> && !check_disable_padding(Opts);
  ------------------
  |  Branch (147:35): [Folded, False: 58.0k]
  |  Branch (147:56): [True: 0, Folded]
  |  Branch (147:84): [True: 0, Folded]
  ------------------
  148|       |
  149|  58.0k|      [[maybe_unused]] size_t original_size{};
  150|       |      if constexpr (use_padded) {
  151|       |         // Pad the buffer for SWAR
  152|       |         original_size = buffer.size();
  153|       |         buffer.resize(original_size + padding_bytes);
  154|       |      }
  155|       |
  156|  58.0k|      auto [it, end] = read_iterators<Opts, use_padded>(buffer);
  157|  58.0k|      auto start = it;
  158|  58.0k|      if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (158:11): [True: 0, False: 58.0k]
  ------------------
  159|      0|         goto finish;
  160|      0|      }
  161|       |
  162|       |      // Bound the speculative re-parsing a variant resolution may do, in bytes, relative to this
  163|       |      // input. Seeded per read so a reused context starts fresh. See charge_speculation.
  164|  58.0k|      if constexpr (requires { ctx.speculation_budget; }) {
  165|  58.0k|         const size_t proportional = max_speculative_parse_factor * size_t(end - it);
  166|  58.0k|         ctx.speculation_budget =
  167|  58.0k|            (proportional > min_speculative_parse_bytes ? proportional : min_speculative_parse_bytes) + 2;
  ------------------
  |  Branch (167:14): [True: 294, False: 57.7k]
  ------------------
  168|  58.0k|      }
  169|       |
  170|       |      // A YAML context marks its outermost parse with stream_begin and seeds its expansion budgets
  171|       |      // there, so clearing it here is what makes those budgets per-read like the one above. A
  172|       |      // reused context would otherwise carry a spent budget into the next document and reject a
  173|       |      // valid one, and would leave stream_begin pointing into the buffer of the previous read.
  174|       |      // Nested YAML parses do not route through glz::read, so they still cannot reseed themselves.
  175|       |      if constexpr (requires { ctx.stream_begin; }) {
  176|       |         ctx.stream_begin = nullptr;
  177|       |      }
  178|       |
  179|       |      if constexpr (use_padded) {
  180|       |         parse<Opts.format>::template op<is_padded_on<Opts>()>(value, ctx, it, end);
  181|       |      }
  182|  58.0k|      else {
  183|  58.0k|         parse<Opts.format>::template op<is_padded_off<Opts>()>(value, ctx, it, end);
  184|  58.0k|      }
  185|       |
  186|  58.0k|      if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (186:11): [True: 47.1k, False: 10.8k]
  ------------------
  187|  47.1k|         goto finish;
  188|  47.1k|      }
  189|       |
  190|       |      // The JSON RFC 8259 defines: JSON-text = ws value ws
  191|       |      // So, trailing whitespace is permitted and sometimes we want to
  192|       |      // validate this, even though this memory will not affect Glaze.
  193|       |      if constexpr (check_validate_trailing_whitespace(Opts)) {
  194|       |         if (it < end) {
  195|       |            skip_ws<Opts>(ctx, it, end);
  196|       |            if (bool(ctx.error)) [[unlikely]] {
  197|       |               goto finish;
  198|       |            }
  199|       |            if (it != end) [[unlikely]] {
  200|       |               ctx.error = error_code::syntax_error;
  201|       |            }
  202|       |         }
  203|       |      }
  204|       |
  205|  58.0k|   finish:
  206|  58.0k|      finalize_top_level_read<Opts>(ctx, start, it, end);
  207|       |
  208|       |      if constexpr (use_padded) {
  209|       |         // Restore the original buffer state
  210|       |         buffer.resize(original_size);
  211|       |      }
  212|       |
  213|  58.0k|      return {size_t(it - start), ctx.error, ctx.custom_error_message};
  214|  10.8k|   }

_ZN3glz12format_errorINSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEEENS1_12basic_stringIcS4_NS1_9allocatorIcEEEERKNS_9error_ctxERKT_:
 3349|  4.11M|   {
 3350|  4.11M|      const auto error_type_str = meta<error_code>::keys[uint32_t(pe.ec)];
 3351|       |
 3352|  4.11M|      const auto info = detail::get_source_info(buffer, pe.count);
 3353|  4.11M|      auto error_str = detail::generate_error_string(error_type_str, info);
 3354|  4.11M|      if (pe.custom_error_message.size()) {
  ------------------
  |  Branch (3354:11): [True: 0, False: 4.11M]
  ------------------
 3355|      0|         error_str.append(" ");
 3356|      0|         error_str.append(pe.custom_error_message.begin(), pe.custom_error_message.end());
 3357|      0|      }
 3358|  4.11M|      return error_str;
 3359|  4.11M|   }
_ZN3glz11decode_hashILj10EN12jsonrpc_fuzz5pointEXtlNS_11hash_info_tIS2_Lm256EEELNS_9hash_typeE1EtlNSt3__15arrayIhLm256EEEtlA256_hLh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh0ELh1ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2EEELm1ELm1EEELS5_1EE2opIRPKcSD_EEmOT_T0_:
 2503|  7.36k|      {
 2504|       |         if constexpr (HashInfo.sized_hash) {
 2505|       |            const auto* c = quote_memchr<HashInfo.min_length>(it, end);
 2506|       |            if (c) [[likely]] {
 2507|       |               const auto n = size_t(static_cast<std::decay_t<decltype(it)>>(c) - it);
 2508|       |               if (n == 0 || n > HashInfo.max_length || HashInfo.unique_index >= size_t(end - it)) [[unlikely]] {
 2509|       |                  return N; // error
 2510|       |               }
 2511|       |
 2512|       |               const auto h = bitmix(uint16_t(it[HashInfo.unique_index]) | (uint16_t(n) << 8), HashInfo.seed);
 2513|       |               return HashInfo.table[h % bsize];
 2514|       |            }
 2515|       |            else [[unlikely]] {
 2516|       |               return N;
 2517|       |            }
 2518|       |         }
 2519|  7.36k|         else {
 2520|  7.36k|            if constexpr (N == 2) {
 2521|       |               if constexpr (uindex > 0) {
 2522|       |                  if (size_t(end - it) <= uindex) [[unlikely]] {
 2523|       |                     return N; // error
 2524|       |                  }
 2525|       |               }
 2526|       |               // Avoids using a hash table
 2527|  7.36k|               constexpr auto first_key_char = reflect<T>::keys[0][uindex];
 2528|  7.36k|               return size_t(bool(it[uindex] ^ first_key_char));
 2529|       |            }
 2530|       |            else {
 2531|       |               if constexpr (uindex > 0) {
 2532|       |                  if (size_t(end - it) <= uindex) [[unlikely]] {
 2533|       |                     return N; // error
 2534|       |                  }
 2535|       |               }
 2536|       |               return HashInfo.table[uint8_t(it[uindex])];
 2537|       |            }
 2538|  7.36k|         }
 2539|  7.36k|      }
_ZN3glz11decode_hashILj10EN12jsonrpc_fuzz8fuzz_apiEXtlNS_11hash_info_tIS2_Lm128EEELNS_9hash_typeE2EtlNSt3__15arrayIhLm128EEEtlA128_hLh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh11ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh6ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh9ELh13ELh13ELh13ELh13ELh13ELh12ELh13ELh13ELh13ELh13ELh0ELh13ELh13ELh13ELh13ELh13ELh13ELh5ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh4ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh1ELh13ELh10ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh2ELh3ELh13ELh13ELh13ELh13ELh13ELh13ELh8ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh7ELh13ELh13ELh13ELh13ELh13ELh13ELh13EEELm4ELm8ELm15149911783463666029ELm18446744073709551615ELb0ELm2EEELS5_2EE2opIRPKcSD_EEmOT_T0_:
 2568|  28.5k|      {
 2569|  28.5k|         if constexpr (HashInfo.front_hash_bytes == 2) {
 2570|  28.5k|            if (size_t(end - it) <= 2) [[unlikely]] {
  ------------------
  |  Branch (2570:17): [True: 7, False: 28.5k]
  ------------------
 2571|      7|               return N; // error
 2572|      7|            }
 2573|  28.5k|            uint16_t h;
 2574|       |            if consteval {
 2575|       |               h = 0;
 2576|       |               for (size_t i = 0; i < 2; ++i) {
 2577|       |                  h |= static_cast<uint16_t>(static_cast<uint8_t>(it[i])) << (8 * i);
 2578|       |               }
 2579|       |            }
 2580|  28.5k|            else {
 2581|  28.5k|               std::memcpy(&h, it, 2);
 2582|       |               if constexpr (std::endian::native == std::endian::big) {
 2583|       |                  h = std::byteswap(h);
 2584|       |               }
 2585|  28.5k|            }
 2586|  28.5k|            return HashInfo.table[bitmix(h, HashInfo.seed) % bsize];
 2587|       |         }
 2588|       |         else if constexpr (HashInfo.front_hash_bytes == 4) {
 2589|       |            if (size_t(end - it) <= 4) [[unlikely]] {
 2590|       |               return N;
 2591|       |            }
 2592|       |            uint32_t h;
 2593|       |            if consteval {
 2594|       |               h = 0;
 2595|       |               for (size_t i = 0; i < 4; ++i) {
 2596|       |                  h |= static_cast<uint32_t>(static_cast<uint8_t>(it[i])) << (8 * i);
 2597|       |               }
 2598|       |            }
 2599|       |            else {
 2600|       |               std::memcpy(&h, it, 4);
 2601|       |               if constexpr (std::endian::native == std::endian::big) {
 2602|       |                  h = std::byteswap(h);
 2603|       |               }
 2604|       |            }
 2605|       |            return HashInfo.table[bitmix(h, HashInfo.seed) % bsize];
 2606|       |         }
 2607|       |         else if constexpr (HashInfo.front_hash_bytes == 8) {
 2608|       |            if (size_t(end - it) <= 8) [[unlikely]] {
 2609|       |               return N;
 2610|       |            }
 2611|       |            uint64_t h;
 2612|       |            if consteval {
 2613|       |               h = 0;
 2614|       |               for (size_t i = 0; i < 8; ++i) {
 2615|       |                  h |= static_cast<uint64_t>(static_cast<uint8_t>(it[i])) << (8 * i);
 2616|       |               }
 2617|       |            }
 2618|       |            else {
 2619|       |               std::memcpy(&h, it, 8);
 2620|       |               if constexpr (std::endian::native == std::endian::big) {
 2621|       |                  h = std::byteswap(h);
 2622|       |               }
 2623|       |            }
 2624|       |            return HashInfo.table[rich_bitmix(h, HashInfo.seed) % bsize];
 2625|       |         }
 2626|       |         else {
 2627|       |            static_assert(false_v<T>, "invalid hash algorithm");
 2628|       |         }
 2629|  28.5k|      }
_ZN3glz6bitmixEmm:
 1531|  28.5k|   {
 1532|  28.5k|      h *= seed;
 1533|  28.5k|      return h ^ std::rotr(h, 49);
 1534|  28.5k|   };
_ZN3glz11decode_hashILj10EN12jsonrpc_fuzz6nestedEXtlNS_11hash_info_tIS2_Lm256EEELNS_9hash_typeE1EtlNSt3__15arrayIhLm256EEEtlA256_hLh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh0ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh1ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2EEELm5ELm5EEELS5_1EE2opIRPKcSD_EEmOT_T0_:
 2503|  13.1k|      {
 2504|       |         if constexpr (HashInfo.sized_hash) {
 2505|       |            const auto* c = quote_memchr<HashInfo.min_length>(it, end);
 2506|       |            if (c) [[likely]] {
 2507|       |               const auto n = size_t(static_cast<std::decay_t<decltype(it)>>(c) - it);
 2508|       |               if (n == 0 || n > HashInfo.max_length || HashInfo.unique_index >= size_t(end - it)) [[unlikely]] {
 2509|       |                  return N; // error
 2510|       |               }
 2511|       |
 2512|       |               const auto h = bitmix(uint16_t(it[HashInfo.unique_index]) | (uint16_t(n) << 8), HashInfo.seed);
 2513|       |               return HashInfo.table[h % bsize];
 2514|       |            }
 2515|       |            else [[unlikely]] {
 2516|       |               return N;
 2517|       |            }
 2518|       |         }
 2519|  13.1k|         else {
 2520|  13.1k|            if constexpr (N == 2) {
 2521|       |               if constexpr (uindex > 0) {
 2522|       |                  if (size_t(end - it) <= uindex) [[unlikely]] {
 2523|       |                     return N; // error
 2524|       |                  }
 2525|       |               }
 2526|       |               // Avoids using a hash table
 2527|  13.1k|               constexpr auto first_key_char = reflect<T>::keys[0][uindex];
 2528|  13.1k|               return size_t(bool(it[uindex] ^ first_key_char));
 2529|       |            }
 2530|       |            else {
 2531|       |               if constexpr (uindex > 0) {
 2532|       |                  if (size_t(end - it) <= uindex) [[unlikely]] {
 2533|       |                     return N; // error
 2534|       |                  }
 2535|       |               }
 2536|       |               return HashInfo.table[uint8_t(it[uindex])];
 2537|       |            }
 2538|  13.1k|         }
 2539|  13.1k|      }
_ZN3glz11decode_hashILj10ENS_3rpc18request_envelope_tEXtlNS_11hash_info_tIS2_Lm256EEELNS_9hash_typeE1EtlNSt3__15arrayIhLm256EEEtlA256_hLh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh3ELh0ELh4ELh4ELh1ELh4ELh4ELh2ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4EEELm2ELm7EEELS5_1EE2opIRPKcSD_EEmOT_T0_:
 2503|   270k|      {
 2504|       |         if constexpr (HashInfo.sized_hash) {
 2505|       |            const auto* c = quote_memchr<HashInfo.min_length>(it, end);
 2506|       |            if (c) [[likely]] {
 2507|       |               const auto n = size_t(static_cast<std::decay_t<decltype(it)>>(c) - it);
 2508|       |               if (n == 0 || n > HashInfo.max_length || HashInfo.unique_index >= size_t(end - it)) [[unlikely]] {
 2509|       |                  return N; // error
 2510|       |               }
 2511|       |
 2512|       |               const auto h = bitmix(uint16_t(it[HashInfo.unique_index]) | (uint16_t(n) << 8), HashInfo.seed);
 2513|       |               return HashInfo.table[h % bsize];
 2514|       |            }
 2515|       |            else [[unlikely]] {
 2516|       |               return N;
 2517|       |            }
 2518|       |         }
 2519|   270k|         else {
 2520|       |            if constexpr (N == 2) {
 2521|       |               if constexpr (uindex > 0) {
 2522|       |                  if (size_t(end - it) <= uindex) [[unlikely]] {
 2523|       |                     return N; // error
 2524|       |                  }
 2525|       |               }
 2526|       |               // Avoids using a hash table
 2527|       |               constexpr auto first_key_char = reflect<T>::keys[0][uindex];
 2528|       |               return size_t(bool(it[uindex] ^ first_key_char));
 2529|       |            }
 2530|   270k|            else {
 2531|       |               if constexpr (uindex > 0) {
 2532|       |                  if (size_t(end - it) <= uindex) [[unlikely]] {
 2533|       |                     return N; // error
 2534|       |                  }
 2535|       |               }
 2536|   270k|               return HashInfo.table[uint8_t(it[uindex])];
 2537|   270k|            }
 2538|   270k|         }
 2539|   270k|      }

_ZN3glz3getILm0ETkNS_12tuple_detail9indexableERKNS_5tupleIJMN12jsonrpc_fuzz10member_apiEiMS4_FiiEMS4_FvvEMS4_FNS3_5pointERKSA_EEEEEEDcOT0_:
  116|  61.1k|   {
  117|  61.1k|      using D = std::remove_cvref_t<Tup>;
  118|  61.1k|      if constexpr (tuple_detail::is_tuple<D>) {
  119|  61.1k|         static_assert(I < D::N, "glz::get index is out of range");
  120|  61.1k|         using T = typename D::template type_at<I>;
  121|  61.1k|         if constexpr (std::is_reference_v<Tup> || std::is_const_v<std::remove_reference_t<Tup>>) {
  122|       |            // An lvalue, or a const tuple of either value category: element access carries the
  123|       |            // constness of the tuple, except for elements that are themselves references.
  124|  61.1k|            using leaf = tuple_detail::match_const_t<std::remove_reference_t<Tup>, tuple_detail::elem<I, T>>;
  125|  61.1k|            return (static_cast<leaf&>(tup).value);
  126|       |         }
  127|       |         else {
  128|       |            return static_cast<T&&>(static_cast<tuple_detail::elem<I, T>&>(tup).value);
  129|       |         }
  130|       |      }
  131|       |      else {
  132|       |         return (static_cast<Tup&&>(tup)[I]);
  133|       |      }
  134|  61.1k|   }
_ZN3glz3getILm1ETkNS_12tuple_detail9indexableERKNS_5tupleIJMN12jsonrpc_fuzz10member_apiEiMS4_FiiEMS4_FvvEMS4_FNS3_5pointERKSA_EEEEEEDcOT0_:
  116|  61.1k|   {
  117|  61.1k|      using D = std::remove_cvref_t<Tup>;
  118|  61.1k|      if constexpr (tuple_detail::is_tuple<D>) {
  119|  61.1k|         static_assert(I < D::N, "glz::get index is out of range");
  120|  61.1k|         using T = typename D::template type_at<I>;
  121|  61.1k|         if constexpr (std::is_reference_v<Tup> || std::is_const_v<std::remove_reference_t<Tup>>) {
  122|       |            // An lvalue, or a const tuple of either value category: element access carries the
  123|       |            // constness of the tuple, except for elements that are themselves references.
  124|  61.1k|            using leaf = tuple_detail::match_const_t<std::remove_reference_t<Tup>, tuple_detail::elem<I, T>>;
  125|  61.1k|            return (static_cast<leaf&>(tup).value);
  126|       |         }
  127|       |         else {
  128|       |            return static_cast<T&&>(static_cast<tuple_detail::elem<I, T>&>(tup).value);
  129|       |         }
  130|       |      }
  131|       |      else {
  132|       |         return (static_cast<Tup&&>(tup)[I]);
  133|       |      }
  134|  61.1k|   }
_ZN3glz3getILm2ETkNS_12tuple_detail9indexableERKNS_5tupleIJMN12jsonrpc_fuzz10member_apiEiMS4_FiiEMS4_FvvEMS4_FNS3_5pointERKSA_EEEEEEDcOT0_:
  116|  61.1k|   {
  117|  61.1k|      using D = std::remove_cvref_t<Tup>;
  118|  61.1k|      if constexpr (tuple_detail::is_tuple<D>) {
  119|  61.1k|         static_assert(I < D::N, "glz::get index is out of range");
  120|  61.1k|         using T = typename D::template type_at<I>;
  121|  61.1k|         if constexpr (std::is_reference_v<Tup> || std::is_const_v<std::remove_reference_t<Tup>>) {
  122|       |            // An lvalue, or a const tuple of either value category: element access carries the
  123|       |            // constness of the tuple, except for elements that are themselves references.
  124|  61.1k|            using leaf = tuple_detail::match_const_t<std::remove_reference_t<Tup>, tuple_detail::elem<I, T>>;
  125|  61.1k|            return (static_cast<leaf&>(tup).value);
  126|       |         }
  127|       |         else {
  128|       |            return static_cast<T&&>(static_cast<tuple_detail::elem<I, T>&>(tup).value);
  129|       |         }
  130|       |      }
  131|       |      else {
  132|       |         return (static_cast<Tup&&>(tup)[I]);
  133|       |      }
  134|  61.1k|   }
_ZN3glz3getILm3ETkNS_12tuple_detail9indexableERKNS_5tupleIJMN12jsonrpc_fuzz10member_apiEiMS4_FiiEMS4_FvvEMS4_FNS3_5pointERKSA_EEEEEEDcOT0_:
  116|  61.1k|   {
  117|  61.1k|      using D = std::remove_cvref_t<Tup>;
  118|  61.1k|      if constexpr (tuple_detail::is_tuple<D>) {
  119|  61.1k|         static_assert(I < D::N, "glz::get index is out of range");
  120|  61.1k|         using T = typename D::template type_at<I>;
  121|  61.1k|         if constexpr (std::is_reference_v<Tup> || std::is_const_v<std::remove_reference_t<Tup>>) {
  122|       |            // An lvalue, or a const tuple of either value category: element access carries the
  123|       |            // constness of the tuple, except for elements that are themselves references.
  124|  61.1k|            using leaf = tuple_detail::match_const_t<std::remove_reference_t<Tup>, tuple_detail::elem<I, T>>;
  125|  61.1k|            return (static_cast<leaf&>(tup).value);
  126|       |         }
  127|       |         else {
  128|       |            return static_cast<T&&>(static_cast<tuple_detail::elem<I, T>&>(tup).value);
  129|       |         }
  130|       |      }
  131|       |      else {
  132|       |         return (static_cast<Tup&&>(tup)[I]);
  133|       |      }
  134|  61.1k|   }
_ZN3glz3getILm0ETkNS_12tuple_detail9indexableENS_5tupleIJRdS3_EEEEEDcOT0_:
  116|  5.66k|   {
  117|  5.66k|      using D = std::remove_cvref_t<Tup>;
  118|  5.66k|      if constexpr (tuple_detail::is_tuple<D>) {
  119|  5.66k|         static_assert(I < D::N, "glz::get index is out of range");
  120|  5.66k|         using T = typename D::template type_at<I>;
  121|       |         if constexpr (std::is_reference_v<Tup> || std::is_const_v<std::remove_reference_t<Tup>>) {
  122|       |            // An lvalue, or a const tuple of either value category: element access carries the
  123|       |            // constness of the tuple, except for elements that are themselves references.
  124|       |            using leaf = tuple_detail::match_const_t<std::remove_reference_t<Tup>, tuple_detail::elem<I, T>>;
  125|       |            return (static_cast<leaf&>(tup).value);
  126|       |         }
  127|  5.66k|         else {
  128|  5.66k|            return static_cast<T&&>(static_cast<tuple_detail::elem<I, T>&>(tup).value);
  129|  5.66k|         }
  130|       |      }
  131|       |      else {
  132|       |         return (static_cast<Tup&&>(tup)[I]);
  133|       |      }
  134|  5.66k|   }
_ZN3glz3tieIJddEEENS_5tupleIJDpRT_EEES4_:
  325|  68.6k|   {
  326|  68.6k|      return {{{ts}...}};
  327|  68.6k|   }
_ZN3glz3getILm1ETkNS_12tuple_detail9indexableENS_5tupleIJRdS3_EEEEEDcOT0_:
  116|  1.49k|   {
  117|  1.49k|      using D = std::remove_cvref_t<Tup>;
  118|  1.49k|      if constexpr (tuple_detail::is_tuple<D>) {
  119|  1.49k|         static_assert(I < D::N, "glz::get index is out of range");
  120|  1.49k|         using T = typename D::template type_at<I>;
  121|       |         if constexpr (std::is_reference_v<Tup> || std::is_const_v<std::remove_reference_t<Tup>>) {
  122|       |            // An lvalue, or a const tuple of either value category: element access carries the
  123|       |            // constness of the tuple, except for elements that are themselves references.
  124|       |            using leaf = tuple_detail::match_const_t<std::remove_reference_t<Tup>, tuple_detail::elem<I, T>>;
  125|       |            return (static_cast<leaf&>(tup).value);
  126|       |         }
  127|  1.49k|         else {
  128|  1.49k|            return static_cast<T&&>(static_cast<tuple_detail::elem<I, T>&>(tup).value);
  129|  1.49k|         }
  130|       |      }
  131|       |      else {
  132|       |         return (static_cast<Tup&&>(tup)[I]);
  133|       |      }
  134|  1.49k|   }
_ZN3glz3getILm0ETkNS_12tuple_detail9indexableERNS_5tupleIJRdS3_EEEEEDcOT0_:
  116|  61.5k|   {
  117|  61.5k|      using D = std::remove_cvref_t<Tup>;
  118|  61.5k|      if constexpr (tuple_detail::is_tuple<D>) {
  119|  61.5k|         static_assert(I < D::N, "glz::get index is out of range");
  120|  61.5k|         using T = typename D::template type_at<I>;
  121|  61.5k|         if constexpr (std::is_reference_v<Tup> || std::is_const_v<std::remove_reference_t<Tup>>) {
  122|       |            // An lvalue, or a const tuple of either value category: element access carries the
  123|       |            // constness of the tuple, except for elements that are themselves references.
  124|  61.5k|            using leaf = tuple_detail::match_const_t<std::remove_reference_t<Tup>, tuple_detail::elem<I, T>>;
  125|  61.5k|            return (static_cast<leaf&>(tup).value);
  126|       |         }
  127|       |         else {
  128|       |            return static_cast<T&&>(static_cast<tuple_detail::elem<I, T>&>(tup).value);
  129|       |         }
  130|       |      }
  131|       |      else {
  132|       |         return (static_cast<Tup&&>(tup)[I]);
  133|       |      }
  134|  61.5k|   }
_ZN3glz3getILm1ETkNS_12tuple_detail9indexableERNS_5tupleIJRdS3_EEEEEDcOT0_:
  116|  61.5k|   {
  117|  61.5k|      using D = std::remove_cvref_t<Tup>;
  118|  61.5k|      if constexpr (tuple_detail::is_tuple<D>) {
  119|  61.5k|         static_assert(I < D::N, "glz::get index is out of range");
  120|  61.5k|         using T = typename D::template type_at<I>;
  121|  61.5k|         if constexpr (std::is_reference_v<Tup> || std::is_const_v<std::remove_reference_t<Tup>>) {
  122|       |            // An lvalue, or a const tuple of either value category: element access carries the
  123|       |            // constness of the tuple, except for elements that are themselves references.
  124|  61.5k|            using leaf = tuple_detail::match_const_t<std::remove_reference_t<Tup>, tuple_detail::elem<I, T>>;
  125|  61.5k|            return (static_cast<leaf&>(tup).value);
  126|       |         }
  127|       |         else {
  128|       |            return static_cast<T&&>(static_cast<tuple_detail::elem<I, T>&>(tup).value);
  129|       |         }
  130|       |      }
  131|       |      else {
  132|       |         return (static_cast<Tup&&>(tup)[I]);
  133|       |      }
  134|  61.5k|   }
_ZN3glz3getILm0ETkNS_12tuple_detail9indexableENS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERN12jsonrpc_fuzz5pointERNSC_6nestedERNS4_6vectorIiNS8_IiEEEERNS4_3mapISA_iNS4_4lessISA_EENS8_INS4_4pairIKSA_iEEEEEERNS4_8optionalIdEERNS4_7variantIJSA_NSC_6amountEEEERNS4_8functionIFiiEEERNS11_IFSA_RSP_EEERNS11_IFSD_RKSD_EEERNS11_IFdRNSH_IdNS8_IdEEEEEEERNS11_IFvvEEEEEEEEDcOT0_:
  116|  14.1k|   {
  117|  14.1k|      using D = std::remove_cvref_t<Tup>;
  118|  14.1k|      if constexpr (tuple_detail::is_tuple<D>) {
  119|  14.1k|         static_assert(I < D::N, "glz::get index is out of range");
  120|  14.1k|         using T = typename D::template type_at<I>;
  121|       |         if constexpr (std::is_reference_v<Tup> || std::is_const_v<std::remove_reference_t<Tup>>) {
  122|       |            // An lvalue, or a const tuple of either value category: element access carries the
  123|       |            // constness of the tuple, except for elements that are themselves references.
  124|       |            using leaf = tuple_detail::match_const_t<std::remove_reference_t<Tup>, tuple_detail::elem<I, T>>;
  125|       |            return (static_cast<leaf&>(tup).value);
  126|       |         }
  127|  14.1k|         else {
  128|  14.1k|            return static_cast<T&&>(static_cast<tuple_detail::elem<I, T>&>(tup).value);
  129|  14.1k|         }
  130|       |      }
  131|       |      else {
  132|       |         return (static_cast<Tup&&>(tup)[I]);
  133|       |      }
  134|  14.1k|   }
_ZN3glz3tieIJiNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEN12jsonrpc_fuzz5pointENS8_6nestedENS1_6vectorIiNS5_IiEEEENS1_3mapIS7_iNS1_4lessIS7_EENS5_INS1_4pairIKS7_iEEEEEENS1_8optionalIdEENS1_7variantIJS7_NS8_6amountEEEENS1_8functionIFiiEEENSR_IFS7_RSI_EEENSR_IFS9_RKS9_EEENSR_IFdRNSB_IdNS5_IdEEEEEEENSR_IFvvEEEEEENS_5tupleIJDpRT_EEES1B_:
  325|  88.9k|   {
  326|  88.9k|      return {{{ts}...}};
  327|  88.9k|   }
_ZN3glz3getILm1ETkNS_12tuple_detail9indexableENS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERN12jsonrpc_fuzz5pointERNSC_6nestedERNS4_6vectorIiNS8_IiEEEERNS4_3mapISA_iNS4_4lessISA_EENS8_INS4_4pairIKSA_iEEEEEERNS4_8optionalIdEERNS4_7variantIJSA_NSC_6amountEEEERNS4_8functionIFiiEEERNS11_IFSA_RSP_EEERNS11_IFSD_RKSD_EEERNS11_IFdRNSH_IdNS8_IdEEEEEEERNS11_IFvvEEEEEEEEDcOT0_:
  116|    204|   {
  117|    204|      using D = std::remove_cvref_t<Tup>;
  118|    204|      if constexpr (tuple_detail::is_tuple<D>) {
  119|    204|         static_assert(I < D::N, "glz::get index is out of range");
  120|    204|         using T = typename D::template type_at<I>;
  121|       |         if constexpr (std::is_reference_v<Tup> || std::is_const_v<std::remove_reference_t<Tup>>) {
  122|       |            // An lvalue, or a const tuple of either value category: element access carries the
  123|       |            // constness of the tuple, except for elements that are themselves references.
  124|       |            using leaf = tuple_detail::match_const_t<std::remove_reference_t<Tup>, tuple_detail::elem<I, T>>;
  125|       |            return (static_cast<leaf&>(tup).value);
  126|       |         }
  127|    204|         else {
  128|    204|            return static_cast<T&&>(static_cast<tuple_detail::elem<I, T>&>(tup).value);
  129|    204|         }
  130|       |      }
  131|       |      else {
  132|       |         return (static_cast<Tup&&>(tup)[I]);
  133|       |      }
  134|    204|   }
_ZN3glz3getILm2ETkNS_12tuple_detail9indexableENS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERN12jsonrpc_fuzz5pointERNSC_6nestedERNS4_6vectorIiNS8_IiEEEERNS4_3mapISA_iNS4_4lessISA_EENS8_INS4_4pairIKSA_iEEEEEERNS4_8optionalIdEERNS4_7variantIJSA_NSC_6amountEEEERNS4_8functionIFiiEEERNS11_IFSA_RSP_EEERNS11_IFSD_RKSD_EEERNS11_IFdRNSH_IdNS8_IdEEEEEEERNS11_IFvvEEEEEEEEDcOT0_:
  116|    658|   {
  117|    658|      using D = std::remove_cvref_t<Tup>;
  118|    658|      if constexpr (tuple_detail::is_tuple<D>) {
  119|    658|         static_assert(I < D::N, "glz::get index is out of range");
  120|    658|         using T = typename D::template type_at<I>;
  121|       |         if constexpr (std::is_reference_v<Tup> || std::is_const_v<std::remove_reference_t<Tup>>) {
  122|       |            // An lvalue, or a const tuple of either value category: element access carries the
  123|       |            // constness of the tuple, except for elements that are themselves references.
  124|       |            using leaf = tuple_detail::match_const_t<std::remove_reference_t<Tup>, tuple_detail::elem<I, T>>;
  125|       |            return (static_cast<leaf&>(tup).value);
  126|       |         }
  127|    658|         else {
  128|    658|            return static_cast<T&&>(static_cast<tuple_detail::elem<I, T>&>(tup).value);
  129|    658|         }
  130|       |      }
  131|       |      else {
  132|       |         return (static_cast<Tup&&>(tup)[I]);
  133|       |      }
  134|    658|   }
_ZN3glz3getILm0ETkNS_12tuple_detail9indexableENS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEEEEDcOT0_:
  116|  12.4k|   {
  117|  12.4k|      using D = std::remove_cvref_t<Tup>;
  118|  12.4k|      if constexpr (tuple_detail::is_tuple<D>) {
  119|  12.4k|         static_assert(I < D::N, "glz::get index is out of range");
  120|  12.4k|         using T = typename D::template type_at<I>;
  121|       |         if constexpr (std::is_reference_v<Tup> || std::is_const_v<std::remove_reference_t<Tup>>) {
  122|       |            // An lvalue, or a const tuple of either value category: element access carries the
  123|       |            // constness of the tuple, except for elements that are themselves references.
  124|       |            using leaf = tuple_detail::match_const_t<std::remove_reference_t<Tup>, tuple_detail::elem<I, T>>;
  125|       |            return (static_cast<leaf&>(tup).value);
  126|       |         }
  127|  12.4k|         else {
  128|  12.4k|            return static_cast<T&&>(static_cast<tuple_detail::elem<I, T>&>(tup).value);
  129|  12.4k|         }
  130|       |      }
  131|       |      else {
  132|       |         return (static_cast<Tup&&>(tup)[I]);
  133|       |      }
  134|  12.4k|   }
_ZN3glz3tieIJiNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEENS_5tupleIJDpRT_EEESB_:
  325|  74.1k|   {
  326|  74.1k|      return {{{ts}...}};
  327|  74.1k|   }
_ZN3glz3getILm1ETkNS_12tuple_detail9indexableENS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEEEEDcOT0_:
  116|    493|   {
  117|    493|      using D = std::remove_cvref_t<Tup>;
  118|    493|      if constexpr (tuple_detail::is_tuple<D>) {
  119|    493|         static_assert(I < D::N, "glz::get index is out of range");
  120|    493|         using T = typename D::template type_at<I>;
  121|       |         if constexpr (std::is_reference_v<Tup> || std::is_const_v<std::remove_reference_t<Tup>>) {
  122|       |            // An lvalue, or a const tuple of either value category: element access carries the
  123|       |            // constness of the tuple, except for elements that are themselves references.
  124|       |            using leaf = tuple_detail::match_const_t<std::remove_reference_t<Tup>, tuple_detail::elem<I, T>>;
  125|       |            return (static_cast<leaf&>(tup).value);
  126|       |         }
  127|    493|         else {
  128|    493|            return static_cast<T&&>(static_cast<tuple_detail::elem<I, T>&>(tup).value);
  129|    493|         }
  130|       |      }
  131|       |      else {
  132|       |         return (static_cast<Tup&&>(tup)[I]);
  133|       |      }
  134|    493|   }
_ZN3glz3getILm3ETkNS_12tuple_detail9indexableENS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERN12jsonrpc_fuzz5pointERNSC_6nestedERNS4_6vectorIiNS8_IiEEEERNS4_3mapISA_iNS4_4lessISA_EENS8_INS4_4pairIKSA_iEEEEEERNS4_8optionalIdEERNS4_7variantIJSA_NSC_6amountEEEERNS4_8functionIFiiEEERNS11_IFSA_RSP_EEERNS11_IFSD_RKSD_EEERNS11_IFdRNSH_IdNS8_IdEEEEEEERNS11_IFvvEEEEEEEEDcOT0_:
  116|    795|   {
  117|    795|      using D = std::remove_cvref_t<Tup>;
  118|    795|      if constexpr (tuple_detail::is_tuple<D>) {
  119|    795|         static_assert(I < D::N, "glz::get index is out of range");
  120|    795|         using T = typename D::template type_at<I>;
  121|       |         if constexpr (std::is_reference_v<Tup> || std::is_const_v<std::remove_reference_t<Tup>>) {
  122|       |            // An lvalue, or a const tuple of either value category: element access carries the
  123|       |            // constness of the tuple, except for elements that are themselves references.
  124|       |            using leaf = tuple_detail::match_const_t<std::remove_reference_t<Tup>, tuple_detail::elem<I, T>>;
  125|       |            return (static_cast<leaf&>(tup).value);
  126|       |         }
  127|    795|         else {
  128|    795|            return static_cast<T&&>(static_cast<tuple_detail::elem<I, T>&>(tup).value);
  129|    795|         }
  130|       |      }
  131|       |      else {
  132|       |         return (static_cast<Tup&&>(tup)[I]);
  133|       |      }
  134|    795|   }
_ZN3glz3getILm5ETkNS_12tuple_detail9indexableENS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERN12jsonrpc_fuzz5pointERNSC_6nestedERNS4_6vectorIiNS8_IiEEEERNS4_3mapISA_iNS4_4lessISA_EENS8_INS4_4pairIKSA_iEEEEEERNS4_8optionalIdEERNS4_7variantIJSA_NSC_6amountEEEERNS4_8functionIFiiEEERNS11_IFSA_RSP_EEERNS11_IFSD_RKSD_EEERNS11_IFdRNSH_IdNS8_IdEEEEEEERNS11_IFvvEEEEEEEEDcOT0_:
  116|  1.10k|   {
  117|  1.10k|      using D = std::remove_cvref_t<Tup>;
  118|  1.10k|      if constexpr (tuple_detail::is_tuple<D>) {
  119|  1.10k|         static_assert(I < D::N, "glz::get index is out of range");
  120|  1.10k|         using T = typename D::template type_at<I>;
  121|       |         if constexpr (std::is_reference_v<Tup> || std::is_const_v<std::remove_reference_t<Tup>>) {
  122|       |            // An lvalue, or a const tuple of either value category: element access carries the
  123|       |            // constness of the tuple, except for elements that are themselves references.
  124|       |            using leaf = tuple_detail::match_const_t<std::remove_reference_t<Tup>, tuple_detail::elem<I, T>>;
  125|       |            return (static_cast<leaf&>(tup).value);
  126|       |         }
  127|  1.10k|         else {
  128|  1.10k|            return static_cast<T&&>(static_cast<tuple_detail::elem<I, T>&>(tup).value);
  129|  1.10k|         }
  130|       |      }
  131|       |      else {
  132|       |         return (static_cast<Tup&&>(tup)[I]);
  133|       |      }
  134|  1.10k|   }
_ZN3glz3getILm6ETkNS_12tuple_detail9indexableENS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERN12jsonrpc_fuzz5pointERNSC_6nestedERNS4_6vectorIiNS8_IiEEEERNS4_3mapISA_iNS4_4lessISA_EENS8_INS4_4pairIKSA_iEEEEEERNS4_8optionalIdEERNS4_7variantIJSA_NSC_6amountEEEERNS4_8functionIFiiEEERNS11_IFSA_RSP_EEERNS11_IFSD_RKSD_EEERNS11_IFdRNSH_IdNS8_IdEEEEEEERNS11_IFvvEEEEEEEEDcOT0_:
  116|  1.52k|   {
  117|  1.52k|      using D = std::remove_cvref_t<Tup>;
  118|  1.52k|      if constexpr (tuple_detail::is_tuple<D>) {
  119|  1.52k|         static_assert(I < D::N, "glz::get index is out of range");
  120|  1.52k|         using T = typename D::template type_at<I>;
  121|       |         if constexpr (std::is_reference_v<Tup> || std::is_const_v<std::remove_reference_t<Tup>>) {
  122|       |            // An lvalue, or a const tuple of either value category: element access carries the
  123|       |            // constness of the tuple, except for elements that are themselves references.
  124|       |            using leaf = tuple_detail::match_const_t<std::remove_reference_t<Tup>, tuple_detail::elem<I, T>>;
  125|       |            return (static_cast<leaf&>(tup).value);
  126|       |         }
  127|  1.52k|         else {
  128|  1.52k|            return static_cast<T&&>(static_cast<tuple_detail::elem<I, T>&>(tup).value);
  129|  1.52k|         }
  130|       |      }
  131|       |      else {
  132|       |         return (static_cast<Tup&&>(tup)[I]);
  133|       |      }
  134|  1.52k|   }
_ZN3glz3getILm0ETkNS_12tuple_detail9indexableENS_5tupleIJRdEEEEEDcOT0_:
  116|    303|   {
  117|    303|      using D = std::remove_cvref_t<Tup>;
  118|    303|      if constexpr (tuple_detail::is_tuple<D>) {
  119|    303|         static_assert(I < D::N, "glz::get index is out of range");
  120|    303|         using T = typename D::template type_at<I>;
  121|       |         if constexpr (std::is_reference_v<Tup> || std::is_const_v<std::remove_reference_t<Tup>>) {
  122|       |            // An lvalue, or a const tuple of either value category: element access carries the
  123|       |            // constness of the tuple, except for elements that are themselves references.
  124|       |            using leaf = tuple_detail::match_const_t<std::remove_reference_t<Tup>, tuple_detail::elem<I, T>>;
  125|       |            return (static_cast<leaf&>(tup).value);
  126|       |         }
  127|    303|         else {
  128|    303|            return static_cast<T&&>(static_cast<tuple_detail::elem<I, T>&>(tup).value);
  129|    303|         }
  130|       |      }
  131|       |      else {
  132|       |         return (static_cast<Tup&&>(tup)[I]);
  133|       |      }
  134|    303|   }
_ZN3glz3tieIJdEEENS_5tupleIJDpRT_EEES4_:
  325|    303|   {
  326|    303|      return {{{ts}...}};
  327|    303|   }
_ZN3glz3getILm7ETkNS_12tuple_detail9indexableENS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERN12jsonrpc_fuzz5pointERNSC_6nestedERNS4_6vectorIiNS8_IiEEEERNS4_3mapISA_iNS4_4lessISA_EENS8_INS4_4pairIKSA_iEEEEEERNS4_8optionalIdEERNS4_7variantIJSA_NSC_6amountEEEERNS4_8functionIFiiEEERNS11_IFSA_RSP_EEERNS11_IFSD_RKSD_EEERNS11_IFdRNSH_IdNS8_IdEEEEEEERNS11_IFvvEEEEEEEEDcOT0_:
  116|    696|   {
  117|    696|      using D = std::remove_cvref_t<Tup>;
  118|    696|      if constexpr (tuple_detail::is_tuple<D>) {
  119|    696|         static_assert(I < D::N, "glz::get index is out of range");
  120|    696|         using T = typename D::template type_at<I>;
  121|       |         if constexpr (std::is_reference_v<Tup> || std::is_const_v<std::remove_reference_t<Tup>>) {
  122|       |            // An lvalue, or a const tuple of either value category: element access carries the
  123|       |            // constness of the tuple, except for elements that are themselves references.
  124|       |            using leaf = tuple_detail::match_const_t<std::remove_reference_t<Tup>, tuple_detail::elem<I, T>>;
  125|       |            return (static_cast<leaf&>(tup).value);
  126|       |         }
  127|    696|         else {
  128|    696|            return static_cast<T&&>(static_cast<tuple_detail::elem<I, T>&>(tup).value);
  129|    696|         }
  130|       |      }
  131|       |      else {
  132|       |         return (static_cast<Tup&&>(tup)[I]);
  133|       |      }
  134|    696|   }
_ZN3glz3getILm8ETkNS_12tuple_detail9indexableENS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERN12jsonrpc_fuzz5pointERNSC_6nestedERNS4_6vectorIiNS8_IiEEEERNS4_3mapISA_iNS4_4lessISA_EENS8_INS4_4pairIKSA_iEEEEEERNS4_8optionalIdEERNS4_7variantIJSA_NSC_6amountEEEERNS4_8functionIFiiEEERNS11_IFSA_RSP_EEERNS11_IFSD_RKSD_EEERNS11_IFdRNSH_IdNS8_IdEEEEEEERNS11_IFvvEEEEEEEEDcOT0_:
  116|    239|   {
  117|    239|      using D = std::remove_cvref_t<Tup>;
  118|    239|      if constexpr (tuple_detail::is_tuple<D>) {
  119|    239|         static_assert(I < D::N, "glz::get index is out of range");
  120|    239|         using T = typename D::template type_at<I>;
  121|       |         if constexpr (std::is_reference_v<Tup> || std::is_const_v<std::remove_reference_t<Tup>>) {
  122|       |            // An lvalue, or a const tuple of either value category: element access carries the
  123|       |            // constness of the tuple, except for elements that are themselves references.
  124|       |            using leaf = tuple_detail::match_const_t<std::remove_reference_t<Tup>, tuple_detail::elem<I, T>>;
  125|       |            return (static_cast<leaf&>(tup).value);
  126|       |         }
  127|    239|         else {
  128|    239|            return static_cast<T&&>(static_cast<tuple_detail::elem<I, T>&>(tup).value);
  129|    239|         }
  130|       |      }
  131|       |      else {
  132|       |         return (static_cast<Tup&&>(tup)[I]);
  133|       |      }
  134|    239|   }
_ZN3glz3getILm9ETkNS_12tuple_detail9indexableENS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERN12jsonrpc_fuzz5pointERNSC_6nestedERNS4_6vectorIiNS8_IiEEEERNS4_3mapISA_iNS4_4lessISA_EENS8_INS4_4pairIKSA_iEEEEEERNS4_8optionalIdEERNS4_7variantIJSA_NSC_6amountEEEERNS4_8functionIFiiEEERNS11_IFSA_RSP_EEERNS11_IFSD_RKSD_EEERNS11_IFdRNSH_IdNS8_IdEEEEEEERNS11_IFvvEEEEEEEEDcOT0_:
  116|  8.18k|   {
  117|  8.18k|      using D = std::remove_cvref_t<Tup>;
  118|  8.18k|      if constexpr (tuple_detail::is_tuple<D>) {
  119|  8.18k|         static_assert(I < D::N, "glz::get index is out of range");
  120|  8.18k|         using T = typename D::template type_at<I>;
  121|       |         if constexpr (std::is_reference_v<Tup> || std::is_const_v<std::remove_reference_t<Tup>>) {
  122|       |            // An lvalue, or a const tuple of either value category: element access carries the
  123|       |            // constness of the tuple, except for elements that are themselves references.
  124|       |            using leaf = tuple_detail::match_const_t<std::remove_reference_t<Tup>, tuple_detail::elem<I, T>>;
  125|       |            return (static_cast<leaf&>(tup).value);
  126|       |         }
  127|  8.18k|         else {
  128|  8.18k|            return static_cast<T&&>(static_cast<tuple_detail::elem<I, T>&>(tup).value);
  129|  8.18k|         }
  130|       |      }
  131|       |      else {
  132|       |         return (static_cast<Tup&&>(tup)[I]);
  133|       |      }
  134|  8.18k|   }
_ZN3glz3getILm10ETkNS_12tuple_detail9indexableENS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERN12jsonrpc_fuzz5pointERNSC_6nestedERNS4_6vectorIiNS8_IiEEEERNS4_3mapISA_iNS4_4lessISA_EENS8_INS4_4pairIKSA_iEEEEEERNS4_8optionalIdEERNS4_7variantIJSA_NSC_6amountEEEERNS4_8functionIFiiEEERNS11_IFSA_RSP_EEERNS11_IFSD_RKSD_EEERNS11_IFdRNSH_IdNS8_IdEEEEEEERNS11_IFvvEEEEEEEEDcOT0_:
  116|     50|   {
  117|     50|      using D = std::remove_cvref_t<Tup>;
  118|     50|      if constexpr (tuple_detail::is_tuple<D>) {
  119|     50|         static_assert(I < D::N, "glz::get index is out of range");
  120|     50|         using T = typename D::template type_at<I>;
  121|       |         if constexpr (std::is_reference_v<Tup> || std::is_const_v<std::remove_reference_t<Tup>>) {
  122|       |            // An lvalue, or a const tuple of either value category: element access carries the
  123|       |            // constness of the tuple, except for elements that are themselves references.
  124|       |            using leaf = tuple_detail::match_const_t<std::remove_reference_t<Tup>, tuple_detail::elem<I, T>>;
  125|       |            return (static_cast<leaf&>(tup).value);
  126|       |         }
  127|     50|         else {
  128|     50|            return static_cast<T&&>(static_cast<tuple_detail::elem<I, T>&>(tup).value);
  129|     50|         }
  130|       |      }
  131|       |      else {
  132|       |         return (static_cast<Tup&&>(tup)[I]);
  133|       |      }
  134|     50|   }
_ZN3glz3getILm11ETkNS_12tuple_detail9indexableENS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERN12jsonrpc_fuzz5pointERNSC_6nestedERNS4_6vectorIiNS8_IiEEEERNS4_3mapISA_iNS4_4lessISA_EENS8_INS4_4pairIKSA_iEEEEEERNS4_8optionalIdEERNS4_7variantIJSA_NSC_6amountEEEERNS4_8functionIFiiEEERNS11_IFSA_RSP_EEERNS11_IFSD_RKSD_EEERNS11_IFdRNSH_IdNS8_IdEEEEEEERNS11_IFvvEEEEEEEEDcOT0_:
  116|     38|   {
  117|     38|      using D = std::remove_cvref_t<Tup>;
  118|     38|      if constexpr (tuple_detail::is_tuple<D>) {
  119|     38|         static_assert(I < D::N, "glz::get index is out of range");
  120|     38|         using T = typename D::template type_at<I>;
  121|       |         if constexpr (std::is_reference_v<Tup> || std::is_const_v<std::remove_reference_t<Tup>>) {
  122|       |            // An lvalue, or a const tuple of either value category: element access carries the
  123|       |            // constness of the tuple, except for elements that are themselves references.
  124|       |            using leaf = tuple_detail::match_const_t<std::remove_reference_t<Tup>, tuple_detail::elem<I, T>>;
  125|       |            return (static_cast<leaf&>(tup).value);
  126|       |         }
  127|     38|         else {
  128|     38|            return static_cast<T&&>(static_cast<tuple_detail::elem<I, T>&>(tup).value);
  129|     38|         }
  130|       |      }
  131|       |      else {
  132|       |         return (static_cast<Tup&&>(tup)[I]);
  133|       |      }
  134|     38|   }
_ZN3glz3getILm12ETkNS_12tuple_detail9indexableENS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERN12jsonrpc_fuzz5pointERNSC_6nestedERNS4_6vectorIiNS8_IiEEEERNS4_3mapISA_iNS4_4lessISA_EENS8_INS4_4pairIKSA_iEEEEEERNS4_8optionalIdEERNS4_7variantIJSA_NSC_6amountEEEERNS4_8functionIFiiEEERNS11_IFSA_RSP_EEERNS11_IFSD_RKSD_EEERNS11_IFdRNSH_IdNS8_IdEEEEEEERNS11_IFvvEEEEEEEEDcOT0_:
  116|    122|   {
  117|    122|      using D = std::remove_cvref_t<Tup>;
  118|    122|      if constexpr (tuple_detail::is_tuple<D>) {
  119|    122|         static_assert(I < D::N, "glz::get index is out of range");
  120|    122|         using T = typename D::template type_at<I>;
  121|       |         if constexpr (std::is_reference_v<Tup> || std::is_const_v<std::remove_reference_t<Tup>>) {
  122|       |            // An lvalue, or a const tuple of either value category: element access carries the
  123|       |            // constness of the tuple, except for elements that are themselves references.
  124|       |            using leaf = tuple_detail::match_const_t<std::remove_reference_t<Tup>, tuple_detail::elem<I, T>>;
  125|       |            return (static_cast<leaf&>(tup).value);
  126|       |         }
  127|    122|         else {
  128|    122|            return static_cast<T&&>(static_cast<tuple_detail::elem<I, T>&>(tup).value);
  129|    122|         }
  130|       |      }
  131|       |      else {
  132|       |         return (static_cast<Tup&&>(tup)[I]);
  133|       |      }
  134|    122|   }
_ZN3glz3getILm0ETkNS_12tuple_detail9indexableERNS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERN12jsonrpc_fuzz5pointERNSC_6nestedERNS4_6vectorIiNS8_IiEEEERNS4_3mapISA_iNS4_4lessISA_EENS8_INS4_4pairIKSA_iEEEEEERNS4_8optionalIdEERNS4_7variantIJSA_NSC_6amountEEEERNS4_8functionIFiiEEERNS11_IFSA_RSP_EEERNS11_IFSD_RKSD_EEERNS11_IFdRNSH_IdNS8_IdEEEEEEERNS11_IFvvEEEEEEEEDcOT0_:
  116|  61.1k|   {
  117|  61.1k|      using D = std::remove_cvref_t<Tup>;
  118|  61.1k|      if constexpr (tuple_detail::is_tuple<D>) {
  119|  61.1k|         static_assert(I < D::N, "glz::get index is out of range");
  120|  61.1k|         using T = typename D::template type_at<I>;
  121|  61.1k|         if constexpr (std::is_reference_v<Tup> || std::is_const_v<std::remove_reference_t<Tup>>) {
  122|       |            // An lvalue, or a const tuple of either value category: element access carries the
  123|       |            // constness of the tuple, except for elements that are themselves references.
  124|  61.1k|            using leaf = tuple_detail::match_const_t<std::remove_reference_t<Tup>, tuple_detail::elem<I, T>>;
  125|  61.1k|            return (static_cast<leaf&>(tup).value);
  126|       |         }
  127|       |         else {
  128|       |            return static_cast<T&&>(static_cast<tuple_detail::elem<I, T>&>(tup).value);
  129|       |         }
  130|       |      }
  131|       |      else {
  132|       |         return (static_cast<Tup&&>(tup)[I]);
  133|       |      }
  134|  61.1k|   }
_ZN3glz3getILm1ETkNS_12tuple_detail9indexableERNS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERN12jsonrpc_fuzz5pointERNSC_6nestedERNS4_6vectorIiNS8_IiEEEERNS4_3mapISA_iNS4_4lessISA_EENS8_INS4_4pairIKSA_iEEEEEERNS4_8optionalIdEERNS4_7variantIJSA_NSC_6amountEEEERNS4_8functionIFiiEEERNS11_IFSA_RSP_EEERNS11_IFSD_RKSD_EEERNS11_IFdRNSH_IdNS8_IdEEEEEEERNS11_IFvvEEEEEEEEDcOT0_:
  116|  61.1k|   {
  117|  61.1k|      using D = std::remove_cvref_t<Tup>;
  118|  61.1k|      if constexpr (tuple_detail::is_tuple<D>) {
  119|  61.1k|         static_assert(I < D::N, "glz::get index is out of range");
  120|  61.1k|         using T = typename D::template type_at<I>;
  121|  61.1k|         if constexpr (std::is_reference_v<Tup> || std::is_const_v<std::remove_reference_t<Tup>>) {
  122|       |            // An lvalue, or a const tuple of either value category: element access carries the
  123|       |            // constness of the tuple, except for elements that are themselves references.
  124|  61.1k|            using leaf = tuple_detail::match_const_t<std::remove_reference_t<Tup>, tuple_detail::elem<I, T>>;
  125|  61.1k|            return (static_cast<leaf&>(tup).value);
  126|       |         }
  127|       |         else {
  128|       |            return static_cast<T&&>(static_cast<tuple_detail::elem<I, T>&>(tup).value);
  129|       |         }
  130|       |      }
  131|       |      else {
  132|       |         return (static_cast<Tup&&>(tup)[I]);
  133|       |      }
  134|  61.1k|   }
_ZN3glz3getILm2ETkNS_12tuple_detail9indexableERNS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERN12jsonrpc_fuzz5pointERNSC_6nestedERNS4_6vectorIiNS8_IiEEEERNS4_3mapISA_iNS4_4lessISA_EENS8_INS4_4pairIKSA_iEEEEEERNS4_8optionalIdEERNS4_7variantIJSA_NSC_6amountEEEERNS4_8functionIFiiEEERNS11_IFSA_RSP_EEERNS11_IFSD_RKSD_EEERNS11_IFdRNSH_IdNS8_IdEEEEEEERNS11_IFvvEEEEEEEEDcOT0_:
  116|  61.1k|   {
  117|  61.1k|      using D = std::remove_cvref_t<Tup>;
  118|  61.1k|      if constexpr (tuple_detail::is_tuple<D>) {
  119|  61.1k|         static_assert(I < D::N, "glz::get index is out of range");
  120|  61.1k|         using T = typename D::template type_at<I>;
  121|  61.1k|         if constexpr (std::is_reference_v<Tup> || std::is_const_v<std::remove_reference_t<Tup>>) {
  122|       |            // An lvalue, or a const tuple of either value category: element access carries the
  123|       |            // constness of the tuple, except for elements that are themselves references.
  124|  61.1k|            using leaf = tuple_detail::match_const_t<std::remove_reference_t<Tup>, tuple_detail::elem<I, T>>;
  125|  61.1k|            return (static_cast<leaf&>(tup).value);
  126|       |         }
  127|       |         else {
  128|       |            return static_cast<T&&>(static_cast<tuple_detail::elem<I, T>&>(tup).value);
  129|       |         }
  130|       |      }
  131|       |      else {
  132|       |         return (static_cast<Tup&&>(tup)[I]);
  133|       |      }
  134|  61.1k|   }
_ZN3glz3getILm0ETkNS_12tuple_detail9indexableERNS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEEEEDcOT0_:
  116|  61.2k|   {
  117|  61.2k|      using D = std::remove_cvref_t<Tup>;
  118|  61.2k|      if constexpr (tuple_detail::is_tuple<D>) {
  119|  61.2k|         static_assert(I < D::N, "glz::get index is out of range");
  120|  61.2k|         using T = typename D::template type_at<I>;
  121|  61.2k|         if constexpr (std::is_reference_v<Tup> || std::is_const_v<std::remove_reference_t<Tup>>) {
  122|       |            // An lvalue, or a const tuple of either value category: element access carries the
  123|       |            // constness of the tuple, except for elements that are themselves references.
  124|  61.2k|            using leaf = tuple_detail::match_const_t<std::remove_reference_t<Tup>, tuple_detail::elem<I, T>>;
  125|  61.2k|            return (static_cast<leaf&>(tup).value);
  126|       |         }
  127|       |         else {
  128|       |            return static_cast<T&&>(static_cast<tuple_detail::elem<I, T>&>(tup).value);
  129|       |         }
  130|       |      }
  131|       |      else {
  132|       |         return (static_cast<Tup&&>(tup)[I]);
  133|       |      }
  134|  61.2k|   }
_ZN3glz3getILm1ETkNS_12tuple_detail9indexableERNS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEEEEDcOT0_:
  116|  61.2k|   {
  117|  61.2k|      using D = std::remove_cvref_t<Tup>;
  118|  61.2k|      if constexpr (tuple_detail::is_tuple<D>) {
  119|  61.2k|         static_assert(I < D::N, "glz::get index is out of range");
  120|  61.2k|         using T = typename D::template type_at<I>;
  121|  61.2k|         if constexpr (std::is_reference_v<Tup> || std::is_const_v<std::remove_reference_t<Tup>>) {
  122|       |            // An lvalue, or a const tuple of either value category: element access carries the
  123|       |            // constness of the tuple, except for elements that are themselves references.
  124|  61.2k|            using leaf = tuple_detail::match_const_t<std::remove_reference_t<Tup>, tuple_detail::elem<I, T>>;
  125|  61.2k|            return (static_cast<leaf&>(tup).value);
  126|       |         }
  127|       |         else {
  128|       |            return static_cast<T&&>(static_cast<tuple_detail::elem<I, T>&>(tup).value);
  129|       |         }
  130|       |      }
  131|       |      else {
  132|       |         return (static_cast<Tup&&>(tup)[I]);
  133|       |      }
  134|  61.2k|   }
_ZN3glz3getILm3ETkNS_12tuple_detail9indexableERNS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERN12jsonrpc_fuzz5pointERNSC_6nestedERNS4_6vectorIiNS8_IiEEEERNS4_3mapISA_iNS4_4lessISA_EENS8_INS4_4pairIKSA_iEEEEEERNS4_8optionalIdEERNS4_7variantIJSA_NSC_6amountEEEERNS4_8functionIFiiEEERNS11_IFSA_RSP_EEERNS11_IFSD_RKSD_EEERNS11_IFdRNSH_IdNS8_IdEEEEEEERNS11_IFvvEEEEEEEEDcOT0_:
  116|  61.1k|   {
  117|  61.1k|      using D = std::remove_cvref_t<Tup>;
  118|  61.1k|      if constexpr (tuple_detail::is_tuple<D>) {
  119|  61.1k|         static_assert(I < D::N, "glz::get index is out of range");
  120|  61.1k|         using T = typename D::template type_at<I>;
  121|  61.1k|         if constexpr (std::is_reference_v<Tup> || std::is_const_v<std::remove_reference_t<Tup>>) {
  122|       |            // An lvalue, or a const tuple of either value category: element access carries the
  123|       |            // constness of the tuple, except for elements that are themselves references.
  124|  61.1k|            using leaf = tuple_detail::match_const_t<std::remove_reference_t<Tup>, tuple_detail::elem<I, T>>;
  125|  61.1k|            return (static_cast<leaf&>(tup).value);
  126|       |         }
  127|       |         else {
  128|       |            return static_cast<T&&>(static_cast<tuple_detail::elem<I, T>&>(tup).value);
  129|       |         }
  130|       |      }
  131|       |      else {
  132|       |         return (static_cast<Tup&&>(tup)[I]);
  133|       |      }
  134|  61.1k|   }
_ZN3glz3getILm4ETkNS_12tuple_detail9indexableERNS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERN12jsonrpc_fuzz5pointERNSC_6nestedERNS4_6vectorIiNS8_IiEEEERNS4_3mapISA_iNS4_4lessISA_EENS8_INS4_4pairIKSA_iEEEEEERNS4_8optionalIdEERNS4_7variantIJSA_NSC_6amountEEEERNS4_8functionIFiiEEERNS11_IFSA_RSP_EEERNS11_IFSD_RKSD_EEERNS11_IFdRNSH_IdNS8_IdEEEEEEERNS11_IFvvEEEEEEEEDcOT0_:
  116|  61.1k|   {
  117|  61.1k|      using D = std::remove_cvref_t<Tup>;
  118|  61.1k|      if constexpr (tuple_detail::is_tuple<D>) {
  119|  61.1k|         static_assert(I < D::N, "glz::get index is out of range");
  120|  61.1k|         using T = typename D::template type_at<I>;
  121|  61.1k|         if constexpr (std::is_reference_v<Tup> || std::is_const_v<std::remove_reference_t<Tup>>) {
  122|       |            // An lvalue, or a const tuple of either value category: element access carries the
  123|       |            // constness of the tuple, except for elements that are themselves references.
  124|  61.1k|            using leaf = tuple_detail::match_const_t<std::remove_reference_t<Tup>, tuple_detail::elem<I, T>>;
  125|  61.1k|            return (static_cast<leaf&>(tup).value);
  126|       |         }
  127|       |         else {
  128|       |            return static_cast<T&&>(static_cast<tuple_detail::elem<I, T>&>(tup).value);
  129|       |         }
  130|       |      }
  131|       |      else {
  132|       |         return (static_cast<Tup&&>(tup)[I]);
  133|       |      }
  134|  61.1k|   }
_ZN3glz3getILm5ETkNS_12tuple_detail9indexableERNS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERN12jsonrpc_fuzz5pointERNSC_6nestedERNS4_6vectorIiNS8_IiEEEERNS4_3mapISA_iNS4_4lessISA_EENS8_INS4_4pairIKSA_iEEEEEERNS4_8optionalIdEERNS4_7variantIJSA_NSC_6amountEEEERNS4_8functionIFiiEEERNS11_IFSA_RSP_EEERNS11_IFSD_RKSD_EEERNS11_IFdRNSH_IdNS8_IdEEEEEEERNS11_IFvvEEEEEEEEDcOT0_:
  116|  61.1k|   {
  117|  61.1k|      using D = std::remove_cvref_t<Tup>;
  118|  61.1k|      if constexpr (tuple_detail::is_tuple<D>) {
  119|  61.1k|         static_assert(I < D::N, "glz::get index is out of range");
  120|  61.1k|         using T = typename D::template type_at<I>;
  121|  61.1k|         if constexpr (std::is_reference_v<Tup> || std::is_const_v<std::remove_reference_t<Tup>>) {
  122|       |            // An lvalue, or a const tuple of either value category: element access carries the
  123|       |            // constness of the tuple, except for elements that are themselves references.
  124|  61.1k|            using leaf = tuple_detail::match_const_t<std::remove_reference_t<Tup>, tuple_detail::elem<I, T>>;
  125|  61.1k|            return (static_cast<leaf&>(tup).value);
  126|       |         }
  127|       |         else {
  128|       |            return static_cast<T&&>(static_cast<tuple_detail::elem<I, T>&>(tup).value);
  129|       |         }
  130|       |      }
  131|       |      else {
  132|       |         return (static_cast<Tup&&>(tup)[I]);
  133|       |      }
  134|  61.1k|   }
_ZN3glz3getILm6ETkNS_12tuple_detail9indexableERNS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERN12jsonrpc_fuzz5pointERNSC_6nestedERNS4_6vectorIiNS8_IiEEEERNS4_3mapISA_iNS4_4lessISA_EENS8_INS4_4pairIKSA_iEEEEEERNS4_8optionalIdEERNS4_7variantIJSA_NSC_6amountEEEERNS4_8functionIFiiEEERNS11_IFSA_RSP_EEERNS11_IFSD_RKSD_EEERNS11_IFdRNSH_IdNS8_IdEEEEEEERNS11_IFvvEEEEEEEEDcOT0_:
  116|  61.1k|   {
  117|  61.1k|      using D = std::remove_cvref_t<Tup>;
  118|  61.1k|      if constexpr (tuple_detail::is_tuple<D>) {
  119|  61.1k|         static_assert(I < D::N, "glz::get index is out of range");
  120|  61.1k|         using T = typename D::template type_at<I>;
  121|  61.1k|         if constexpr (std::is_reference_v<Tup> || std::is_const_v<std::remove_reference_t<Tup>>) {
  122|       |            // An lvalue, or a const tuple of either value category: element access carries the
  123|       |            // constness of the tuple, except for elements that are themselves references.
  124|  61.1k|            using leaf = tuple_detail::match_const_t<std::remove_reference_t<Tup>, tuple_detail::elem<I, T>>;
  125|  61.1k|            return (static_cast<leaf&>(tup).value);
  126|       |         }
  127|       |         else {
  128|       |            return static_cast<T&&>(static_cast<tuple_detail::elem<I, T>&>(tup).value);
  129|       |         }
  130|       |      }
  131|       |      else {
  132|       |         return (static_cast<Tup&&>(tup)[I]);
  133|       |      }
  134|  61.1k|   }
_ZN3glz3getILm7ETkNS_12tuple_detail9indexableERNS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERN12jsonrpc_fuzz5pointERNSC_6nestedERNS4_6vectorIiNS8_IiEEEERNS4_3mapISA_iNS4_4lessISA_EENS8_INS4_4pairIKSA_iEEEEEERNS4_8optionalIdEERNS4_7variantIJSA_NSC_6amountEEEERNS4_8functionIFiiEEERNS11_IFSA_RSP_EEERNS11_IFSD_RKSD_EEERNS11_IFdRNSH_IdNS8_IdEEEEEEERNS11_IFvvEEEEEEEEDcOT0_:
  116|  61.1k|   {
  117|  61.1k|      using D = std::remove_cvref_t<Tup>;
  118|  61.1k|      if constexpr (tuple_detail::is_tuple<D>) {
  119|  61.1k|         static_assert(I < D::N, "glz::get index is out of range");
  120|  61.1k|         using T = typename D::template type_at<I>;
  121|  61.1k|         if constexpr (std::is_reference_v<Tup> || std::is_const_v<std::remove_reference_t<Tup>>) {
  122|       |            // An lvalue, or a const tuple of either value category: element access carries the
  123|       |            // constness of the tuple, except for elements that are themselves references.
  124|  61.1k|            using leaf = tuple_detail::match_const_t<std::remove_reference_t<Tup>, tuple_detail::elem<I, T>>;
  125|  61.1k|            return (static_cast<leaf&>(tup).value);
  126|       |         }
  127|       |         else {
  128|       |            return static_cast<T&&>(static_cast<tuple_detail::elem<I, T>&>(tup).value);
  129|       |         }
  130|       |      }
  131|       |      else {
  132|       |         return (static_cast<Tup&&>(tup)[I]);
  133|       |      }
  134|  61.1k|   }
_ZN3glz3getILm8ETkNS_12tuple_detail9indexableERNS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERN12jsonrpc_fuzz5pointERNSC_6nestedERNS4_6vectorIiNS8_IiEEEERNS4_3mapISA_iNS4_4lessISA_EENS8_INS4_4pairIKSA_iEEEEEERNS4_8optionalIdEERNS4_7variantIJSA_NSC_6amountEEEERNS4_8functionIFiiEEERNS11_IFSA_RSP_EEERNS11_IFSD_RKSD_EEERNS11_IFdRNSH_IdNS8_IdEEEEEEERNS11_IFvvEEEEEEEEDcOT0_:
  116|  61.1k|   {
  117|  61.1k|      using D = std::remove_cvref_t<Tup>;
  118|  61.1k|      if constexpr (tuple_detail::is_tuple<D>) {
  119|  61.1k|         static_assert(I < D::N, "glz::get index is out of range");
  120|  61.1k|         using T = typename D::template type_at<I>;
  121|  61.1k|         if constexpr (std::is_reference_v<Tup> || std::is_const_v<std::remove_reference_t<Tup>>) {
  122|       |            // An lvalue, or a const tuple of either value category: element access carries the
  123|       |            // constness of the tuple, except for elements that are themselves references.
  124|  61.1k|            using leaf = tuple_detail::match_const_t<std::remove_reference_t<Tup>, tuple_detail::elem<I, T>>;
  125|  61.1k|            return (static_cast<leaf&>(tup).value);
  126|       |         }
  127|       |         else {
  128|       |            return static_cast<T&&>(static_cast<tuple_detail::elem<I, T>&>(tup).value);
  129|       |         }
  130|       |      }
  131|       |      else {
  132|       |         return (static_cast<Tup&&>(tup)[I]);
  133|       |      }
  134|  61.1k|   }
_ZN3glz3getILm9ETkNS_12tuple_detail9indexableERNS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERN12jsonrpc_fuzz5pointERNSC_6nestedERNS4_6vectorIiNS8_IiEEEERNS4_3mapISA_iNS4_4lessISA_EENS8_INS4_4pairIKSA_iEEEEEERNS4_8optionalIdEERNS4_7variantIJSA_NSC_6amountEEEERNS4_8functionIFiiEEERNS11_IFSA_RSP_EEERNS11_IFSD_RKSD_EEERNS11_IFdRNSH_IdNS8_IdEEEEEEERNS11_IFvvEEEEEEEEDcOT0_:
  116|  61.1k|   {
  117|  61.1k|      using D = std::remove_cvref_t<Tup>;
  118|  61.1k|      if constexpr (tuple_detail::is_tuple<D>) {
  119|  61.1k|         static_assert(I < D::N, "glz::get index is out of range");
  120|  61.1k|         using T = typename D::template type_at<I>;
  121|  61.1k|         if constexpr (std::is_reference_v<Tup> || std::is_const_v<std::remove_reference_t<Tup>>) {
  122|       |            // An lvalue, or a const tuple of either value category: element access carries the
  123|       |            // constness of the tuple, except for elements that are themselves references.
  124|  61.1k|            using leaf = tuple_detail::match_const_t<std::remove_reference_t<Tup>, tuple_detail::elem<I, T>>;
  125|  61.1k|            return (static_cast<leaf&>(tup).value);
  126|       |         }
  127|       |         else {
  128|       |            return static_cast<T&&>(static_cast<tuple_detail::elem<I, T>&>(tup).value);
  129|       |         }
  130|       |      }
  131|       |      else {
  132|       |         return (static_cast<Tup&&>(tup)[I]);
  133|       |      }
  134|  61.1k|   }
_ZN3glz3getILm10ETkNS_12tuple_detail9indexableERNS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERN12jsonrpc_fuzz5pointERNSC_6nestedERNS4_6vectorIiNS8_IiEEEERNS4_3mapISA_iNS4_4lessISA_EENS8_INS4_4pairIKSA_iEEEEEERNS4_8optionalIdEERNS4_7variantIJSA_NSC_6amountEEEERNS4_8functionIFiiEEERNS11_IFSA_RSP_EEERNS11_IFSD_RKSD_EEERNS11_IFdRNSH_IdNS8_IdEEEEEEERNS11_IFvvEEEEEEEEDcOT0_:
  116|  61.1k|   {
  117|  61.1k|      using D = std::remove_cvref_t<Tup>;
  118|  61.1k|      if constexpr (tuple_detail::is_tuple<D>) {
  119|  61.1k|         static_assert(I < D::N, "glz::get index is out of range");
  120|  61.1k|         using T = typename D::template type_at<I>;
  121|  61.1k|         if constexpr (std::is_reference_v<Tup> || std::is_const_v<std::remove_reference_t<Tup>>) {
  122|       |            // An lvalue, or a const tuple of either value category: element access carries the
  123|       |            // constness of the tuple, except for elements that are themselves references.
  124|  61.1k|            using leaf = tuple_detail::match_const_t<std::remove_reference_t<Tup>, tuple_detail::elem<I, T>>;
  125|  61.1k|            return (static_cast<leaf&>(tup).value);
  126|       |         }
  127|       |         else {
  128|       |            return static_cast<T&&>(static_cast<tuple_detail::elem<I, T>&>(tup).value);
  129|       |         }
  130|       |      }
  131|       |      else {
  132|       |         return (static_cast<Tup&&>(tup)[I]);
  133|       |      }
  134|  61.1k|   }
_ZN3glz3getILm11ETkNS_12tuple_detail9indexableERNS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERN12jsonrpc_fuzz5pointERNSC_6nestedERNS4_6vectorIiNS8_IiEEEERNS4_3mapISA_iNS4_4lessISA_EENS8_INS4_4pairIKSA_iEEEEEERNS4_8optionalIdEERNS4_7variantIJSA_NSC_6amountEEEERNS4_8functionIFiiEEERNS11_IFSA_RSP_EEERNS11_IFSD_RKSD_EEERNS11_IFdRNSH_IdNS8_IdEEEEEEERNS11_IFvvEEEEEEEEDcOT0_:
  116|  61.1k|   {
  117|  61.1k|      using D = std::remove_cvref_t<Tup>;
  118|  61.1k|      if constexpr (tuple_detail::is_tuple<D>) {
  119|  61.1k|         static_assert(I < D::N, "glz::get index is out of range");
  120|  61.1k|         using T = typename D::template type_at<I>;
  121|  61.1k|         if constexpr (std::is_reference_v<Tup> || std::is_const_v<std::remove_reference_t<Tup>>) {
  122|       |            // An lvalue, or a const tuple of either value category: element access carries the
  123|       |            // constness of the tuple, except for elements that are themselves references.
  124|  61.1k|            using leaf = tuple_detail::match_const_t<std::remove_reference_t<Tup>, tuple_detail::elem<I, T>>;
  125|  61.1k|            return (static_cast<leaf&>(tup).value);
  126|       |         }
  127|       |         else {
  128|       |            return static_cast<T&&>(static_cast<tuple_detail::elem<I, T>&>(tup).value);
  129|       |         }
  130|       |      }
  131|       |      else {
  132|       |         return (static_cast<Tup&&>(tup)[I]);
  133|       |      }
  134|  61.1k|   }
_ZN3glz3getILm12ETkNS_12tuple_detail9indexableERNS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERN12jsonrpc_fuzz5pointERNSC_6nestedERNS4_6vectorIiNS8_IiEEEERNS4_3mapISA_iNS4_4lessISA_EENS8_INS4_4pairIKSA_iEEEEEERNS4_8optionalIdEERNS4_7variantIJSA_NSC_6amountEEEERNS4_8functionIFiiEEERNS11_IFSA_RSP_EEERNS11_IFSD_RKSD_EEERNS11_IFdRNSH_IdNS8_IdEEEEEEERNS11_IFvvEEEEEEEEDcOT0_:
  116|  61.1k|   {
  117|  61.1k|      using D = std::remove_cvref_t<Tup>;
  118|  61.1k|      if constexpr (tuple_detail::is_tuple<D>) {
  119|  61.1k|         static_assert(I < D::N, "glz::get index is out of range");
  120|  61.1k|         using T = typename D::template type_at<I>;
  121|  61.1k|         if constexpr (std::is_reference_v<Tup> || std::is_const_v<std::remove_reference_t<Tup>>) {
  122|       |            // An lvalue, or a const tuple of either value category: element access carries the
  123|       |            // constness of the tuple, except for elements that are themselves references.
  124|  61.1k|            using leaf = tuple_detail::match_const_t<std::remove_reference_t<Tup>, tuple_detail::elem<I, T>>;
  125|  61.1k|            return (static_cast<leaf&>(tup).value);
  126|       |         }
  127|       |         else {
  128|       |            return static_cast<T&&>(static_cast<tuple_detail::elem<I, T>&>(tup).value);
  129|       |         }
  130|       |      }
  131|       |      else {
  132|       |         return (static_cast<Tup&&>(tup)[I]);
  133|       |      }
  134|  61.1k|   }
_ZN3glz3getILm0ETkNS_12tuple_detail9indexableERKNS_5tupleIJMNS_3rpc18request_envelope_tENSt3__18optionalINS5_17basic_string_viewIcNS5_11char_traitsIcEEEEEESC_MS4_NS_14basic_raw_jsonISA_EEMS4_NS5_7variantIJDnSA_lEEEEEEEEDcOT0_:
  116|  60.0k|   {
  117|  60.0k|      using D = std::remove_cvref_t<Tup>;
  118|  60.0k|      if constexpr (tuple_detail::is_tuple<D>) {
  119|  60.0k|         static_assert(I < D::N, "glz::get index is out of range");
  120|  60.0k|         using T = typename D::template type_at<I>;
  121|  60.0k|         if constexpr (std::is_reference_v<Tup> || std::is_const_v<std::remove_reference_t<Tup>>) {
  122|       |            // An lvalue, or a const tuple of either value category: element access carries the
  123|       |            // constness of the tuple, except for elements that are themselves references.
  124|  60.0k|            using leaf = tuple_detail::match_const_t<std::remove_reference_t<Tup>, tuple_detail::elem<I, T>>;
  125|  60.0k|            return (static_cast<leaf&>(tup).value);
  126|       |         }
  127|       |         else {
  128|       |            return static_cast<T&&>(static_cast<tuple_detail::elem<I, T>&>(tup).value);
  129|       |         }
  130|       |      }
  131|       |      else {
  132|       |         return (static_cast<Tup&&>(tup)[I]);
  133|       |      }
  134|  60.0k|   }
_ZN3glz3getILm1ETkNS_12tuple_detail9indexableERKNS_5tupleIJMNS_3rpc18request_envelope_tENSt3__18optionalINS5_17basic_string_viewIcNS5_11char_traitsIcEEEEEESC_MS4_NS_14basic_raw_jsonISA_EEMS4_NS5_7variantIJDnSA_lEEEEEEEEDcOT0_:
  116|  50.8k|   {
  117|  50.8k|      using D = std::remove_cvref_t<Tup>;
  118|  50.8k|      if constexpr (tuple_detail::is_tuple<D>) {
  119|  50.8k|         static_assert(I < D::N, "glz::get index is out of range");
  120|  50.8k|         using T = typename D::template type_at<I>;
  121|  50.8k|         if constexpr (std::is_reference_v<Tup> || std::is_const_v<std::remove_reference_t<Tup>>) {
  122|       |            // An lvalue, or a const tuple of either value category: element access carries the
  123|       |            // constness of the tuple, except for elements that are themselves references.
  124|  50.8k|            using leaf = tuple_detail::match_const_t<std::remove_reference_t<Tup>, tuple_detail::elem<I, T>>;
  125|  50.8k|            return (static_cast<leaf&>(tup).value);
  126|       |         }
  127|       |         else {
  128|       |            return static_cast<T&&>(static_cast<tuple_detail::elem<I, T>&>(tup).value);
  129|       |         }
  130|       |      }
  131|       |      else {
  132|       |         return (static_cast<Tup&&>(tup)[I]);
  133|       |      }
  134|  50.8k|   }
_ZN3glz3getILm2ETkNS_12tuple_detail9indexableERKNS_5tupleIJMNS_3rpc18request_envelope_tENSt3__18optionalINS5_17basic_string_viewIcNS5_11char_traitsIcEEEEEESC_MS4_NS_14basic_raw_jsonISA_EEMS4_NS5_7variantIJDnSA_lEEEEEEEEDcOT0_:
  116|  36.1k|   {
  117|  36.1k|      using D = std::remove_cvref_t<Tup>;
  118|  36.1k|      if constexpr (tuple_detail::is_tuple<D>) {
  119|  36.1k|         static_assert(I < D::N, "glz::get index is out of range");
  120|  36.1k|         using T = typename D::template type_at<I>;
  121|  36.1k|         if constexpr (std::is_reference_v<Tup> || std::is_const_v<std::remove_reference_t<Tup>>) {
  122|       |            // An lvalue, or a const tuple of either value category: element access carries the
  123|       |            // constness of the tuple, except for elements that are themselves references.
  124|  36.1k|            using leaf = tuple_detail::match_const_t<std::remove_reference_t<Tup>, tuple_detail::elem<I, T>>;
  125|  36.1k|            return (static_cast<leaf&>(tup).value);
  126|       |         }
  127|       |         else {
  128|       |            return static_cast<T&&>(static_cast<tuple_detail::elem<I, T>&>(tup).value);
  129|       |         }
  130|       |      }
  131|       |      else {
  132|       |         return (static_cast<Tup&&>(tup)[I]);
  133|       |      }
  134|  36.1k|   }
_ZN3glz3getILm3ETkNS_12tuple_detail9indexableERKNS_5tupleIJMNS_3rpc18request_envelope_tENSt3__18optionalINS5_17basic_string_viewIcNS5_11char_traitsIcEEEEEESC_MS4_NS_14basic_raw_jsonISA_EEMS4_NS5_7variantIJDnSA_lEEEEEEEEDcOT0_:
  116|  89.5k|   {
  117|  89.5k|      using D = std::remove_cvref_t<Tup>;
  118|  89.5k|      if constexpr (tuple_detail::is_tuple<D>) {
  119|  89.5k|         static_assert(I < D::N, "glz::get index is out of range");
  120|  89.5k|         using T = typename D::template type_at<I>;
  121|  89.5k|         if constexpr (std::is_reference_v<Tup> || std::is_const_v<std::remove_reference_t<Tup>>) {
  122|       |            // An lvalue, or a const tuple of either value category: element access carries the
  123|       |            // constness of the tuple, except for elements that are themselves references.
  124|  89.5k|            using leaf = tuple_detail::match_const_t<std::remove_reference_t<Tup>, tuple_detail::elem<I, T>>;
  125|  89.5k|            return (static_cast<leaf&>(tup).value);
  126|       |         }
  127|       |         else {
  128|       |            return static_cast<T&&>(static_cast<tuple_detail::elem<I, T>&>(tup).value);
  129|       |         }
  130|       |      }
  131|       |      else {
  132|       |         return (static_cast<Tup&&>(tup)[I]);
  133|       |      }
  134|  89.5k|   }

_ZN3glz5writeITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEQ15write_supportedIT0_XdtT_6formatEEEENS2_8expectedIS8_NS_9error_ctxEEEOSB_:
   86|  49.3k|   {
   87|  49.3k|      std::string buffer{};
   88|  49.3k|      context ctx{};
   89|  49.3k|      const auto res = write<Opts>(std::forward<T>(value), buffer, ctx);
   90|  49.3k|      if (res) [[unlikely]] {
  ------------------
  |  Branch (90:11): [True: 0, False: 49.3k]
  ------------------
   91|      0|         return glz::unexpected(res);
   92|      0|      }
   93|  49.3k|      return {buffer};
   94|  49.3k|   }
_ZN3glz5writeITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEETkNS_13output_bufferES8_TkNS_10is_contextERNS_7contextEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSD_RT1_OT2_:
   18|  49.3k|   {
   19|  49.3k|      using traits = buffer_traits<std::remove_cvref_t<Buffer>>;
   20|       |
   21|  49.3k|      if constexpr (traits::is_resizable) {
   22|       |         // A buffer could be size 1, to ensure we have sufficient memory we can't just check `empty()`
   23|  49.3k|         if (buffer.size() < 2 * write_padding_bytes) {
  ------------------
  |  Branch (23:14): [True: 49.3k, False: 0]
  ------------------
   24|  49.3k|            buffer.resize(2 * write_padding_bytes);
   25|  49.3k|         }
   26|  49.3k|      }
   27|  49.3k|      size_t ix = 0; // overwrite index
   28|  49.3k|      to<Opts.format, std::remove_cvref_t<T>>::template op<Opts>(std::forward<T>(value), ctx, buffer, ix);
   29|       |
   30|  49.3k|      if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (30:11): [True: 0, False: 49.3k]
  ------------------
   31|      0|         return {ix, ctx.error, ctx.custom_error_message};
   32|      0|      }
   33|       |
   34|  49.3k|      traits::finalize(buffer, ix);
   35|  49.3k|      return {ix, error_code::none, ctx.custom_error_message};
   36|  49.3k|   }
_ZN3glz5writeITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERNSt3__17variantIJDnNS2_17basic_string_viewIcNS2_11char_traitsIcEEEElEEEQ15write_supportedIT0_XdtT_6formatEEEENS2_8expectedINS2_12basic_stringIcS6_NS2_9allocatorIcEEEENS_9error_ctxEEEOSA_:
   86|  47.7k|   {
   87|  47.7k|      std::string buffer{};
   88|  47.7k|      context ctx{};
   89|  47.7k|      const auto res = write<Opts>(std::forward<T>(value), buffer, ctx);
   90|  47.7k|      if (res) [[unlikely]] {
  ------------------
  |  Branch (90:11): [True: 0, False: 47.7k]
  ------------------
   91|      0|         return glz::unexpected(res);
   92|      0|      }
   93|  47.7k|      return {buffer};
   94|  47.7k|   }
_ZN3glz5writeITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERNSt3__17variantIJDnNS2_17basic_string_viewIcNS2_11char_traitsIcEEEElEEETkNS_13output_bufferENS2_12basic_stringIcS6_NS2_9allocatorIcEEEETkNS_10is_contextERNS_7contextEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSG_RT1_OT2_:
   18|  47.7k|   {
   19|  47.7k|      using traits = buffer_traits<std::remove_cvref_t<Buffer>>;
   20|       |
   21|  47.7k|      if constexpr (traits::is_resizable) {
   22|       |         // A buffer could be size 1, to ensure we have sufficient memory we can't just check `empty()`
   23|  47.7k|         if (buffer.size() < 2 * write_padding_bytes) {
  ------------------
  |  Branch (23:14): [True: 47.7k, False: 0]
  ------------------
   24|  47.7k|            buffer.resize(2 * write_padding_bytes);
   25|  47.7k|         }
   26|  47.7k|      }
   27|  47.7k|      size_t ix = 0; // overwrite index
   28|  47.7k|      to<Opts.format, std::remove_cvref_t<T>>::template op<Opts>(std::forward<T>(value), ctx, buffer, ix);
   29|       |
   30|  47.7k|      if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (30:11): [True: 0, False: 47.7k]
  ------------------
   31|      0|         return {ix, ctx.error, ctx.custom_error_message};
   32|      0|      }
   33|       |
   34|  47.7k|      traits::finalize(buffer, ix);
   35|  47.7k|      return {ix, error_code::none, ctx.custom_error_message};
   36|  47.7k|   }
_ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERiTkNS_13output_bufferENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSA_RT1_:
   78|    337|   {
   79|    337|      context ctx{};
   80|    337|      return write<Opts>(std::forward<T>(value), buffer, ctx);
   81|    337|   }
_ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERiTkNS_13output_bufferENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEETkNS_10is_contextERNS_7contextEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSC_RT1_OT2_:
   18|    337|   {
   19|    337|      using traits = buffer_traits<std::remove_cvref_t<Buffer>>;
   20|       |
   21|    337|      if constexpr (traits::is_resizable) {
   22|       |         // A buffer could be size 1, to ensure we have sufficient memory we can't just check `empty()`
   23|    337|         if (buffer.size() < 2 * write_padding_bytes) {
  ------------------
  |  Branch (23:14): [True: 337, False: 0]
  ------------------
   24|    337|            buffer.resize(2 * write_padding_bytes);
   25|    337|         }
   26|    337|      }
   27|    337|      size_t ix = 0; // overwrite index
   28|    337|      to<Opts.format, std::remove_cvref_t<T>>::template op<Opts>(std::forward<T>(value), ctx, buffer, ix);
   29|       |
   30|    337|      if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (30:11): [True: 0, False: 337]
  ------------------
   31|      0|         return {ix, ctx.error, ctx.custom_error_message};
   32|      0|      }
   33|       |
   34|    337|      traits::finalize(buffer, ix);
   35|    337|      return {ix, error_code::none, ctx.custom_error_message};
   36|    337|   }
_ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEiTkNS_13output_bufferENSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOS9_RT1_:
   78|    347|   {
   79|    347|      context ctx{};
   80|    347|      return write<Opts>(std::forward<T>(value), buffer, ctx);
   81|    347|   }
_ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEiTkNS_13output_bufferENSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEETkNS_10is_contextERNS_7contextEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSB_RT1_OT2_:
   18|    347|   {
   19|    347|      using traits = buffer_traits<std::remove_cvref_t<Buffer>>;
   20|       |
   21|    347|      if constexpr (traits::is_resizable) {
   22|       |         // A buffer could be size 1, to ensure we have sufficient memory we can't just check `empty()`
   23|    347|         if (buffer.size() < 2 * write_padding_bytes) {
  ------------------
  |  Branch (23:14): [True: 347, False: 0]
  ------------------
   24|    347|            buffer.resize(2 * write_padding_bytes);
   25|    347|         }
   26|    347|      }
   27|    347|      size_t ix = 0; // overwrite index
   28|    347|      to<Opts.format, std::remove_cvref_t<T>>::template op<Opts>(std::forward<T>(value), ctx, buffer, ix);
   29|       |
   30|    347|      if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (30:11): [True: 0, False: 347]
  ------------------
   31|      0|         return {ix, ctx.error, ctx.custom_error_message};
   32|      0|      }
   33|       |
   34|    347|      traits::finalize(buffer, ix);
   35|    347|      return {ix, error_code::none, ctx.custom_error_message};
   36|    347|   }
_ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz5pointETkNS_13output_bufferENSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSB_RT1_:
   78|    161|   {
   79|    161|      context ctx{};
   80|    161|      return write<Opts>(std::forward<T>(value), buffer, ctx);
   81|    161|   }
_ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz5pointETkNS_13output_bufferENSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEETkNS_10is_contextERNS_7contextEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSD_RT1_OT2_:
   18|    161|   {
   19|    161|      using traits = buffer_traits<std::remove_cvref_t<Buffer>>;
   20|       |
   21|    161|      if constexpr (traits::is_resizable) {
   22|       |         // A buffer could be size 1, to ensure we have sufficient memory we can't just check `empty()`
   23|    161|         if (buffer.size() < 2 * write_padding_bytes) {
  ------------------
  |  Branch (23:14): [True: 161, False: 0]
  ------------------
   24|    161|            buffer.resize(2 * write_padding_bytes);
   25|    161|         }
   26|    161|      }
   27|    161|      size_t ix = 0; // overwrite index
   28|    161|      to<Opts.format, std::remove_cvref_t<T>>::template op<Opts>(std::forward<T>(value), ctx, buffer, ix);
   29|       |
   30|    161|      if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (30:11): [True: 0, False: 161]
  ------------------
   31|      0|         return {ix, ctx.error, ctx.custom_error_message};
   32|      0|      }
   33|       |
   34|    161|      traits::finalize(buffer, ix);
   35|    161|      return {ix, error_code::none, ctx.custom_error_message};
   36|    161|   }
_ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERN12jsonrpc_fuzz8fuzz_apiETkNS_13output_bufferENSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSC_RT1_:
   78|     43|   {
   79|     43|      context ctx{};
   80|     43|      return write<Opts>(std::forward<T>(value), buffer, ctx);
   81|     43|   }
_ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERN12jsonrpc_fuzz8fuzz_apiETkNS_13output_bufferENSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEETkNS_10is_contextERNS_7contextEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSE_RT1_OT2_:
   18|     43|   {
   19|     43|      using traits = buffer_traits<std::remove_cvref_t<Buffer>>;
   20|       |
   21|     43|      if constexpr (traits::is_resizable) {
   22|       |         // A buffer could be size 1, to ensure we have sufficient memory we can't just check `empty()`
   23|     43|         if (buffer.size() < 2 * write_padding_bytes) {
  ------------------
  |  Branch (23:14): [True: 43, False: 0]
  ------------------
   24|     43|            buffer.resize(2 * write_padding_bytes);
   25|     43|         }
   26|     43|      }
   27|     43|      size_t ix = 0; // overwrite index
   28|     43|      to<Opts.format, std::remove_cvref_t<T>>::template op<Opts>(std::forward<T>(value), ctx, buffer, ix);
   29|       |
   30|     43|      if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (30:11): [True: 0, False: 43]
  ------------------
   31|      0|         return {ix, ctx.error, ctx.custom_error_message};
   32|      0|      }
   33|       |
   34|     43|      traits::finalize(buffer, ix);
   35|     43|      return {ix, error_code::none, ctx.custom_error_message};
   36|     43|   }
_ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEETkNS_13output_bufferES8_Q15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSA_RT1_:
   78|    611|   {
   79|    611|      context ctx{};
   80|    611|      return write<Opts>(std::forward<T>(value), buffer, ctx);
   81|    611|   }
_ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEETkNS_13output_bufferES8_TkNS_10is_contextERNS_7contextEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSC_RT1_OT2_:
   18|    611|   {
   19|    611|      using traits = buffer_traits<std::remove_cvref_t<Buffer>>;
   20|       |
   21|    611|      if constexpr (traits::is_resizable) {
   22|       |         // A buffer could be size 1, to ensure we have sufficient memory we can't just check `empty()`
   23|    611|         if (buffer.size() < 2 * write_padding_bytes) {
  ------------------
  |  Branch (23:14): [True: 611, False: 0]
  ------------------
   24|    611|            buffer.resize(2 * write_padding_bytes);
   25|    611|         }
   26|    611|      }
   27|    611|      size_t ix = 0; // overwrite index
   28|    611|      to<Opts.format, std::remove_cvref_t<T>>::template op<Opts>(std::forward<T>(value), ctx, buffer, ix);
   29|       |
   30|    611|      if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (30:11): [True: 0, False: 611]
  ------------------
   31|      0|         return {ix, ctx.error, ctx.custom_error_message};
   32|      0|      }
   33|       |
   34|    611|      traits::finalize(buffer, ix);
   35|    611|      return {ix, error_code::none, ctx.custom_error_message};
   36|    611|   }
_ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERdTkNS_13output_bufferENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSA_RT1_:
   78|  1.78k|   {
   79|  1.78k|      context ctx{};
   80|  1.78k|      return write<Opts>(std::forward<T>(value), buffer, ctx);
   81|  1.78k|   }
_ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERdTkNS_13output_bufferENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEETkNS_10is_contextERNS_7contextEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSC_RT1_OT2_:
   18|  1.78k|   {
   19|  1.78k|      using traits = buffer_traits<std::remove_cvref_t<Buffer>>;
   20|       |
   21|  1.78k|      if constexpr (traits::is_resizable) {
   22|       |         // A buffer could be size 1, to ensure we have sufficient memory we can't just check `empty()`
   23|  1.78k|         if (buffer.size() < 2 * write_padding_bytes) {
  ------------------
  |  Branch (23:14): [True: 1.78k, False: 0]
  ------------------
   24|  1.78k|            buffer.resize(2 * write_padding_bytes);
   25|  1.78k|         }
   26|  1.78k|      }
   27|  1.78k|      size_t ix = 0; // overwrite index
   28|  1.78k|      to<Opts.format, std::remove_cvref_t<T>>::template op<Opts>(std::forward<T>(value), ctx, buffer, ix);
   29|       |
   30|  1.78k|      if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (30:11): [True: 0, False: 1.78k]
  ------------------
   31|      0|         return {ix, ctx.error, ctx.custom_error_message};
   32|      0|      }
   33|       |
   34|  1.78k|      traits::finalize(buffer, ix);
   35|  1.78k|      return {ix, error_code::none, ctx.custom_error_message};
   36|  1.78k|   }
_ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERN12jsonrpc_fuzz5pointETkNS_13output_bufferENSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSC_RT1_:
   78|    219|   {
   79|    219|      context ctx{};
   80|    219|      return write<Opts>(std::forward<T>(value), buffer, ctx);
   81|    219|   }
_ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERN12jsonrpc_fuzz5pointETkNS_13output_bufferENSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEETkNS_10is_contextERNS_7contextEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSE_RT1_OT2_:
   18|    219|   {
   19|    219|      using traits = buffer_traits<std::remove_cvref_t<Buffer>>;
   20|       |
   21|    219|      if constexpr (traits::is_resizable) {
   22|       |         // A buffer could be size 1, to ensure we have sufficient memory we can't just check `empty()`
   23|    219|         if (buffer.size() < 2 * write_padding_bytes) {
  ------------------
  |  Branch (23:14): [True: 219, False: 0]
  ------------------
   24|    219|            buffer.resize(2 * write_padding_bytes);
   25|    219|         }
   26|    219|      }
   27|    219|      size_t ix = 0; // overwrite index
   28|    219|      to<Opts.format, std::remove_cvref_t<T>>::template op<Opts>(std::forward<T>(value), ctx, buffer, ix);
   29|       |
   30|    219|      if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (30:11): [True: 0, False: 219]
  ------------------
   31|      0|         return {ix, ctx.error, ctx.custom_error_message};
   32|      0|      }
   33|       |
   34|    219|      traits::finalize(buffer, ix);
   35|    219|      return {ix, error_code::none, ctx.custom_error_message};
   36|    219|   }
_ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERN12jsonrpc_fuzz6nestedETkNS_13output_bufferENSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSC_RT1_:
   78|     56|   {
   79|     56|      context ctx{};
   80|     56|      return write<Opts>(std::forward<T>(value), buffer, ctx);
   81|     56|   }
_ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERN12jsonrpc_fuzz6nestedETkNS_13output_bufferENSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEETkNS_10is_contextERNS_7contextEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSE_RT1_OT2_:
   18|     56|   {
   19|     56|      using traits = buffer_traits<std::remove_cvref_t<Buffer>>;
   20|       |
   21|     56|      if constexpr (traits::is_resizable) {
   22|       |         // A buffer could be size 1, to ensure we have sufficient memory we can't just check `empty()`
   23|     56|         if (buffer.size() < 2 * write_padding_bytes) {
  ------------------
  |  Branch (23:14): [True: 56, False: 0]
  ------------------
   24|     56|            buffer.resize(2 * write_padding_bytes);
   25|     56|         }
   26|     56|      }
   27|     56|      size_t ix = 0; // overwrite index
   28|     56|      to<Opts.format, std::remove_cvref_t<T>>::template op<Opts>(std::forward<T>(value), ctx, buffer, ix);
   29|       |
   30|     56|      if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (30:11): [True: 0, False: 56]
  ------------------
   31|      0|         return {ix, ctx.error, ctx.custom_error_message};
   32|      0|      }
   33|       |
   34|     56|      traits::finalize(buffer, ix);
   35|     56|      return {ix, error_code::none, ctx.custom_error_message};
   36|     56|   }
_ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__16vectorIiNS2_9allocatorIiEEEETkNS_13output_bufferENS2_12basic_stringIcNS2_11char_traitsIcEENS4_IcEEEEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSD_RT1_:
   78|    147|   {
   79|    147|      context ctx{};
   80|    147|      return write<Opts>(std::forward<T>(value), buffer, ctx);
   81|    147|   }
_ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__16vectorIiNS2_9allocatorIiEEEETkNS_13output_bufferENS2_12basic_stringIcNS2_11char_traitsIcEENS4_IcEEEETkNS_10is_contextERNS_7contextEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSF_RT1_OT2_:
   18|    147|   {
   19|    147|      using traits = buffer_traits<std::remove_cvref_t<Buffer>>;
   20|       |
   21|    147|      if constexpr (traits::is_resizable) {
   22|       |         // A buffer could be size 1, to ensure we have sufficient memory we can't just check `empty()`
   23|    147|         if (buffer.size() < 2 * write_padding_bytes) {
  ------------------
  |  Branch (23:14): [True: 147, False: 0]
  ------------------
   24|    147|            buffer.resize(2 * write_padding_bytes);
   25|    147|         }
   26|    147|      }
   27|    147|      size_t ix = 0; // overwrite index
   28|    147|      to<Opts.format, std::remove_cvref_t<T>>::template op<Opts>(std::forward<T>(value), ctx, buffer, ix);
   29|       |
   30|    147|      if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (30:11): [True: 0, False: 147]
  ------------------
   31|      0|         return {ix, ctx.error, ctx.custom_error_message};
   32|      0|      }
   33|       |
   34|    147|      traits::finalize(buffer, ix);
   35|    147|      return {ix, error_code::none, ctx.custom_error_message};
   36|    147|   }
_ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__13mapINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEiNS2_4lessIS9_EENS7_INS2_4pairIKS9_iEEEEEETkNS_13output_bufferES9_Q15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSI_RT1_:
   78|     32|   {
   79|     32|      context ctx{};
   80|     32|      return write<Opts>(std::forward<T>(value), buffer, ctx);
   81|     32|   }
_ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__13mapINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEiNS2_4lessIS9_EENS7_INS2_4pairIKS9_iEEEEEETkNS_13output_bufferES9_TkNS_10is_contextERNS_7contextEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSK_RT1_OT2_:
   18|     32|   {
   19|     32|      using traits = buffer_traits<std::remove_cvref_t<Buffer>>;
   20|       |
   21|     32|      if constexpr (traits::is_resizable) {
   22|       |         // A buffer could be size 1, to ensure we have sufficient memory we can't just check `empty()`
   23|     32|         if (buffer.size() < 2 * write_padding_bytes) {
  ------------------
  |  Branch (23:14): [True: 32, False: 0]
  ------------------
   24|     32|            buffer.resize(2 * write_padding_bytes);
   25|     32|         }
   26|     32|      }
   27|     32|      size_t ix = 0; // overwrite index
   28|     32|      to<Opts.format, std::remove_cvref_t<T>>::template op<Opts>(std::forward<T>(value), ctx, buffer, ix);
   29|       |
   30|     32|      if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (30:11): [True: 0, False: 32]
  ------------------
   31|      0|         return {ix, ctx.error, ctx.custom_error_message};
   32|      0|      }
   33|       |
   34|     32|      traits::finalize(buffer, ix);
   35|     32|      return {ix, error_code::none, ctx.custom_error_message};
   36|     32|   }
_ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__18optionalIdEETkNS_13output_bufferENS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSC_RT1_:
   78|     56|   {
   79|     56|      context ctx{};
   80|     56|      return write<Opts>(std::forward<T>(value), buffer, ctx);
   81|     56|   }
_ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__18optionalIdEETkNS_13output_bufferENS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEETkNS_10is_contextERNS_7contextEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSE_RT1_OT2_:
   18|     56|   {
   19|     56|      using traits = buffer_traits<std::remove_cvref_t<Buffer>>;
   20|       |
   21|     56|      if constexpr (traits::is_resizable) {
   22|       |         // A buffer could be size 1, to ensure we have sufficient memory we can't just check `empty()`
   23|     56|         if (buffer.size() < 2 * write_padding_bytes) {
  ------------------
  |  Branch (23:14): [True: 56, False: 0]
  ------------------
   24|     56|            buffer.resize(2 * write_padding_bytes);
   25|     56|         }
   26|     56|      }
   27|     56|      size_t ix = 0; // overwrite index
   28|     56|      to<Opts.format, std::remove_cvref_t<T>>::template op<Opts>(std::forward<T>(value), ctx, buffer, ix);
   29|       |
   30|     56|      if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (30:11): [True: 0, False: 56]
  ------------------
   31|      0|         return {ix, ctx.error, ctx.custom_error_message};
   32|      0|      }
   33|       |
   34|     56|      traits::finalize(buffer, ix);
   35|     56|      return {ix, error_code::none, ctx.custom_error_message};
   36|     56|   }
_ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__17variantIJNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEN12jsonrpc_fuzz6amountEEEETkNS_13output_bufferES9_Q15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSE_RT1_:
   78|     63|   {
   79|     63|      context ctx{};
   80|     63|      return write<Opts>(std::forward<T>(value), buffer, ctx);
   81|     63|   }
_ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__17variantIJNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEN12jsonrpc_fuzz6amountEEEETkNS_13output_bufferES9_TkNS_10is_contextERNS_7contextEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSG_RT1_OT2_:
   18|     63|   {
   19|     63|      using traits = buffer_traits<std::remove_cvref_t<Buffer>>;
   20|       |
   21|     63|      if constexpr (traits::is_resizable) {
   22|       |         // A buffer could be size 1, to ensure we have sufficient memory we can't just check `empty()`
   23|     63|         if (buffer.size() < 2 * write_padding_bytes) {
  ------------------
  |  Branch (23:14): [True: 63, False: 0]
  ------------------
   24|     63|            buffer.resize(2 * write_padding_bytes);
   25|     63|         }
   26|     63|      }
   27|     63|      size_t ix = 0; // overwrite index
   28|     63|      to<Opts.format, std::remove_cvref_t<T>>::template op<Opts>(std::forward<T>(value), ctx, buffer, ix);
   29|       |
   30|     63|      if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (30:11): [True: 0, False: 63]
  ------------------
   31|      0|         return {ix, ctx.error, ctx.custom_error_message};
   32|      0|      }
   33|       |
   34|     63|      traits::finalize(buffer, ix);
   35|     63|      return {ix, error_code::none, ctx.custom_error_message};
   36|     63|   }
_ZN3glz5writeITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEENSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEQ15write_supportedIT0_XdtT_6formatEEEENS2_8expectedIS8_NS_9error_ctxEEEOS9_:
   86|  4.09M|   {
   87|  4.09M|      std::string buffer{};
   88|  4.09M|      context ctx{};
   89|  4.09M|      const auto res = write<Opts>(std::forward<T>(value), buffer, ctx);
   90|  4.09M|      if (res) [[unlikely]] {
  ------------------
  |  Branch (90:11): [True: 0, False: 4.09M]
  ------------------
   91|      0|         return glz::unexpected(res);
   92|      0|      }
   93|  4.09M|      return {buffer};
   94|  4.09M|   }
_ZN3glz5writeITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEENSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEETkNS_13output_bufferES8_TkNS_10is_contextERNS_7contextEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSB_RT1_OT2_:
   18|  4.09M|   {
   19|  4.09M|      using traits = buffer_traits<std::remove_cvref_t<Buffer>>;
   20|       |
   21|  4.09M|      if constexpr (traits::is_resizable) {
   22|       |         // A buffer could be size 1, to ensure we have sufficient memory we can't just check `empty()`
   23|  4.09M|         if (buffer.size() < 2 * write_padding_bytes) {
  ------------------
  |  Branch (23:14): [True: 4.09M, False: 0]
  ------------------
   24|  4.09M|            buffer.resize(2 * write_padding_bytes);
   25|  4.09M|         }
   26|  4.09M|      }
   27|  4.09M|      size_t ix = 0; // overwrite index
   28|  4.09M|      to<Opts.format, std::remove_cvref_t<T>>::template op<Opts>(std::forward<T>(value), ctx, buffer, ix);
   29|       |
   30|  4.09M|      if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (30:11): [True: 0, False: 4.09M]
  ------------------
   31|      0|         return {ix, ctx.error, ctx.custom_error_message};
   32|      0|      }
   33|       |
   34|  4.09M|      traits::finalize(buffer, ix);
   35|  4.09M|      return {ix, error_code::none, ctx.custom_error_message};
   36|  4.09M|   }
_ZN3glz5writeITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERKNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEQ15write_supportedIT0_XdtT_6formatEEEENS2_8expectedINS2_12basic_stringIcS5_NS2_9allocatorIcEEEENS_9error_ctxEEEOS9_:
   86|     40|   {
   87|     40|      std::string buffer{};
   88|     40|      context ctx{};
   89|     40|      const auto res = write<Opts>(std::forward<T>(value), buffer, ctx);
   90|     40|      if (res) [[unlikely]] {
  ------------------
  |  Branch (90:11): [True: 0, False: 40]
  ------------------
   91|      0|         return glz::unexpected(res);
   92|      0|      }
   93|     40|      return {buffer};
   94|     40|   }
_ZN3glz5writeITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERKNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEETkNS_13output_bufferENS2_12basic_stringIcS5_NS2_9allocatorIcEEEETkNS_10is_contextERNS_7contextEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSF_RT1_OT2_:
   18|     40|   {
   19|     40|      using traits = buffer_traits<std::remove_cvref_t<Buffer>>;
   20|       |
   21|     40|      if constexpr (traits::is_resizable) {
   22|       |         // A buffer could be size 1, to ensure we have sufficient memory we can't just check `empty()`
   23|     40|         if (buffer.size() < 2 * write_padding_bytes) {
  ------------------
  |  Branch (23:14): [True: 40, False: 0]
  ------------------
   24|     40|            buffer.resize(2 * write_padding_bytes);
   25|     40|         }
   26|     40|      }
   27|     40|      size_t ix = 0; // overwrite index
   28|     40|      to<Opts.format, std::remove_cvref_t<T>>::template op<Opts>(std::forward<T>(value), ctx, buffer, ix);
   29|       |
   30|     40|      if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (30:11): [True: 0, False: 40]
  ------------------
   31|      0|         return {ix, ctx.error, ctx.custom_error_message};
   32|      0|      }
   33|       |
   34|     40|      traits::finalize(buffer, ix);
   35|     40|      return {ix, error_code::none, ctx.custom_error_message};
   36|     40|   }

_ZN3glz11write_chars2opITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj128EEERNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEETkNS_5num_tERlTkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_:
  205|  32.8k|      {
  206|       |         /*if constexpr (std::same_as<std::decay_t<B>, std::string>) {
  207|       |            // more efficient strings in C++23:
  208|       |          https://en.cppreference.com/w/cpp/string/basic_string/resize_and_overwrite
  209|       |          }*/
  210|       |
  211|       |         // https://stackoverflow.com/questions/1701055/what-is-the-maximum-length-in-chars-needed-to-represent-any-double-value
  212|       |         // maximum length for a double should be 24 chars, we use 64 to be sufficient for float128_t
  213|       |         if constexpr (resizable<B> && not check_write_unchecked(Opts)) {
  214|       |            if (const auto k = ix + 64; k > b.size()) {
  215|       |               b.resize(2 * k);
  216|       |            }
  217|       |         }
  218|       |
  219|  32.8k|         using V = std::decay_t<decltype(value)>;
  220|       |
  221|       |         if constexpr (std::floating_point<V>) {
  222|       |            using opts_type = std::decay_t<decltype(Opts)>;
  223|       |            constexpr bool use_float_format = requires { opts_type::float_format; };
  224|       |
  225|       |            // User-specified float_format takes priority over all other options
  226|       |            if constexpr (use_float_format && is_any_of<V, float, double>) {
  227|       |#if GLZ_USE_STD_FORMAT_FLOAT
  228|       |               // Use std::format with user-provided format string (e.g., "{:.2f}")
  229|       |               // Format string is validated at compile-time via std::format_string
  230|       |               constexpr auto fmt = std::format_string<V>{opts_type::float_format};
  231|       |
  232|       |               if constexpr (check_write_unchecked(Opts)) {
  233|       |                  // Caller guarantees buffer has enough space
  234|       |                  const auto start = reinterpret_cast<char*>(&b[ix]);
  235|       |                  auto result = std::format_to(start, fmt, V(value));
  236|       |                  ix += size_t(result - start);
  237|       |               }
  238|       |               else {
  239|       |                  // format_to_n writes up to 'available' chars and returns total size needed.
  240|       |                  // Common case: output fits in pre-allocated buffer (single pass).
  241|       |                  // Rare case: output exceeds buffer (e.g., "{:.100f}"), requires resize.
  242|       |                  const auto start = reinterpret_cast<char*>(&b[ix]);
  243|       |                  const auto available = b.size() - ix;
  244|       |                  auto [out, size] = std::format_to_n(start, available, fmt, V(value));
  245|       |
  246|       |                  if (static_cast<size_t>(size) > available) {
  247|       |                     // Output was truncated - size tells us exactly how much space we need
  248|       |                     if constexpr (resizable<B>) {
  249|       |                        b.resize(2 * (ix + size));
  250|       |                        std::format_to(reinterpret_cast<char*>(&b[ix]), fmt, V(value));
  251|       |                     }
  252|       |                     else {
  253|       |                        ctx.error = error_code::unexpected_end;
  254|       |                        return;
  255|       |                     }
  256|       |                  }
  257|       |                  ix += size;
  258|       |               }
  259|       |#else
  260|       |               // snprintf fallback for platforms without std::format float support (e.g., iOS < 16.3)
  261|       |               // Convert std::format spec to printf format at compile time
  262|       |               constexpr auto printf_fmt = detail::to_printf_fmt(opts_type::float_format);
  263|       |
  264|       |               const auto start = reinterpret_cast<char*>(&b[ix]);
  265|       |               const auto available = check_write_unchecked(Opts) ? size_t(64) : (b.size() - ix);
  266|       |
  267|       |               // snprintf returns chars that would be written (excluding null), or negative on error
  268|       |               const int len = std::snprintf(start, available, printf_fmt.data, static_cast<double>(value));
  269|       |
  270|       |               if (len < 0) {
  271|       |                  ctx.error = error_code::unexpected_end;
  272|       |                  return;
  273|       |               }
  274|       |
  275|       |               if (static_cast<size_t>(len) >= available) {
  276|       |                  // Output was truncated, need to resize and retry
  277|       |                  if constexpr (resizable<B> && not check_write_unchecked(Opts)) {
  278|       |                     b.resize(2 * (ix + static_cast<size_t>(len) + 1));
  279|       |                     std::snprintf(reinterpret_cast<char*>(&b[ix]), static_cast<size_t>(len) + 1, printf_fmt.data,
  280|       |                                   static_cast<double>(value));
  281|       |                  }
  282|       |                  else {
  283|       |                     ctx.error = error_code::unexpected_end;
  284|       |                     return;
  285|       |                  }
  286|       |               }
  287|       |               ix += static_cast<size_t>(len);
  288|       |#endif
  289|       |            }
  290|       |            else if constexpr (uint8_t(check_float_max_write_precision(Opts)) > 0 &&
  291|       |                               uint8_t(check_float_max_write_precision(Opts)) < sizeof(V)) {
  292|       |               // we cast to a lower precision floating point value before writing out
  293|       |               if constexpr (uint8_t(check_float_max_write_precision(Opts)) == 8) {
  294|       |                  const auto reduced = static_cast<double>(value);
  295|       |                  const auto start = reinterpret_cast<char*>(&b[ix]);
  296|       |                  const auto end = glz::to_chars(start, reduced);
  297|       |                  ix += size_t(end - start);
  298|       |               }
  299|       |               else if constexpr (uint8_t(check_float_max_write_precision(Opts)) == 4) {
  300|       |                  const auto reduced = static_cast<float>(value);
  301|       |                  const auto start = reinterpret_cast<char*>(&b[ix]);
  302|       |                  const auto end = glz::to_chars(start, reduced);
  303|       |                  ix += size_t(end - start);
  304|       |               }
  305|       |               else {
  306|       |                  static_assert(false_v<V>, "invalid float_max_write_precision");
  307|       |               }
  308|       |            }
  309|       |            // Size optimization: pass OptSize=true so the ~17KB pow-10 lookup
  310|       |            // tables are dropped (recomputed on the fly). Much faster than the
  311|       |            // old simple_float::to_chars path at essentially the same footprint.
  312|       |            // See discussion #2519.
  313|       |            else if constexpr (is_size_optimized(Opts) && is_any_of<V, float, double>) {
  314|       |               const auto start = reinterpret_cast<char*>(&b[ix]);
  315|       |               const auto end = glz::to_chars<V, /*OptSize=*/true>(start, V(value));
  316|       |               ix += size_t(end - start);
  317|       |            }
  318|       |            else if constexpr (is_any_of<V, float, double>) {
  319|       |               const auto start = reinterpret_cast<char*>(&b[ix]);
  320|       |               const auto end = glz::to_chars(start, value);
  321|       |               ix += size_t(end - start);
  322|       |            }
  323|       |// float128_t requires std::to_chars for floating-point, unavailable on older Apple platforms (iOS < 16.3)
  324|       |#if !defined(_LIBCPP_VERSION) || _LIBCPP_AVAILABILITY_HAS_TO_CHARS_FLOATING_POINT
  325|       |            else if constexpr (is_float128<V>) {
  326|       |               const auto start = reinterpret_cast<char*>(&b[ix]);
  327|       |               const auto [ptr, ec] = std::to_chars(start, &b[0] + b.size(), value, std::chars_format::general);
  328|       |               if (ec != std::errc()) {
  329|       |                  ctx.error = error_code::unexpected_end;
  330|       |                  return;
  331|       |               }
  332|       |               ix += size_t(ptr - start);
  333|       |            }
  334|       |#endif
  335|       |            else {
  336|       |               static_assert(false_v<V>, "type is not supported");
  337|       |            }
  338|       |         }
  339|       |         else if constexpr (is_any_of<V, int8_t, uint8_t, int16_t, uint16_t>) {
  340|       |            // Small integers: always use to_chars (400B tables)
  341|       |            // The 40KB digit_quads table doesn't help for these small ranges
  342|       |            const auto start = reinterpret_cast<char*>(&b[ix]);
  343|       |            const auto end = glz::to_chars(start, value);
  344|       |            ix += size_t(end - start);
  345|       |         }
  346|  32.8k|         else if constexpr (is_any_of<V, int32_t, uint32_t, int64_t, uint64_t>) {
  347|  32.8k|            const auto start = reinterpret_cast<char*>(&b[ix]);
  348|       |            if constexpr (is_size_optimized(Opts)) {
  349|       |               // Size mode: use glz::to_chars (400B lookup tables)
  350|       |               const auto end = glz::to_chars(start, value);
  351|       |               ix += size_t(end - start);
  352|       |            }
  353|  32.8k|            else {
  354|       |               // Normal mode: use to_chars_40kb (40KB digit_quads table)
  355|  32.8k|               const auto end = glz::to_chars_40kb(start, value);
  356|  32.8k|               ix += size_t(end - start);
  357|  32.8k|            }
  358|       |         }
  359|       |         else if constexpr (std::integral<V>) {
  360|       |            // Handle other integral types (char, wchar_t, etc.) by casting to sized types
  361|       |            using X = std::decay_t<decltype(sized_integer_conversion<V>())>;
  362|       |            const auto start = reinterpret_cast<char*>(&b[ix]);
  363|       |            if constexpr (is_size_optimized(Opts)) {
  364|       |               // Size mode: use glz::to_chars (400B lookup tables)
  365|       |               const auto end = glz::to_chars(start, static_cast<X>(value));
  366|       |               ix += size_t(end - start);
  367|       |            }
  368|       |            else {
  369|       |               // Normal mode: use to_chars_40kb
  370|       |               const auto end = glz::to_chars_40kb(start, static_cast<X>(value));
  371|       |               ix += size_t(end - start);
  372|       |            }
  373|       |         }
  374|       |         else {
  375|       |            static_assert(false_v<V>, "type is not supported");
  376|       |         }
  377|  32.8k|      }
_ZN3glz11write_chars2opITnDaXtlNS_9opts_sizeEtlNS_4optsELj10ELb1ELb0ELb1ELb1EEEERNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEETkNS_5num_tERKmTkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_:
  205|  4.49M|      {
  206|       |         /*if constexpr (std::same_as<std::decay_t<B>, std::string>) {
  207|       |            // more efficient strings in C++23:
  208|       |          https://en.cppreference.com/w/cpp/string/basic_string/resize_and_overwrite
  209|       |          }*/
  210|       |
  211|       |         // https://stackoverflow.com/questions/1701055/what-is-the-maximum-length-in-chars-needed-to-represent-any-double-value
  212|       |         // maximum length for a double should be 24 chars, we use 64 to be sufficient for float128_t
  213|  4.49M|         if constexpr (resizable<B> && not check_write_unchecked(Opts)) {
  214|  4.49M|            if (const auto k = ix + 64; k > b.size()) {
  ------------------
  |  Branch (214:41): [True: 0, False: 4.49M]
  ------------------
  215|      0|               b.resize(2 * k);
  216|      0|            }
  217|  4.49M|         }
  218|       |
  219|  4.49M|         using V = std::decay_t<decltype(value)>;
  220|       |
  221|       |         if constexpr (std::floating_point<V>) {
  222|       |            using opts_type = std::decay_t<decltype(Opts)>;
  223|       |            constexpr bool use_float_format = requires { opts_type::float_format; };
  224|       |
  225|       |            // User-specified float_format takes priority over all other options
  226|       |            if constexpr (use_float_format && is_any_of<V, float, double>) {
  227|       |#if GLZ_USE_STD_FORMAT_FLOAT
  228|       |               // Use std::format with user-provided format string (e.g., "{:.2f}")
  229|       |               // Format string is validated at compile-time via std::format_string
  230|       |               constexpr auto fmt = std::format_string<V>{opts_type::float_format};
  231|       |
  232|       |               if constexpr (check_write_unchecked(Opts)) {
  233|       |                  // Caller guarantees buffer has enough space
  234|       |                  const auto start = reinterpret_cast<char*>(&b[ix]);
  235|       |                  auto result = std::format_to(start, fmt, V(value));
  236|       |                  ix += size_t(result - start);
  237|       |               }
  238|       |               else {
  239|       |                  // format_to_n writes up to 'available' chars and returns total size needed.
  240|       |                  // Common case: output fits in pre-allocated buffer (single pass).
  241|       |                  // Rare case: output exceeds buffer (e.g., "{:.100f}"), requires resize.
  242|       |                  const auto start = reinterpret_cast<char*>(&b[ix]);
  243|       |                  const auto available = b.size() - ix;
  244|       |                  auto [out, size] = std::format_to_n(start, available, fmt, V(value));
  245|       |
  246|       |                  if (static_cast<size_t>(size) > available) {
  247|       |                     // Output was truncated - size tells us exactly how much space we need
  248|       |                     if constexpr (resizable<B>) {
  249|       |                        b.resize(2 * (ix + size));
  250|       |                        std::format_to(reinterpret_cast<char*>(&b[ix]), fmt, V(value));
  251|       |                     }
  252|       |                     else {
  253|       |                        ctx.error = error_code::unexpected_end;
  254|       |                        return;
  255|       |                     }
  256|       |                  }
  257|       |                  ix += size;
  258|       |               }
  259|       |#else
  260|       |               // snprintf fallback for platforms without std::format float support (e.g., iOS < 16.3)
  261|       |               // Convert std::format spec to printf format at compile time
  262|       |               constexpr auto printf_fmt = detail::to_printf_fmt(opts_type::float_format);
  263|       |
  264|       |               const auto start = reinterpret_cast<char*>(&b[ix]);
  265|       |               const auto available = check_write_unchecked(Opts) ? size_t(64) : (b.size() - ix);
  266|       |
  267|       |               // snprintf returns chars that would be written (excluding null), or negative on error
  268|       |               const int len = std::snprintf(start, available, printf_fmt.data, static_cast<double>(value));
  269|       |
  270|       |               if (len < 0) {
  271|       |                  ctx.error = error_code::unexpected_end;
  272|       |                  return;
  273|       |               }
  274|       |
  275|       |               if (static_cast<size_t>(len) >= available) {
  276|       |                  // Output was truncated, need to resize and retry
  277|       |                  if constexpr (resizable<B> && not check_write_unchecked(Opts)) {
  278|       |                     b.resize(2 * (ix + static_cast<size_t>(len) + 1));
  279|       |                     std::snprintf(reinterpret_cast<char*>(&b[ix]), static_cast<size_t>(len) + 1, printf_fmt.data,
  280|       |                                   static_cast<double>(value));
  281|       |                  }
  282|       |                  else {
  283|       |                     ctx.error = error_code::unexpected_end;
  284|       |                     return;
  285|       |                  }
  286|       |               }
  287|       |               ix += static_cast<size_t>(len);
  288|       |#endif
  289|       |            }
  290|       |            else if constexpr (uint8_t(check_float_max_write_precision(Opts)) > 0 &&
  291|       |                               uint8_t(check_float_max_write_precision(Opts)) < sizeof(V)) {
  292|       |               // we cast to a lower precision floating point value before writing out
  293|       |               if constexpr (uint8_t(check_float_max_write_precision(Opts)) == 8) {
  294|       |                  const auto reduced = static_cast<double>(value);
  295|       |                  const auto start = reinterpret_cast<char*>(&b[ix]);
  296|       |                  const auto end = glz::to_chars(start, reduced);
  297|       |                  ix += size_t(end - start);
  298|       |               }
  299|       |               else if constexpr (uint8_t(check_float_max_write_precision(Opts)) == 4) {
  300|       |                  const auto reduced = static_cast<float>(value);
  301|       |                  const auto start = reinterpret_cast<char*>(&b[ix]);
  302|       |                  const auto end = glz::to_chars(start, reduced);
  303|       |                  ix += size_t(end - start);
  304|       |               }
  305|       |               else {
  306|       |                  static_assert(false_v<V>, "invalid float_max_write_precision");
  307|       |               }
  308|       |            }
  309|       |            // Size optimization: pass OptSize=true so the ~17KB pow-10 lookup
  310|       |            // tables are dropped (recomputed on the fly). Much faster than the
  311|       |            // old simple_float::to_chars path at essentially the same footprint.
  312|       |            // See discussion #2519.
  313|       |            else if constexpr (is_size_optimized(Opts) && is_any_of<V, float, double>) {
  314|       |               const auto start = reinterpret_cast<char*>(&b[ix]);
  315|       |               const auto end = glz::to_chars<V, /*OptSize=*/true>(start, V(value));
  316|       |               ix += size_t(end - start);
  317|       |            }
  318|       |            else if constexpr (is_any_of<V, float, double>) {
  319|       |               const auto start = reinterpret_cast<char*>(&b[ix]);
  320|       |               const auto end = glz::to_chars(start, value);
  321|       |               ix += size_t(end - start);
  322|       |            }
  323|       |// float128_t requires std::to_chars for floating-point, unavailable on older Apple platforms (iOS < 16.3)
  324|       |#if !defined(_LIBCPP_VERSION) || _LIBCPP_AVAILABILITY_HAS_TO_CHARS_FLOATING_POINT
  325|       |            else if constexpr (is_float128<V>) {
  326|       |               const auto start = reinterpret_cast<char*>(&b[ix]);
  327|       |               const auto [ptr, ec] = std::to_chars(start, &b[0] + b.size(), value, std::chars_format::general);
  328|       |               if (ec != std::errc()) {
  329|       |                  ctx.error = error_code::unexpected_end;
  330|       |                  return;
  331|       |               }
  332|       |               ix += size_t(ptr - start);
  333|       |            }
  334|       |#endif
  335|       |            else {
  336|       |               static_assert(false_v<V>, "type is not supported");
  337|       |            }
  338|       |         }
  339|       |         else if constexpr (is_any_of<V, int8_t, uint8_t, int16_t, uint16_t>) {
  340|       |            // Small integers: always use to_chars (400B tables)
  341|       |            // The 40KB digit_quads table doesn't help for these small ranges
  342|       |            const auto start = reinterpret_cast<char*>(&b[ix]);
  343|       |            const auto end = glz::to_chars(start, value);
  344|       |            ix += size_t(end - start);
  345|       |         }
  346|  4.49M|         else if constexpr (is_any_of<V, int32_t, uint32_t, int64_t, uint64_t>) {
  347|  4.49M|            const auto start = reinterpret_cast<char*>(&b[ix]);
  348|  4.49M|            if constexpr (is_size_optimized(Opts)) {
  349|       |               // Size mode: use glz::to_chars (400B lookup tables)
  350|  4.49M|               const auto end = glz::to_chars(start, value);
  351|  4.49M|               ix += size_t(end - start);
  352|       |            }
  353|       |            else {
  354|       |               // Normal mode: use to_chars_40kb (40KB digit_quads table)
  355|       |               const auto end = glz::to_chars_40kb(start, value);
  356|       |               ix += size_t(end - start);
  357|       |            }
  358|       |         }
  359|       |         else if constexpr (std::integral<V>) {
  360|       |            // Handle other integral types (char, wchar_t, etc.) by casting to sized types
  361|       |            using X = std::decay_t<decltype(sized_integer_conversion<V>())>;
  362|       |            const auto start = reinterpret_cast<char*>(&b[ix]);
  363|       |            if constexpr (is_size_optimized(Opts)) {
  364|       |               // Size mode: use glz::to_chars (400B lookup tables)
  365|       |               const auto end = glz::to_chars(start, static_cast<X>(value));
  366|       |               ix += size_t(end - start);
  367|       |            }
  368|       |            else {
  369|       |               // Normal mode: use to_chars_40kb
  370|       |               const auto end = glz::to_chars_40kb(start, static_cast<X>(value));
  371|       |               ix += size_t(end - start);
  372|       |            }
  373|       |         }
  374|       |         else {
  375|       |            static_assert(false_v<V>, "type is not supported");
  376|       |         }
  377|  4.49M|      }
_ZN3glz11write_chars2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj128EEERNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEETkNS_5num_tERiTkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_:
  205|    826|      {
  206|       |         /*if constexpr (std::same_as<std::decay_t<B>, std::string>) {
  207|       |            // more efficient strings in C++23:
  208|       |          https://en.cppreference.com/w/cpp/string/basic_string/resize_and_overwrite
  209|       |          }*/
  210|       |
  211|       |         // https://stackoverflow.com/questions/1701055/what-is-the-maximum-length-in-chars-needed-to-represent-any-double-value
  212|       |         // maximum length for a double should be 24 chars, we use 64 to be sufficient for float128_t
  213|       |         if constexpr (resizable<B> && not check_write_unchecked(Opts)) {
  214|       |            if (const auto k = ix + 64; k > b.size()) {
  215|       |               b.resize(2 * k);
  216|       |            }
  217|       |         }
  218|       |
  219|    826|         using V = std::decay_t<decltype(value)>;
  220|       |
  221|       |         if constexpr (std::floating_point<V>) {
  222|       |            using opts_type = std::decay_t<decltype(Opts)>;
  223|       |            constexpr bool use_float_format = requires { opts_type::float_format; };
  224|       |
  225|       |            // User-specified float_format takes priority over all other options
  226|       |            if constexpr (use_float_format && is_any_of<V, float, double>) {
  227|       |#if GLZ_USE_STD_FORMAT_FLOAT
  228|       |               // Use std::format with user-provided format string (e.g., "{:.2f}")
  229|       |               // Format string is validated at compile-time via std::format_string
  230|       |               constexpr auto fmt = std::format_string<V>{opts_type::float_format};
  231|       |
  232|       |               if constexpr (check_write_unchecked(Opts)) {
  233|       |                  // Caller guarantees buffer has enough space
  234|       |                  const auto start = reinterpret_cast<char*>(&b[ix]);
  235|       |                  auto result = std::format_to(start, fmt, V(value));
  236|       |                  ix += size_t(result - start);
  237|       |               }
  238|       |               else {
  239|       |                  // format_to_n writes up to 'available' chars and returns total size needed.
  240|       |                  // Common case: output fits in pre-allocated buffer (single pass).
  241|       |                  // Rare case: output exceeds buffer (e.g., "{:.100f}"), requires resize.
  242|       |                  const auto start = reinterpret_cast<char*>(&b[ix]);
  243|       |                  const auto available = b.size() - ix;
  244|       |                  auto [out, size] = std::format_to_n(start, available, fmt, V(value));
  245|       |
  246|       |                  if (static_cast<size_t>(size) > available) {
  247|       |                     // Output was truncated - size tells us exactly how much space we need
  248|       |                     if constexpr (resizable<B>) {
  249|       |                        b.resize(2 * (ix + size));
  250|       |                        std::format_to(reinterpret_cast<char*>(&b[ix]), fmt, V(value));
  251|       |                     }
  252|       |                     else {
  253|       |                        ctx.error = error_code::unexpected_end;
  254|       |                        return;
  255|       |                     }
  256|       |                  }
  257|       |                  ix += size;
  258|       |               }
  259|       |#else
  260|       |               // snprintf fallback for platforms without std::format float support (e.g., iOS < 16.3)
  261|       |               // Convert std::format spec to printf format at compile time
  262|       |               constexpr auto printf_fmt = detail::to_printf_fmt(opts_type::float_format);
  263|       |
  264|       |               const auto start = reinterpret_cast<char*>(&b[ix]);
  265|       |               const auto available = check_write_unchecked(Opts) ? size_t(64) : (b.size() - ix);
  266|       |
  267|       |               // snprintf returns chars that would be written (excluding null), or negative on error
  268|       |               const int len = std::snprintf(start, available, printf_fmt.data, static_cast<double>(value));
  269|       |
  270|       |               if (len < 0) {
  271|       |                  ctx.error = error_code::unexpected_end;
  272|       |                  return;
  273|       |               }
  274|       |
  275|       |               if (static_cast<size_t>(len) >= available) {
  276|       |                  // Output was truncated, need to resize and retry
  277|       |                  if constexpr (resizable<B> && not check_write_unchecked(Opts)) {
  278|       |                     b.resize(2 * (ix + static_cast<size_t>(len) + 1));
  279|       |                     std::snprintf(reinterpret_cast<char*>(&b[ix]), static_cast<size_t>(len) + 1, printf_fmt.data,
  280|       |                                   static_cast<double>(value));
  281|       |                  }
  282|       |                  else {
  283|       |                     ctx.error = error_code::unexpected_end;
  284|       |                     return;
  285|       |                  }
  286|       |               }
  287|       |               ix += static_cast<size_t>(len);
  288|       |#endif
  289|       |            }
  290|       |            else if constexpr (uint8_t(check_float_max_write_precision(Opts)) > 0 &&
  291|       |                               uint8_t(check_float_max_write_precision(Opts)) < sizeof(V)) {
  292|       |               // we cast to a lower precision floating point value before writing out
  293|       |               if constexpr (uint8_t(check_float_max_write_precision(Opts)) == 8) {
  294|       |                  const auto reduced = static_cast<double>(value);
  295|       |                  const auto start = reinterpret_cast<char*>(&b[ix]);
  296|       |                  const auto end = glz::to_chars(start, reduced);
  297|       |                  ix += size_t(end - start);
  298|       |               }
  299|       |               else if constexpr (uint8_t(check_float_max_write_precision(Opts)) == 4) {
  300|       |                  const auto reduced = static_cast<float>(value);
  301|       |                  const auto start = reinterpret_cast<char*>(&b[ix]);
  302|       |                  const auto end = glz::to_chars(start, reduced);
  303|       |                  ix += size_t(end - start);
  304|       |               }
  305|       |               else {
  306|       |                  static_assert(false_v<V>, "invalid float_max_write_precision");
  307|       |               }
  308|       |            }
  309|       |            // Size optimization: pass OptSize=true so the ~17KB pow-10 lookup
  310|       |            // tables are dropped (recomputed on the fly). Much faster than the
  311|       |            // old simple_float::to_chars path at essentially the same footprint.
  312|       |            // See discussion #2519.
  313|       |            else if constexpr (is_size_optimized(Opts) && is_any_of<V, float, double>) {
  314|       |               const auto start = reinterpret_cast<char*>(&b[ix]);
  315|       |               const auto end = glz::to_chars<V, /*OptSize=*/true>(start, V(value));
  316|       |               ix += size_t(end - start);
  317|       |            }
  318|       |            else if constexpr (is_any_of<V, float, double>) {
  319|       |               const auto start = reinterpret_cast<char*>(&b[ix]);
  320|       |               const auto end = glz::to_chars(start, value);
  321|       |               ix += size_t(end - start);
  322|       |            }
  323|       |// float128_t requires std::to_chars for floating-point, unavailable on older Apple platforms (iOS < 16.3)
  324|       |#if !defined(_LIBCPP_VERSION) || _LIBCPP_AVAILABILITY_HAS_TO_CHARS_FLOATING_POINT
  325|       |            else if constexpr (is_float128<V>) {
  326|       |               const auto start = reinterpret_cast<char*>(&b[ix]);
  327|       |               const auto [ptr, ec] = std::to_chars(start, &b[0] + b.size(), value, std::chars_format::general);
  328|       |               if (ec != std::errc()) {
  329|       |                  ctx.error = error_code::unexpected_end;
  330|       |                  return;
  331|       |               }
  332|       |               ix += size_t(ptr - start);
  333|       |            }
  334|       |#endif
  335|       |            else {
  336|       |               static_assert(false_v<V>, "type is not supported");
  337|       |            }
  338|       |         }
  339|       |         else if constexpr (is_any_of<V, int8_t, uint8_t, int16_t, uint16_t>) {
  340|       |            // Small integers: always use to_chars (400B tables)
  341|       |            // The 40KB digit_quads table doesn't help for these small ranges
  342|       |            const auto start = reinterpret_cast<char*>(&b[ix]);
  343|       |            const auto end = glz::to_chars(start, value);
  344|       |            ix += size_t(end - start);
  345|       |         }
  346|    826|         else if constexpr (is_any_of<V, int32_t, uint32_t, int64_t, uint64_t>) {
  347|    826|            const auto start = reinterpret_cast<char*>(&b[ix]);
  348|       |            if constexpr (is_size_optimized(Opts)) {
  349|       |               // Size mode: use glz::to_chars (400B lookup tables)
  350|       |               const auto end = glz::to_chars(start, value);
  351|       |               ix += size_t(end - start);
  352|       |            }
  353|    826|            else {
  354|       |               // Normal mode: use to_chars_40kb (40KB digit_quads table)
  355|    826|               const auto end = glz::to_chars_40kb(start, value);
  356|    826|               ix += size_t(end - start);
  357|    826|            }
  358|       |         }
  359|       |         else if constexpr (std::integral<V>) {
  360|       |            // Handle other integral types (char, wchar_t, etc.) by casting to sized types
  361|       |            using X = std::decay_t<decltype(sized_integer_conversion<V>())>;
  362|       |            const auto start = reinterpret_cast<char*>(&b[ix]);
  363|       |            if constexpr (is_size_optimized(Opts)) {
  364|       |               // Size mode: use glz::to_chars (400B lookup tables)
  365|       |               const auto end = glz::to_chars(start, static_cast<X>(value));
  366|       |               ix += size_t(end - start);
  367|       |            }
  368|       |            else {
  369|       |               // Normal mode: use to_chars_40kb
  370|       |               const auto end = glz::to_chars_40kb(start, static_cast<X>(value));
  371|       |               ix += size_t(end - start);
  372|       |            }
  373|       |         }
  374|       |         else {
  375|       |            static_assert(false_v<V>, "type is not supported");
  376|       |         }
  377|    826|      }
_ZN3glz11write_chars2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj128EEERNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEETkNS_5num_tERdTkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_:
  205|  2.62k|      {
  206|       |         /*if constexpr (std::same_as<std::decay_t<B>, std::string>) {
  207|       |            // more efficient strings in C++23:
  208|       |          https://en.cppreference.com/w/cpp/string/basic_string/resize_and_overwrite
  209|       |          }*/
  210|       |
  211|       |         // https://stackoverflow.com/questions/1701055/what-is-the-maximum-length-in-chars-needed-to-represent-any-double-value
  212|       |         // maximum length for a double should be 24 chars, we use 64 to be sufficient for float128_t
  213|       |         if constexpr (resizable<B> && not check_write_unchecked(Opts)) {
  214|       |            if (const auto k = ix + 64; k > b.size()) {
  215|       |               b.resize(2 * k);
  216|       |            }
  217|       |         }
  218|       |
  219|  2.62k|         using V = std::decay_t<decltype(value)>;
  220|       |
  221|  2.62k|         if constexpr (std::floating_point<V>) {
  222|  2.62k|            using opts_type = std::decay_t<decltype(Opts)>;
  223|  2.62k|            constexpr bool use_float_format = requires { opts_type::float_format; };
  224|       |
  225|       |            // User-specified float_format takes priority over all other options
  226|       |            if constexpr (use_float_format && is_any_of<V, float, double>) {
  227|       |#if GLZ_USE_STD_FORMAT_FLOAT
  228|       |               // Use std::format with user-provided format string (e.g., "{:.2f}")
  229|       |               // Format string is validated at compile-time via std::format_string
  230|       |               constexpr auto fmt = std::format_string<V>{opts_type::float_format};
  231|       |
  232|       |               if constexpr (check_write_unchecked(Opts)) {
  233|       |                  // Caller guarantees buffer has enough space
  234|       |                  const auto start = reinterpret_cast<char*>(&b[ix]);
  235|       |                  auto result = std::format_to(start, fmt, V(value));
  236|       |                  ix += size_t(result - start);
  237|       |               }
  238|       |               else {
  239|       |                  // format_to_n writes up to 'available' chars and returns total size needed.
  240|       |                  // Common case: output fits in pre-allocated buffer (single pass).
  241|       |                  // Rare case: output exceeds buffer (e.g., "{:.100f}"), requires resize.
  242|       |                  const auto start = reinterpret_cast<char*>(&b[ix]);
  243|       |                  const auto available = b.size() - ix;
  244|       |                  auto [out, size] = std::format_to_n(start, available, fmt, V(value));
  245|       |
  246|       |                  if (static_cast<size_t>(size) > available) {
  247|       |                     // Output was truncated - size tells us exactly how much space we need
  248|       |                     if constexpr (resizable<B>) {
  249|       |                        b.resize(2 * (ix + size));
  250|       |                        std::format_to(reinterpret_cast<char*>(&b[ix]), fmt, V(value));
  251|       |                     }
  252|       |                     else {
  253|       |                        ctx.error = error_code::unexpected_end;
  254|       |                        return;
  255|       |                     }
  256|       |                  }
  257|       |                  ix += size;
  258|       |               }
  259|       |#else
  260|       |               // snprintf fallback for platforms without std::format float support (e.g., iOS < 16.3)
  261|       |               // Convert std::format spec to printf format at compile time
  262|       |               constexpr auto printf_fmt = detail::to_printf_fmt(opts_type::float_format);
  263|       |
  264|       |               const auto start = reinterpret_cast<char*>(&b[ix]);
  265|       |               const auto available = check_write_unchecked(Opts) ? size_t(64) : (b.size() - ix);
  266|       |
  267|       |               // snprintf returns chars that would be written (excluding null), or negative on error
  268|       |               const int len = std::snprintf(start, available, printf_fmt.data, static_cast<double>(value));
  269|       |
  270|       |               if (len < 0) {
  271|       |                  ctx.error = error_code::unexpected_end;
  272|       |                  return;
  273|       |               }
  274|       |
  275|       |               if (static_cast<size_t>(len) >= available) {
  276|       |                  // Output was truncated, need to resize and retry
  277|       |                  if constexpr (resizable<B> && not check_write_unchecked(Opts)) {
  278|       |                     b.resize(2 * (ix + static_cast<size_t>(len) + 1));
  279|       |                     std::snprintf(reinterpret_cast<char*>(&b[ix]), static_cast<size_t>(len) + 1, printf_fmt.data,
  280|       |                                   static_cast<double>(value));
  281|       |                  }
  282|       |                  else {
  283|       |                     ctx.error = error_code::unexpected_end;
  284|       |                     return;
  285|       |                  }
  286|       |               }
  287|       |               ix += static_cast<size_t>(len);
  288|       |#endif
  289|       |            }
  290|       |            else if constexpr (uint8_t(check_float_max_write_precision(Opts)) > 0 &&
  291|       |                               uint8_t(check_float_max_write_precision(Opts)) < sizeof(V)) {
  292|       |               // we cast to a lower precision floating point value before writing out
  293|       |               if constexpr (uint8_t(check_float_max_write_precision(Opts)) == 8) {
  294|       |                  const auto reduced = static_cast<double>(value);
  295|       |                  const auto start = reinterpret_cast<char*>(&b[ix]);
  296|       |                  const auto end = glz::to_chars(start, reduced);
  297|       |                  ix += size_t(end - start);
  298|       |               }
  299|       |               else if constexpr (uint8_t(check_float_max_write_precision(Opts)) == 4) {
  300|       |                  const auto reduced = static_cast<float>(value);
  301|       |                  const auto start = reinterpret_cast<char*>(&b[ix]);
  302|       |                  const auto end = glz::to_chars(start, reduced);
  303|       |                  ix += size_t(end - start);
  304|       |               }
  305|       |               else {
  306|       |                  static_assert(false_v<V>, "invalid float_max_write_precision");
  307|       |               }
  308|       |            }
  309|       |            // Size optimization: pass OptSize=true so the ~17KB pow-10 lookup
  310|       |            // tables are dropped (recomputed on the fly). Much faster than the
  311|       |            // old simple_float::to_chars path at essentially the same footprint.
  312|       |            // See discussion #2519.
  313|       |            else if constexpr (is_size_optimized(Opts) && is_any_of<V, float, double>) {
  314|       |               const auto start = reinterpret_cast<char*>(&b[ix]);
  315|       |               const auto end = glz::to_chars<V, /*OptSize=*/true>(start, V(value));
  316|       |               ix += size_t(end - start);
  317|       |            }
  318|  2.62k|            else if constexpr (is_any_of<V, float, double>) {
  319|  2.62k|               const auto start = reinterpret_cast<char*>(&b[ix]);
  320|  2.62k|               const auto end = glz::to_chars(start, value);
  321|  2.62k|               ix += size_t(end - start);
  322|       |            }
  323|       |// float128_t requires std::to_chars for floating-point, unavailable on older Apple platforms (iOS < 16.3)
  324|       |#if !defined(_LIBCPP_VERSION) || _LIBCPP_AVAILABILITY_HAS_TO_CHARS_FLOATING_POINT
  325|       |            else if constexpr (is_float128<V>) {
  326|       |               const auto start = reinterpret_cast<char*>(&b[ix]);
  327|       |               const auto [ptr, ec] = std::to_chars(start, &b[0] + b.size(), value, std::chars_format::general);
  328|       |               if (ec != std::errc()) {
  329|       |                  ctx.error = error_code::unexpected_end;
  330|       |                  return;
  331|       |               }
  332|       |               ix += size_t(ptr - start);
  333|       |            }
  334|       |#endif
  335|       |            else {
  336|       |               static_assert(false_v<V>, "type is not supported");
  337|       |            }
  338|       |         }
  339|       |         else if constexpr (is_any_of<V, int8_t, uint8_t, int16_t, uint16_t>) {
  340|       |            // Small integers: always use to_chars (400B tables)
  341|       |            // The 40KB digit_quads table doesn't help for these small ranges
  342|       |            const auto start = reinterpret_cast<char*>(&b[ix]);
  343|       |            const auto end = glz::to_chars(start, value);
  344|       |            ix += size_t(end - start);
  345|       |         }
  346|       |         else if constexpr (is_any_of<V, int32_t, uint32_t, int64_t, uint64_t>) {
  347|       |            const auto start = reinterpret_cast<char*>(&b[ix]);
  348|       |            if constexpr (is_size_optimized(Opts)) {
  349|       |               // Size mode: use glz::to_chars (400B lookup tables)
  350|       |               const auto end = glz::to_chars(start, value);
  351|       |               ix += size_t(end - start);
  352|       |            }
  353|       |            else {
  354|       |               // Normal mode: use to_chars_40kb (40KB digit_quads table)
  355|       |               const auto end = glz::to_chars_40kb(start, value);
  356|       |               ix += size_t(end - start);
  357|       |            }
  358|       |         }
  359|       |         else if constexpr (std::integral<V>) {
  360|       |            // Handle other integral types (char, wchar_t, etc.) by casting to sized types
  361|       |            using X = std::decay_t<decltype(sized_integer_conversion<V>())>;
  362|       |            const auto start = reinterpret_cast<char*>(&b[ix]);
  363|       |            if constexpr (is_size_optimized(Opts)) {
  364|       |               // Size mode: use glz::to_chars (400B lookup tables)
  365|       |               const auto end = glz::to_chars(start, static_cast<X>(value));
  366|       |               ix += size_t(end - start);
  367|       |            }
  368|       |            else {
  369|       |               // Normal mode: use to_chars_40kb
  370|       |               const auto end = glz::to_chars_40kb(start, static_cast<X>(value));
  371|       |               ix += size_t(end - start);
  372|       |            }
  373|       |         }
  374|       |         else {
  375|       |            static_assert(false_v<V>, "type is not supported");
  376|       |         }
  377|  2.62k|      }

_ZN3glz9sweethash7sweet32ITkNS0_16contiguous_rangeENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEEEjRKT_j:
  270|    516|   {
  271|    516|      return sweet32(static_cast<const void*>(s.data()), s.size(), seed);
  272|    516|   }
_ZN3glz9sweethash7sweet32EPKvmj:
  154|    516|   {
  155|    516|      const uint8_t* p = static_cast<const uint8_t*>(data);
  156|       |
  157|       |      // For inputs <= 8 bytes, use simple hash (tail handler requires len >= 9)
  158|    516|      if (len <= 8) {
  ------------------
  |  Branch (158:11): [True: 516, False: 0]
  ------------------
  159|    516|         uint64_t v = 0;
  160|    516|         switch (len) {
  161|     86|         case 8:
  ------------------
  |  Branch (161:10): [True: 86, False: 430]
  ------------------
  162|     86|            std::memcpy(&v, p, 8);
  163|     86|            break;
  164|     86|         case 7:
  ------------------
  |  Branch (164:10): [True: 86, False: 430]
  ------------------
  165|     86|            std::memcpy(&v, p, 7);
  166|     86|            break;
  167|     43|         case 6:
  ------------------
  |  Branch (167:10): [True: 43, False: 473]
  ------------------
  168|     43|            std::memcpy(&v, p, 6);
  169|     43|            break;
  170|    258|         case 5:
  ------------------
  |  Branch (170:10): [True: 258, False: 258]
  ------------------
  171|    258|            std::memcpy(&v, p, 5);
  172|    258|            break;
  173|     43|         case 4:
  ------------------
  |  Branch (173:10): [True: 43, False: 473]
  ------------------
  174|     43|            std::memcpy(&v, p, 4);
  175|     43|            break;
  176|      0|         case 3:
  ------------------
  |  Branch (176:10): [True: 0, False: 516]
  ------------------
  177|      0|            std::memcpy(&v, p, 3);
  178|      0|            break;
  179|      0|         case 2:
  ------------------
  |  Branch (179:10): [True: 0, False: 516]
  ------------------
  180|      0|            std::memcpy(&v, p, 2);
  181|      0|            break;
  182|      0|         case 1:
  ------------------
  |  Branch (182:10): [True: 0, False: 516]
  ------------------
  183|      0|            v = p[0];
  184|      0|            break;
  185|      0|         default:
  ------------------
  |  Branch (185:10): [True: 0, False: 516]
  ------------------
  186|      0|            break;
  187|    516|         }
  188|    516|         v = v ^ seed ^ (len + 1);
  189|    516|         return static_cast<uint32_t>(v) ^ static_cast<uint32_t>(v >> 32);
  190|    516|      }
  191|       |
  192|       |      // Full hash for inputs > 8 bytes
  193|      0|      uint64_t seed64 = (static_cast<uint64_t>(seed) << 32) | static_cast<uint64_t>(seed);
  194|      0|      uint64_t h = (seed64 ^ prime4) + (len * prime1);
  195|      0|      const uint8_t* const end = p + len;
  196|       |
  197|      0|      if (len >= 32) {
  ------------------
  |  Branch (197:11): [True: 0, False: 0]
  ------------------
  198|      0|         uint64_t h1 = h;
  199|      0|         uint64_t h2 = (seed64 * prime2) ^ prime3;
  200|      0|         uint64_t h3 = (seed64 * prime3) ^ prime4;
  201|      0|         uint64_t h4 = (seed64 * prime4) ^ prime5;
  202|       |
  203|      0|         do {
  204|      0|            uint64_t k1, k2, k3, k4;
  205|      0|            std::memcpy(&k1, p, 8);
  206|      0|            std::memcpy(&k2, p + 8, 8);
  207|      0|            std::memcpy(&k3, p + 16, 8);
  208|      0|            std::memcpy(&k4, p + 24, 8);
  209|       |
  210|      0|            k1 = k1 * prime2;
  211|      0|            k1 = k1 ^ (k1 >> 47);
  212|      0|            h1 = h1 ^ k1;
  213|      0|            h1 = h1 * prime1;
  214|       |
  215|      0|            k2 = k2 * prime3;
  216|      0|            k2 = k2 ^ (k2 >> 47);
  217|      0|            h2 = h2 ^ k2;
  218|      0|            h2 = h2 * prime2;
  219|       |
  220|      0|            k3 = k3 * prime4;
  221|      0|            k3 = k3 ^ (k3 >> 47);
  222|      0|            h3 = h3 ^ k3;
  223|      0|            h3 = h3 * prime3;
  224|       |
  225|      0|            k4 = k4 * prime5;
  226|      0|            k4 = k4 ^ (k4 >> 47);
  227|      0|            h4 = h4 ^ k4;
  228|      0|            h4 = h4 * prime4;
  229|       |
  230|      0|            p = p + 32;
  231|      0|            len = len - 32;
  232|      0|         } while (len >= 32);
  ------------------
  |  Branch (232:19): [True: 0, False: 0]
  ------------------
  233|       |
  234|      0|         h = h1 + h2 + h3 + h4;
  235|      0|      }
  236|       |
  237|      0|      while (len >= 8) {
  ------------------
  |  Branch (237:14): [True: 0, False: 0]
  ------------------
  238|      0|         uint64_t k;
  239|      0|         std::memcpy(&k, p, 8);
  240|      0|         k = k * prime2;
  241|      0|         k = k ^ (k >> 47);
  242|      0|         h = h ^ k;
  243|      0|         h = h * prime1;
  244|      0|         p = p + 8;
  245|      0|         len = len - 8;
  246|      0|      }
  247|       |
  248|      0|      if (len > 0) {
  ------------------
  |  Branch (248:11): [True: 0, False: 0]
  ------------------
  249|      0|         uint64_t k;
  250|      0|         std::memcpy(&k, end - 8, 8);
  251|      0|         k = k * prime2;
  252|      0|         k = k ^ (k >> 47);
  253|      0|         k = k * prime3;
  254|      0|         h = h ^ k;
  255|      0|      }
  256|       |
  257|      0|      h = mix64(h);
  258|      0|      return static_cast<uint32_t>(h) ^ static_cast<uint32_t>(h >> 32);
  259|    516|   }

_ZN3glz12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEC2Ev:
  338|  1.77M|      generic_json() = default;
_ZN3glz12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEC2EOS3_:
  341|  1.83M|      generic_json(generic_json&& other) noexcept : data(std::move(other.data)) {}
_ZN3glz12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEED2Ev:
  114|  3.60M|      ~generic_json() = default;

_ZN3glz11get_as_jsonINSt3__17variantIJDnNS1_17basic_string_viewIcNS1_11char_traitsIcEEEElEEETnNS_14string_literalEXtlNS8_ILm4EEEtlA4_cLc47ELc105ELc100EEEETnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETkNS_10contiguousERS6_EENS1_8expectedIT_NS_9error_ctxEEEOT2_:
  209|   122k|   {
  210|   122k|      const auto str = glz::get_view_json<Str, Opts>(buffer);
  211|   122k|      if (str) {
  ------------------
  |  Branch (211:11): [True: 19.7k, False: 102k]
  ------------------
  212|  19.7k|         T value{};
  213|  19.7k|         context ctx{};
  214|  19.7k|         if (const auto ec = glz::read<Opts>(value, *str, ctx); ec) {
  ------------------
  |  Branch (214:65): [True: 16.7k, False: 3.00k]
  ------------------
  215|  16.7k|            return unexpected(ec);
  216|  16.7k|         }
  217|  3.00k|         return value;
  218|  19.7k|      }
  219|   102k|      return unexpected(str.error());
  220|   122k|   }
_ZN3glz13get_view_jsonITnNS_14string_literalEXtlNS1_ILm4EEEtlA4_cLc47ELc105ELc100EEEETnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETkNS_10contiguousERNSt3__117basic_string_viewIcNS5_11char_traitsIcEEEEEEDaOT1_:
   24|   122k|   {
   25|   122k|      static constexpr auto S = chars<JsonPointer>;
   26|   122k|      static constexpr auto tokens = split_json_ptr<S>();
   27|   122k|      static constexpr auto N = tokens.size();
   28|       |
   29|   122k|      context ctx{};
   30|   122k|      auto p = read_iterators<Opts>(buffer);
   31|       |
   32|   122k|      auto it = p.first;
   33|   122k|      auto end = p.second;
   34|       |
   35|       |      // Don't automatically const qualify the buffer so we can write to the view,
   36|       |      // which allows us to write to a JSON Pointer location
   37|   122k|      using span_t =
   38|   122k|         std::span<std::conditional_t<std::is_const_v<std::remove_pointer_t<decltype(it)>>, const char, char>>;
   39|   122k|      using result_t = expected<span_t, error_ctx>;
   40|       |
   41|   122k|      auto start = it;
   42|       |
   43|   122k|      if (buffer.empty()) [[unlikely]] {
  ------------------
  |  Branch (43:11): [True: 0, False: 122k]
  ------------------
   44|      0|         ctx.error = error_code::no_read_input;
   45|      0|      }
   46|       |
   47|   122k|      if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (47:11): [True: 0, False: 122k]
  ------------------
   48|      0|         return result_t{unexpected(error_ctx{0, ctx.error})};
   49|      0|      }
   50|       |
   51|       |      if constexpr (N == 0) {
   52|       |         return result_t{span_t{it, end}};
   53|       |      }
   54|   122k|      else {
   55|   122k|         using namespace glz::detail;
   56|       |
   57|   122k|         skip_ws<Opts>(ctx, it, end);
   58|       |
   59|   122k|         result_t ret;
   60|       |
   61|   122k|         for_each<N>([&]<size_t I>() {
   62|   122k|            if (bool(ctx.error)) [[unlikely]] {
   63|   122k|               return;
   64|   122k|            }
   65|       |
   66|   122k|            static constexpr auto key = tokens[I];
   67|   122k|            if constexpr (maybe_numeric_key(key)) {
   68|   122k|               switch (*it) {
   69|   122k|               case '{': {
   70|   122k|                  ++it;
   71|   122k|                  while (true) {
   72|   122k|                     if (skip_ws<Opts>(ctx, it, end)) {
   73|   122k|                        return;
   74|   122k|                     }
   75|   122k|                     if (match<'"'>(ctx, it)) {
   76|   122k|                        return;
   77|   122k|                     }
   78|       |
   79|   122k|                     auto* start = it;
   80|   122k|                     skip_string_view(ctx, it, end);
   81|   122k|                     if (bool(ctx.error)) [[unlikely]]
   82|   122k|                        return;
   83|   122k|                     const sv k = {start, size_t(it - start)};
   84|   122k|                     ++it;
   85|       |
   86|   122k|                     if (key.size() == k.size() && comparitor<key>(k.data())) {
   87|   122k|                        if (skip_ws<Opts>(ctx, it, end)) {
   88|   122k|                           return;
   89|   122k|                        }
   90|   122k|                        if (match_invalid_end<':', Opts>(ctx, it, end)) {
   91|   122k|                           return;
   92|   122k|                        }
   93|   122k|                        if (skip_ws<Opts>(ctx, it, end)) {
   94|   122k|                           return;
   95|   122k|                        }
   96|       |
   97|   122k|                        if constexpr (I == (N - 1)) {
   98|   122k|                           ret = parse_value<Opts>(ctx, it, end);
   99|   122k|                        }
  100|   122k|                        return;
  101|   122k|                     }
  102|   122k|                     else {
  103|   122k|                        skip_value<JSON>::op<Opts>(ctx, it, end);
  104|   122k|                        if (bool(ctx.error)) [[unlikely]] {
  105|   122k|                           return;
  106|   122k|                        }
  107|   122k|                        if (it >= end || *it != ',') {
  108|   122k|                           ctx.error = it >= end ? error_code::unexpected_end : error_code::key_not_found;
  109|   122k|                           return;
  110|   122k|                        }
  111|   122k|                        ++it;
  112|   122k|                     }
  113|   122k|                  }
  114|   122k|               }
  115|   122k|               case '[': {
  116|   122k|                  ++it;
  117|       |                  // Could optimize by counting commas
  118|   122k|                  static constexpr auto n = stoui(key);
  119|   122k|                  if constexpr (n) {
  120|   122k|                     for_each<n.value()>([&]<size_t>() {
  121|   122k|                        skip_value<JSON>::op<Opts>(ctx, it, end);
  122|   122k|                        if (bool(ctx.error)) [[unlikely]] {
  123|   122k|                           return;
  124|   122k|                        }
  125|   122k|                        if (it >= end || *it != ',') {
  126|   122k|                           ctx.error = it >= end ? error_code::unexpected_end : error_code::array_element_not_found;
  127|   122k|                           return;
  128|   122k|                        }
  129|   122k|                        ++it;
  130|   122k|                     });
  131|       |
  132|   122k|                     if (skip_ws<Opts>(ctx, it, end)) {
  133|   122k|                        return;
  134|   122k|                     }
  135|       |
  136|   122k|                     if constexpr (I == (N - 1)) {
  137|   122k|                        ret = parse_value<Opts>(ctx, it, end);
  138|   122k|                     }
  139|   122k|                     return;
  140|   122k|                  }
  141|   122k|                  else {
  142|   122k|                     ctx.error = error_code::array_element_not_found;
  143|   122k|                     return;
  144|   122k|                  }
  145|   122k|               }
  146|   122k|               }
  147|   122k|            }
  148|   122k|            else {
  149|   122k|               if (match_invalid_end<'{', Opts>(ctx, it, end)) {
  150|   122k|                  return;
  151|   122k|               }
  152|       |
  153|   122k|               while (it < end) {
  154|   122k|                  if (skip_ws<Opts>(ctx, it, end)) {
  155|   122k|                     return;
  156|   122k|                  }
  157|   122k|                  if (match<'"'>(ctx, it)) {
  158|   122k|                     return;
  159|   122k|                  }
  160|       |
  161|   122k|                  auto* start = it;
  162|   122k|                  skip_string_view(ctx, it, end);
  163|   122k|                  if (bool(ctx.error)) [[unlikely]]
  164|   122k|                     return;
  165|   122k|                  const sv k = {start, size_t(it - start)};
  166|   122k|                  ++it;
  167|       |
  168|   122k|                  if (key.size() == k.size() && comparitor<key>(k.data())) {
  169|   122k|                     if (skip_ws<Opts>(ctx, it, end)) {
  170|   122k|                        return;
  171|   122k|                     }
  172|   122k|                     if (match_invalid_end<':', Opts>(ctx, it, end)) {
  173|   122k|                        return;
  174|   122k|                     }
  175|   122k|                     if (skip_ws<Opts>(ctx, it, end)) {
  176|   122k|                        return;
  177|   122k|                     }
  178|       |
  179|   122k|                     if constexpr (I == (N - 1)) {
  180|   122k|                        ret = parse_value<Opts>(ctx, it, end);
  181|   122k|                     }
  182|   122k|                     return;
  183|   122k|                  }
  184|   122k|                  else {
  185|   122k|                     skip_value<JSON>::op<Opts>(ctx, it, end);
  186|   122k|                     if (bool(ctx.error)) [[unlikely]] {
  187|   122k|                        return;
  188|   122k|                     }
  189|   122k|                     if (it >= end || *it != ',') {
  190|   122k|                        ctx.error = it >= end ? error_code::unexpected_end : error_code::key_not_found;
  191|   122k|                        return;
  192|   122k|                     }
  193|   122k|                     ++it;
  194|   122k|                  }
  195|   122k|               }
  196|   122k|            }
  197|   122k|         });
  198|       |
  199|   122k|         if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (199:14): [True: 102k, False: 19.7k]
  ------------------
  200|   102k|            return result_t{unexpected(error_ctx{size_t(it - start), ctx.error})};
  201|   102k|         }
  202|       |
  203|  19.7k|         return ret;
  204|   122k|      }
  205|   122k|   }
_ZZN3glz13get_view_jsonITnNS_14string_literalEXtlNS1_ILm4EEEtlA4_cLc47ELc105ELc100EEEETnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETkNS_10contiguousERNSt3__117basic_string_viewIcNS5_11char_traitsIcEEEEEEDaOT1_ENKUlTnmvE_clILm0EEEDav:
   61|   122k|         for_each<N>([&]<size_t I>() {
   62|   122k|            if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (62:17): [True: 0, False: 122k]
  ------------------
   63|      0|               return;
   64|      0|            }
   65|       |
   66|   122k|            static constexpr auto key = tokens[I];
   67|       |            if constexpr (maybe_numeric_key(key)) {
   68|       |               switch (*it) {
   69|       |               case '{': {
   70|       |                  ++it;
   71|       |                  while (true) {
   72|       |                     if (skip_ws<Opts>(ctx, it, end)) {
   73|       |                        return;
   74|       |                     }
   75|       |                     if (match<'"'>(ctx, it)) {
   76|       |                        return;
   77|       |                     }
   78|       |
   79|       |                     auto* start = it;
   80|       |                     skip_string_view(ctx, it, end);
   81|       |                     if (bool(ctx.error)) [[unlikely]]
   82|       |                        return;
   83|       |                     const sv k = {start, size_t(it - start)};
   84|       |                     ++it;
   85|       |
   86|       |                     if (key.size() == k.size() && comparitor<key>(k.data())) {
   87|       |                        if (skip_ws<Opts>(ctx, it, end)) {
   88|       |                           return;
   89|       |                        }
   90|       |                        if (match_invalid_end<':', Opts>(ctx, it, end)) {
   91|       |                           return;
   92|       |                        }
   93|       |                        if (skip_ws<Opts>(ctx, it, end)) {
   94|       |                           return;
   95|       |                        }
   96|       |
   97|       |                        if constexpr (I == (N - 1)) {
   98|       |                           ret = parse_value<Opts>(ctx, it, end);
   99|       |                        }
  100|       |                        return;
  101|       |                     }
  102|       |                     else {
  103|       |                        skip_value<JSON>::op<Opts>(ctx, it, end);
  104|       |                        if (bool(ctx.error)) [[unlikely]] {
  105|       |                           return;
  106|       |                        }
  107|       |                        if (it >= end || *it != ',') {
  108|       |                           ctx.error = it >= end ? error_code::unexpected_end : error_code::key_not_found;
  109|       |                           return;
  110|       |                        }
  111|       |                        ++it;
  112|       |                     }
  113|       |                  }
  114|       |               }
  115|       |               case '[': {
  116|       |                  ++it;
  117|       |                  // Could optimize by counting commas
  118|       |                  static constexpr auto n = stoui(key);
  119|       |                  if constexpr (n) {
  120|       |                     for_each<n.value()>([&]<size_t>() {
  121|       |                        skip_value<JSON>::op<Opts>(ctx, it, end);
  122|       |                        if (bool(ctx.error)) [[unlikely]] {
  123|       |                           return;
  124|       |                        }
  125|       |                        if (it >= end || *it != ',') {
  126|       |                           ctx.error = it >= end ? error_code::unexpected_end : error_code::array_element_not_found;
  127|       |                           return;
  128|       |                        }
  129|       |                        ++it;
  130|       |                     });
  131|       |
  132|       |                     if (skip_ws<Opts>(ctx, it, end)) {
  133|       |                        return;
  134|       |                     }
  135|       |
  136|       |                     if constexpr (I == (N - 1)) {
  137|       |                        ret = parse_value<Opts>(ctx, it, end);
  138|       |                     }
  139|       |                     return;
  140|       |                  }
  141|       |                  else {
  142|       |                     ctx.error = error_code::array_element_not_found;
  143|       |                     return;
  144|       |                  }
  145|       |               }
  146|       |               }
  147|       |            }
  148|   122k|            else {
  149|   122k|               if (match_invalid_end<'{', Opts>(ctx, it, end)) {
  ------------------
  |  Branch (149:20): [True: 95.3k, False: 26.7k]
  ------------------
  150|  95.3k|                  return;
  151|  95.3k|               }
  152|       |
  153|  36.3k|               while (it < end) {
  ------------------
  |  Branch (153:23): [True: 36.3k, False: 0]
  ------------------
  154|  36.3k|                  if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (154:23): [True: 0, False: 36.3k]
  ------------------
  155|      0|                     return;
  156|      0|                  }
  157|  36.3k|                  if (match<'"'>(ctx, it)) {
  ------------------
  |  Branch (157:23): [True: 0, False: 36.3k]
  ------------------
  158|      0|                     return;
  159|      0|                  }
  160|       |
  161|  36.3k|                  auto* start = it;
  162|  36.3k|                  skip_string_view(ctx, it, end);
  163|  36.3k|                  if (bool(ctx.error)) [[unlikely]]
  ------------------
  |  Branch (163:23): [True: 0, False: 36.3k]
  ------------------
  164|      0|                     return;
  165|  36.3k|                  const sv k = {start, size_t(it - start)};
  166|  36.3k|                  ++it;
  167|       |
  168|  36.3k|                  if (key.size() == k.size() && comparitor<key>(k.data())) {
  ------------------
  |  Branch (168:23): [True: 21.8k, False: 14.4k]
  |  Branch (168:49): [True: 19.7k, False: 2.14k]
  ------------------
  169|  19.7k|                     if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (169:26): [True: 0, False: 19.7k]
  ------------------
  170|      0|                        return;
  171|      0|                     }
  172|  19.7k|                     if (match_invalid_end<':', Opts>(ctx, it, end)) {
  ------------------
  |  Branch (172:26): [True: 0, False: 19.7k]
  ------------------
  173|      0|                        return;
  174|      0|                     }
  175|  19.7k|                     if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (175:26): [True: 0, False: 19.7k]
  ------------------
  176|      0|                        return;
  177|      0|                     }
  178|       |
  179|  19.7k|                     if constexpr (I == (N - 1)) {
  180|  19.7k|                        ret = parse_value<Opts>(ctx, it, end);
  181|  19.7k|                     }
  182|  19.7k|                     return;
  183|  19.7k|                  }
  184|  16.6k|                  else {
  185|  16.6k|                     skip_value<JSON>::op<Opts>(ctx, it, end);
  186|  16.6k|                     if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (186:26): [True: 0, False: 16.6k]
  ------------------
  187|      0|                        return;
  188|      0|                     }
  189|  16.6k|                     if (it >= end || *it != ',') {
  ------------------
  |  Branch (189:26): [True: 0, False: 16.6k]
  |  Branch (189:39): [True: 6.97k, False: 9.66k]
  ------------------
  190|  6.97k|                        ctx.error = it >= end ? error_code::unexpected_end : error_code::key_not_found;
  ------------------
  |  Branch (190:37): [True: 0, False: 6.97k]
  ------------------
  191|  6.97k|                        return;
  192|  6.97k|                     }
  193|  9.66k|                     ++it;
  194|  9.66k|                  }
  195|  36.3k|               }
  196|  26.7k|            }
  197|   122k|         });

_ZN3glz4fromILj10EiE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEERPKcRiTkNS_10is_contextERNS_7contextES5_EEvOT1_OT2_OT0_T3_:
  767|   643k|      {
  768|       |         if constexpr (check_quoted_num(Opts)) {
  769|       |            if (skip_ws<Opts>(ctx, it, end)) {
  770|       |               return;
  771|       |            }
  772|       |            if (match_invalid_end<'"', Opts>(ctx, it, end)) {
  773|       |               return;
  774|       |            }
  775|       |         }
  776|       |
  777|       |         if constexpr (!check_ws_handled(Opts)) {
  778|       |            if (skip_ws<Opts>(ctx, it, end)) {
  779|       |               return;
  780|       |            }
  781|       |         }
  782|       |
  783|   643k|         using V = std::decay_t<decltype(value)>;
  784|   643k|         if constexpr (int_t<V>) {
  785|   643k|            static_assert(sizeof(*it) == sizeof(char));
  786|       |
  787|       |            if constexpr (Opts.null_terminated) {
  788|       |               if (not glz::atoi(value, it)) [[unlikely]] {
  789|       |                  ctx.error = error_code::parse_number_failure;
  790|       |                  return;
  791|       |               }
  792|       |            }
  793|   643k|            else {
  794|   643k|               if (not glz::atoi(value, it, end)) [[unlikely]] {
  ------------------
  |  Branch (794:20): [True: 2.47k, False: 640k]
  ------------------
  795|  2.47k|                  ctx.error = error_code::parse_number_failure;
  796|  2.47k|                  return;
  797|  2.47k|               }
  798|   643k|            }
  799|       |         }
  800|       |         else {
  801|       |// float128_t requires std::from_chars for floating-point, unavailable on older Apple platforms (iOS < 16.3)
  802|       |#if !defined(_LIBCPP_VERSION) || defined(_LIBCPP_AVAILABILITY_HAS_TO_CHARS_FLOATING_POINT)
  803|       |            if constexpr (is_float128<V>) {
  804|       |               auto [ptr, ec] = std::from_chars(it, end, value);
  805|       |               if (ec != std::errc()) {
  806|       |                  ctx.error = error_code::parse_number_failure;
  807|       |                  return;
  808|       |               }
  809|       |               it = ptr;
  810|       |            }
  811|       |            else
  812|       |#endif
  813|       |            {
  814|       |               if constexpr (std::is_volatile_v<std::remove_reference_t<decltype(value)>>) {
  815|       |                  // Hardware may interact with value changes, so we parse into a temporary and assign in one
  816|       |                  // place
  817|       |                  V temp;
  818|       |                  if constexpr (is_size_optimized(Opts)) {
  819|       |                     auto [ptr, ec] = simple_float::from_chars<Opts.null_terminated>(it, end, temp);
  820|       |                     if (ec != std::errc{}) [[unlikely]] {
  821|       |                        ctx.error = error_code::parse_number_failure;
  822|       |                        return;
  823|       |                     }
  824|       |                     it = ptr;
  825|       |                  }
  826|       |                  else {
  827|       |                     auto [ptr, ec] = glz::from_chars<Opts.null_terminated>(it, end, temp);
  828|       |                     if (ec != std::errc()) [[unlikely]] {
  829|       |                        ctx.error = error_code::parse_number_failure;
  830|       |                        return;
  831|       |                     }
  832|       |                     it = ptr;
  833|       |                  }
  834|       |                  value = temp;
  835|       |               }
  836|       |               else {
  837|       |                  if constexpr (is_size_optimized(Opts)) {
  838|       |                     auto [ptr, ec] = simple_float::from_chars<Opts.null_terminated>(it, end, value);
  839|       |                     if (ec != std::errc{}) [[unlikely]] {
  840|       |                        ctx.error = error_code::parse_number_failure;
  841|       |                        return;
  842|       |                     }
  843|       |                     it = ptr;
  844|       |                  }
  845|       |                  else {
  846|       |                     auto [ptr, ec] = glz::from_chars<Opts.null_terminated>(it, end, value);
  847|       |                     if (ec != std::errc()) [[unlikely]] {
  848|       |                        ctx.error = error_code::parse_number_failure;
  849|       |                        return;
  850|       |                     }
  851|       |                     it = ptr;
  852|       |                  }
  853|       |               }
  854|       |            }
  855|       |         }
  856|       |
  857|       |         if constexpr (check_quoted_num(Opts)) {
  858|       |            if constexpr (not Opts.null_terminated) {
  859|       |               if (it == end) [[unlikely]] {
  860|       |                  ctx.error = error_code::unexpected_end;
  861|       |                  return;
  862|       |               }
  863|       |            }
  864|       |            if (match<'"'>(ctx, it)) {
  865|       |               return;
  866|       |            }
  867|       |            if constexpr (not Opts.null_terminated) {
  868|       |               if (it == end) {
  869|       |                  ctx.error = error_code::end_reached;
  870|       |                  return;
  871|       |               }
  872|       |            }
  873|       |         }
  874|   643k|         else {
  875|   643k|            if constexpr (not Opts.null_terminated) {
  876|   643k|               if (it == end) {
  ------------------
  |  Branch (876:20): [True: 0, False: 643k]
  ------------------
  877|      0|                  ctx.error = error_code::end_reached;
  878|      0|                  return;
  879|      0|               }
  880|   643k|            }
  881|   643k|         }
  882|   643k|      }
_ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERiTkNS_10is_contextERNS_7contextERPKcS8_EEvOT0_OT1_OT2_T3_:
   49|  1.30k|      {
   50|       |         if constexpr (const_value_v<T>) {
   51|       |            if constexpr (check_error_on_const_read(Opts)) {
   52|       |               ctx.error = error_code::attempt_const_read;
   53|       |            }
   54|       |            else {
   55|       |               // do not read anything into the const value
   56|       |               skip_value<JSON>::op<Opts>(std::forward<Ctx>(ctx), std::forward<It0>(it), end);
   57|       |            }
   58|       |         }
   59|  1.30k|         else {
   60|  1.30k|            using V = std::remove_cvref_t<T>;
   61|  1.30k|            from<JSON, V>::template op<Opts>(std::forward<T>(value), std::forward<Ctx>(ctx), std::forward<It0>(it),
   62|  1.30k|                                             end);
   63|  1.30k|         }
   64|  1.30k|      }
_ZN3glz4fromILj10EiE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERPKcRiTkNS_10is_contextERNS_7contextES5_EEvOT1_OT2_OT0_T3_:
  767|  1.30k|      {
  768|       |         if constexpr (check_quoted_num(Opts)) {
  769|       |            if (skip_ws<Opts>(ctx, it, end)) {
  770|       |               return;
  771|       |            }
  772|       |            if (match_invalid_end<'"', Opts>(ctx, it, end)) {
  773|       |               return;
  774|       |            }
  775|       |         }
  776|       |
  777|  1.30k|         if constexpr (!check_ws_handled(Opts)) {
  778|  1.30k|            if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (778:17): [True: 0, False: 1.30k]
  ------------------
  779|      0|               return;
  780|      0|            }
  781|  1.30k|         }
  782|       |
  783|  1.30k|         using V = std::decay_t<decltype(value)>;
  784|  1.30k|         if constexpr (int_t<V>) {
  785|  1.30k|            static_assert(sizeof(*it) == sizeof(char));
  786|       |
  787|       |            if constexpr (Opts.null_terminated) {
  788|       |               if (not glz::atoi(value, it)) [[unlikely]] {
  789|       |                  ctx.error = error_code::parse_number_failure;
  790|       |                  return;
  791|       |               }
  792|       |            }
  793|  1.30k|            else {
  794|  1.30k|               if (not glz::atoi(value, it, end)) [[unlikely]] {
  ------------------
  |  Branch (794:20): [True: 648, False: 652]
  ------------------
  795|    648|                  ctx.error = error_code::parse_number_failure;
  796|    648|                  return;
  797|    648|               }
  798|  1.30k|            }
  799|       |         }
  800|       |         else {
  801|       |// float128_t requires std::from_chars for floating-point, unavailable on older Apple platforms (iOS < 16.3)
  802|       |#if !defined(_LIBCPP_VERSION) || defined(_LIBCPP_AVAILABILITY_HAS_TO_CHARS_FLOATING_POINT)
  803|       |            if constexpr (is_float128<V>) {
  804|       |               auto [ptr, ec] = std::from_chars(it, end, value);
  805|       |               if (ec != std::errc()) {
  806|       |                  ctx.error = error_code::parse_number_failure;
  807|       |                  return;
  808|       |               }
  809|       |               it = ptr;
  810|       |            }
  811|       |            else
  812|       |#endif
  813|       |            {
  814|       |               if constexpr (std::is_volatile_v<std::remove_reference_t<decltype(value)>>) {
  815|       |                  // Hardware may interact with value changes, so we parse into a temporary and assign in one
  816|       |                  // place
  817|       |                  V temp;
  818|       |                  if constexpr (is_size_optimized(Opts)) {
  819|       |                     auto [ptr, ec] = simple_float::from_chars<Opts.null_terminated>(it, end, temp);
  820|       |                     if (ec != std::errc{}) [[unlikely]] {
  821|       |                        ctx.error = error_code::parse_number_failure;
  822|       |                        return;
  823|       |                     }
  824|       |                     it = ptr;
  825|       |                  }
  826|       |                  else {
  827|       |                     auto [ptr, ec] = glz::from_chars<Opts.null_terminated>(it, end, temp);
  828|       |                     if (ec != std::errc()) [[unlikely]] {
  829|       |                        ctx.error = error_code::parse_number_failure;
  830|       |                        return;
  831|       |                     }
  832|       |                     it = ptr;
  833|       |                  }
  834|       |                  value = temp;
  835|       |               }
  836|       |               else {
  837|       |                  if constexpr (is_size_optimized(Opts)) {
  838|       |                     auto [ptr, ec] = simple_float::from_chars<Opts.null_terminated>(it, end, value);
  839|       |                     if (ec != std::errc{}) [[unlikely]] {
  840|       |                        ctx.error = error_code::parse_number_failure;
  841|       |                        return;
  842|       |                     }
  843|       |                     it = ptr;
  844|       |                  }
  845|       |                  else {
  846|       |                     auto [ptr, ec] = glz::from_chars<Opts.null_terminated>(it, end, value);
  847|       |                     if (ec != std::errc()) [[unlikely]] {
  848|       |                        ctx.error = error_code::parse_number_failure;
  849|       |                        return;
  850|       |                     }
  851|       |                     it = ptr;
  852|       |                  }
  853|       |               }
  854|       |            }
  855|       |         }
  856|       |
  857|       |         if constexpr (check_quoted_num(Opts)) {
  858|       |            if constexpr (not Opts.null_terminated) {
  859|       |               if (it == end) [[unlikely]] {
  860|       |                  ctx.error = error_code::unexpected_end;
  861|       |                  return;
  862|       |               }
  863|       |            }
  864|       |            if (match<'"'>(ctx, it)) {
  865|       |               return;
  866|       |            }
  867|       |            if constexpr (not Opts.null_terminated) {
  868|       |               if (it == end) {
  869|       |                  ctx.error = error_code::end_reached;
  870|       |                  return;
  871|       |               }
  872|       |            }
  873|       |         }
  874|  1.30k|         else {
  875|  1.30k|            if constexpr (not Opts.null_terminated) {
  876|  1.30k|               if (it == end) {
  ------------------
  |  Branch (876:20): [True: 506, False: 794]
  ------------------
  877|    506|                  ctx.error = error_code::end_reached;
  878|    506|                  return;
  879|    506|               }
  880|  1.30k|            }
  881|  1.30k|         }
  882|  1.30k|      }
_ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERN12jsonrpc_fuzz5pointETkNS_10is_contextERNS_7contextERPKcSA_EEvOT0_OT1_OT2_T3_:
   49|  1.18k|      {
   50|       |         if constexpr (const_value_v<T>) {
   51|       |            if constexpr (check_error_on_const_read(Opts)) {
   52|       |               ctx.error = error_code::attempt_const_read;
   53|       |            }
   54|       |            else {
   55|       |               // do not read anything into the const value
   56|       |               skip_value<JSON>::op<Opts>(std::forward<Ctx>(ctx), std::forward<It0>(it), end);
   57|       |            }
   58|       |         }
   59|  1.18k|         else {
   60|  1.18k|            using V = std::remove_cvref_t<T>;
   61|  1.18k|            from<JSON, V>::template op<Opts>(std::forward<T>(value), std::forward<Ctx>(ctx), std::forward<It0>(it),
   62|  1.18k|                                             end);
   63|  1.18k|         }
   64|  1.18k|      }
_ZN3glz4fromILj10EN12jsonrpc_fuzz5pointEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnNS_14string_literalEXtlNS6_ILm1EEEEERS2_TkNS_10is_contextERNS_7contextERPKcSC_EEvOT1_OT2_OT3_T4_:
 3044|  1.18k|      {
 3045|  1.18k|         static constexpr auto num_members = reflect<T>::size;
 3046|       |
 3047|  1.18k|         static constexpr auto Opts = opening_handled_off<ws_handled_off<Options>()>();
 3048|  1.18k|         if constexpr (!check_opening_handled(Options)) {
 3049|  1.18k|            if constexpr (!check_ws_handled(Options)) {
 3050|  1.18k|               if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (3050:20): [True: 0, False: 1.18k]
  ------------------
 3051|      0|                  return;
 3052|      0|               }
 3053|  1.18k|            }
 3054|  1.18k|            if (match_invalid_end<'{', Opts>(ctx, it, end)) {
  ------------------
  |  Branch (3054:17): [True: 272, False: 914]
  ------------------
 3055|    272|               return;
 3056|    272|            }
 3057|    914|            if constexpr (not Opts.null_terminated) {
 3058|    914|               if (it == end) [[unlikely]] {
  ------------------
  |  Branch (3058:20): [True: 0, False: 914]
  ------------------
 3059|      0|                  ctx.error = error_code::unexpected_end;
 3060|      0|                  return;
 3061|      0|               }
 3062|    914|            }
 3063|       |            // one nesting level (see enter_depth): counted in both modes so the limit binds,
 3064|       |            // released at each syntactic close below
 3065|    914|            if (enter_depth(ctx)) [[unlikely]] {
  ------------------
  |  Branch (3065:17): [True: 0, False: 914]
  ------------------
 3066|      0|               return;
 3067|      0|            }
 3068|    914|         }
 3069|    914|         const auto ws_start = it;
 3070|  1.18k|         if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (3070:14): [True: 0, False: 1.18k]
  ------------------
 3071|      0|            return;
 3072|      0|         }
 3073|  1.18k|         const size_t ws_size = size_t(it - ws_start);
 3074|       |
 3075|       |         if constexpr ((glaze_object_t<T> || reflectable<T>) && num_members == 0 && Opts.error_on_unknown_keys) {
 3076|       |            if constexpr (not tag.sv().empty()) {
 3077|       |               if (*it == '"') {
 3078|       |                  ++it;
 3079|       |                  if constexpr (not Opts.null_terminated) {
 3080|       |                     if (it == end) [[unlikely]] {
 3081|       |                        ctx.error = error_code::unexpected_end;
 3082|       |                        return;
 3083|       |                     }
 3084|       |                  }
 3085|       |
 3086|       |                  const auto start = it;
 3087|       |                  skip_string_view(ctx, it, end);
 3088|       |                  if (bool(ctx.error)) [[unlikely]]
 3089|       |                     return;
 3090|       |                  if (validate_utf8_span<Opts>(ctx, start, it)) [[unlikely]]
 3091|       |                     return;
 3092|       |                  const sv key{start, size_t(it - start)};
 3093|       |                  ++it;
 3094|       |                  if constexpr (not Opts.null_terminated) {
 3095|       |                     if (it == end) [[unlikely]] {
 3096|       |                        ctx.error = error_code::unexpected_end;
 3097|       |                        return;
 3098|       |                     }
 3099|       |                  }
 3100|       |
 3101|       |                  if (key == tag.sv()) {
 3102|       |                     if (parse_ws_colon<Opts>(ctx, it, end)) {
 3103|       |                        return;
 3104|       |                     }
 3105|       |
 3106|       |                     parse<JSON>::handle_unknown<Opts>(key, value, ctx, it, end);
 3107|       |                     if (bool(ctx.error)) [[unlikely]]
 3108|       |                        return;
 3109|       |
 3110|       |                     if (skip_ws<Opts>(ctx, it, end)) {
 3111|       |                        return;
 3112|       |                     }
 3113|       |                  }
 3114|       |                  else {
 3115|       |                     ctx.error = error_code::unknown_key;
 3116|       |                     return;
 3117|       |                  }
 3118|       |               }
 3119|       |            }
 3120|       |
 3121|       |            if (*it == '}') [[likely]] {
 3122|       |               --ctx.depth;
 3123|       |               if constexpr (glaze_object_t<T> || reflectable<T>) {
 3124|       |                  if constexpr (has_self_constraint_v<T> && !check_skip_self_constraint(Opts)) {
 3125|       |                     auto wrapper = self_constraint_v<T>(value);
 3126|       |                     from<JSON, decltype(wrapper)>::template op<ws_handled<Opts>()>(wrapper, ctx, it, end);
 3127|       |                     if (bool(ctx.error)) {
 3128|       |                        return;
 3129|       |                     }
 3130|       |                  }
 3131|       |               }
 3132|       |               ++it;
 3133|       |               if constexpr (not Opts.null_terminated) {
 3134|       |                  if (it == end) {
 3135|       |                     ctx.error = error_code::end_reached;
 3136|       |                     return;
 3137|       |                  }
 3138|       |               }
 3139|       |               if constexpr (Opts.partial_read) {
 3140|       |                  ctx.error = error_code::partial_read_complete;
 3141|       |               }
 3142|       |               return;
 3143|       |            }
 3144|       |            ctx.error = error_code::unknown_key;
 3145|       |            return;
 3146|       |         }
 3147|  1.18k|         else {
 3148|  1.18k|            decltype(auto) fields = [&]() -> decltype(auto) {
 3149|  1.18k|               if constexpr ((glaze_object_t<T> || reflectable<T>) &&
 3150|  1.18k|                             (Opts.error_on_missing_keys || Opts.partial_read)) {
 3151|  1.18k|                  return bit_array<num_members>{};
 3152|  1.18k|               }
 3153|  1.18k|               else {
 3154|  1.18k|                  return nullptr;
 3155|  1.18k|               }
 3156|  1.18k|            }();
 3157|       |
 3158|  1.18k|            size_t read_count{}; // for partial_read
 3159|       |
 3160|  1.18k|            bool first = true;
 3161|  5.34k|            while (true) {
  ------------------
  |  Branch (3161:20): [True: 4.31k, Folded]
  ------------------
 3162|       |               if constexpr ((glaze_object_t<T> || reflectable<T>) && Opts.partial_read) {
 3163|       |                  static constexpr bit_array<num_members> all_fields = [] {
 3164|       |                     bit_array<num_members> arr{};
 3165|       |                     for (size_t i = 0; i < num_members; ++i) {
 3166|       |                        arr[i] = true;
 3167|       |                     }
 3168|       |                     return arr;
 3169|       |                  }();
 3170|       |
 3171|       |                  if ((all_fields & fields) == all_fields) {
 3172|       |                     ctx.error = error_code::partial_read_complete;
 3173|       |                     --ctx.depth; // as above: an early success still closes this level
 3174|       |                     return;
 3175|       |                  }
 3176|       |               }
 3177|       |
 3178|       |               // Streaming refill point: at start of each iteration, ensure buffer has data
 3179|       |               if constexpr (has_streaming_state<decltype(ctx)>) {
 3180|       |                  if (ctx.stream.enabled()) {
 3181|       |                     const size_t consumed = static_cast<size_t>(it - ctx.stream.data());
 3182|       |                     const size_t remaining = ctx.stream.size() - consumed;
 3183|       |                     // Refill when less than half of buffer remains to ensure space for next key-value pair
 3184|       |                     if (remaining <= ctx.stream.size() / 2 || it >= end) {
 3185|       |                        const char* new_it;
 3186|       |                        const char* new_end;
 3187|       |                        ctx.stream.consume_and_refill(consumed, new_it, new_end);
 3188|       |                        it = new_it;
 3189|       |                        end = new_end;
 3190|       |                        if (it >= end && ctx.stream.at_eof()) {
 3191|       |                           ctx.error = error_code::unexpected_end;
 3192|       |                           return;
 3193|       |                        }
 3194|       |                     }
 3195|       |                  }
 3196|       |               }
 3197|       |
 3198|  4.31k|               if (*it == '}') {
  ------------------
  |  Branch (3198:20): [True: 114, False: 4.20k]
  ------------------
 3199|    114|                  --ctx.depth;
 3200|       |                  if constexpr ((glaze_object_t<T> || reflectable<T>) && Opts.error_on_missing_keys) {
 3201|       |                     constexpr auto req_fields = required_fields<T, Opts>();
 3202|       |                     if ((req_fields & fields) != req_fields) {
 3203|       |                        for (size_t i = 0; i < num_members; ++i) {
 3204|       |                           if (not fields[i] && req_fields[i]) {
 3205|       |                              ctx.custom_error_message = reflect<T>::keys[i];
 3206|       |                              // We just return the first missing key in order to avoid heap allocations
 3207|       |                              break;
 3208|       |                           }
 3209|       |                        }
 3210|       |
 3211|       |                        ctx.error = error_code::missing_key;
 3212|       |                        return;
 3213|       |                     }
 3214|       |                  }
 3215|    114|                  if constexpr (glaze_object_t<T> || reflectable<T>) {
 3216|       |                     if constexpr (has_self_constraint_v<T> && !check_skip_self_constraint(Opts)) {
 3217|       |                        auto wrapper = self_constraint_v<T>(value);
 3218|       |                        from<JSON, decltype(wrapper)>::template op<ws_handled<Opts>()>(wrapper, ctx, it, end);
 3219|       |                        if (bool(ctx.error)) {
 3220|       |                           return;
 3221|       |                        }
 3222|       |                     }
 3223|    114|                  }
 3224|    114|                  ++it; // Increment after checking for missing keys so errors are within buffer bounds
 3225|    114|                  if constexpr (not Opts.null_terminated) {
 3226|    114|                     if (it == end) {
  ------------------
  |  Branch (3226:26): [True: 114, False: 0]
  ------------------
 3227|    114|                        ctx.error = error_code::end_reached;
 3228|    114|                        return;
 3229|    114|                     }
 3230|    114|                  }
 3231|      0|                  return;
 3232|    114|               }
 3233|  4.20k|               else if (first) {
  ------------------
  |  Branch (3233:25): [True: 878, False: 3.32k]
  ------------------
 3234|    878|                  first = false;
 3235|    878|               }
 3236|  3.32k|               else {
 3237|  3.32k|                  if (match_invalid_end<',', Opts>(ctx, it, end)) {
  ------------------
  |  Branch (3237:23): [True: 44, False: 3.27k]
  ------------------
 3238|     44|                     return;
 3239|     44|                  }
 3240|  3.27k|                  if constexpr (not Opts.null_terminated) {
 3241|  3.27k|                     if (it == end) [[unlikely]] {
  ------------------
  |  Branch (3241:26): [True: 0, False: 3.27k]
  ------------------
 3242|      0|                        ctx.error = error_code::unexpected_end;
 3243|      0|                        return;
 3244|      0|                     }
 3245|  3.27k|                  }
 3246|       |
 3247|       |                  if constexpr ((not Opts.minified) && (num_members > 1 || not Opts.error_on_unknown_keys) &&
 3248|  3.27k|                                (!Opts.comments)) {
 3249|  3.27k|                     if (ws_size && ws_size < size_t(end - it)) {
  ------------------
  |  Branch (3249:26): [True: 3.05k, False: 225]
  |  Branch (3249:37): [True: 2.97k, False: 81]
  ------------------
 3250|  2.97k|                        skip_matching_ws(ws_start, it, ws_size);
 3251|  2.97k|                     }
 3252|  3.27k|                  }
 3253|       |
 3254|  3.27k|                  if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (3254:23): [True: 0, False: 3.27k]
  ------------------
 3255|      0|                     return;
 3256|      0|                  }
 3257|  3.27k|               }
 3258|       |
 3259|  4.15k|               constexpr auto reflection_type = glaze_object_t<T> || reflectable<T>;
  ------------------
  |  Branch (3259:49): [Folded, False: 0]
  |  Branch (3259:70): [True: 0, Folded]
  ------------------
 3260|       |
 3261|       |               if constexpr (reflection_type && (num_members == 0)) {
 3262|       |                  if constexpr (Opts.error_on_unknown_keys) {
 3263|       |                     static_assert(false_v<T>, "This should be unreachable");
 3264|       |                  }
 3265|       |                  else {
 3266|       |                     if (match_invalid_end<'"', Opts>(ctx, it, end)) {
 3267|       |                        return;
 3268|       |                     }
 3269|       |
 3270|       |                     // parsing to an empty object, but at this point the JSON presents keys
 3271|       |
 3272|       |                     // Unknown key handler does not unescape keys. Unknown escaped keys are
 3273|       |                     // handled by the user.
 3274|       |
 3275|       |                     const auto start = it;
 3276|       |                     skip_string_view(ctx, it, end);
 3277|       |                     if (bool(ctx.error)) [[unlikely]]
 3278|       |                        return;
 3279|       |                     if (validate_utf8_span<Opts>(ctx, start, it)) [[unlikely]]
 3280|       |                        return;
 3281|       |                     const sv key{start, size_t(it - start)};
 3282|       |                     ++it;
 3283|       |                     if constexpr (not Opts.null_terminated) {
 3284|       |                        if (it == end) [[unlikely]] {
 3285|       |                           ctx.error = error_code::unexpected_end;
 3286|       |                           return;
 3287|       |                        }
 3288|       |                     }
 3289|       |
 3290|       |                     if (parse_ws_colon<Opts>(ctx, it, end)) {
 3291|       |                        return;
 3292|       |                     }
 3293|       |
 3294|       |                     // Check if this key is the variant tag that should be skipped
 3295|       |                     if constexpr (not tag.sv().empty()) {
 3296|       |                        if (key == tag.sv()) {
 3297|       |                           // Skip the tag value
 3298|       |                           skip_value<JSON>::op<Opts>(ctx, it, end);
 3299|       |                           if (bool(ctx.error)) [[unlikely]]
 3300|       |                              return;
 3301|       |                           resync_window_end(ctx, end); // a streaming skip refills
 3302|       |                           if (skip_ws<Opts>(ctx, it, end)) {
 3303|       |                              return;
 3304|       |                           }
 3305|       |                           continue;
 3306|       |                        }
 3307|       |                     }
 3308|       |
 3309|       |                     parse<JSON>::handle_unknown<Opts>(key, value, ctx, it, end);
 3310|       |                     if (bool(ctx.error)) [[unlikely]]
 3311|       |                        return;
 3312|       |                     if constexpr (not Opts.null_terminated) {
 3313|       |                        if (it == end) [[unlikely]] {
 3314|       |                           ctx.error = error_code::unexpected_end;
 3315|       |                           return;
 3316|       |                        }
 3317|       |                     }
 3318|       |                     if (skip_ws<Opts>(ctx, it, end)) {
 3319|       |                        return;
 3320|       |                     }
 3321|       |                  }
 3322|       |               }
 3323|  4.15k|               else if constexpr (reflection_type) {
 3324|  4.15k|                  static_assert(bool(hash_info<T>.type));
 3325|       |
 3326|  4.15k|                  if (*it != '"') [[unlikely]] {
  ------------------
  |  Branch (3326:23): [True: 507, False: 3.64k]
  ------------------
 3327|    507|                     ctx.error = error_code::expected_quote;
 3328|    507|                     return;
 3329|    507|                  }
 3330|  3.64k|                  ++it;
 3331|  3.64k|                  if constexpr (not Opts.null_terminated) {
 3332|  3.64k|                     if (it == end) [[unlikely]] {
  ------------------
  |  Branch (3332:26): [True: 0, False: 3.64k]
  ------------------
 3333|      0|                        ctx.error = error_code::unexpected_end;
 3334|      0|                        return;
 3335|      0|                     }
 3336|  3.64k|                  }
 3337|       |
 3338|       |                  if constexpr (not tag.sv().empty() && not contains_tag<T, tag>()) {
 3339|       |                     // For tagged variants we first check to see if the key matches the tag
 3340|       |                     // We only need to do this if the tag is not part of the keys
 3341|       |
 3342|       |                     const auto start = it;
 3343|       |                     skip_string_view(ctx, it, end);
 3344|       |                     if (bool(ctx.error)) [[unlikely]]
 3345|       |                        return;
 3346|       |                     if (validate_utf8_span<Opts>(ctx, start, it)) [[unlikely]]
 3347|       |                        return;
 3348|       |                     const sv key{start, size_t(it - start)};
 3349|       |                     ++it;
 3350|       |                     if constexpr (not Opts.null_terminated) {
 3351|       |                        if (it == end) [[unlikely]] {
 3352|       |                           ctx.error = error_code::unexpected_end;
 3353|       |                           return;
 3354|       |                        }
 3355|       |                     }
 3356|       |
 3357|       |                     if (key == tag.sv()) {
 3358|       |                        if (parse_ws_colon<Opts>(ctx, it, end)) {
 3359|       |                           return;
 3360|       |                        }
 3361|       |
 3362|       |                        parse<JSON>::handle_unknown<Opts>(key, value, ctx, it, end);
 3363|       |                        if (bool(ctx.error)) [[unlikely]]
 3364|       |                           return;
 3365|       |
 3366|       |                        if (skip_ws<Opts>(ctx, it, end)) {
 3367|       |                           return;
 3368|       |                        }
 3369|       |                        continue;
 3370|       |                     }
 3371|       |                     else {
 3372|       |                        it = start; // reset the iterator
 3373|       |                     }
 3374|       |                  }
 3375|       |
 3376|       |                  if constexpr (Opts.error_on_missing_keys || Opts.partial_read) {
 3377|       |                     size_t index = num_members;
 3378|       |                     parse_and_invoke<Opts, T>(value, ctx, it, end, index);
 3379|       |                     if (bool(ctx.error)) [[unlikely]]
 3380|       |                        return;
 3381|       |                     if (index < num_members) {
 3382|       |                        fields[index] = true;
 3383|       |                     }
 3384|       |                  }
 3385|  3.64k|                  else {
 3386|  3.64k|                     parse_and_invoke<Opts, T>(value, ctx, it, end);
 3387|  3.64k|                     if (bool(ctx.error)) [[unlikely]]
  ------------------
  |  Branch (3387:26): [True: 249, False: 3.40k]
  ------------------
 3388|    249|                        return;
 3389|  3.64k|                  }
 3390|       |               }
 3391|       |               else {
 3392|       |                  // For types like std::map, std::unordered_map
 3393|       |
 3394|       |                  auto reading = [&](auto&& key) {
 3395|       |                     if constexpr (Opts.partial_read) {
 3396|       |                        if (auto element = value.find(key); element != value.end()) {
 3397|       |                           ++read_count;
 3398|       |                           parse<JSON>::op<ws_handled<Opts>()>(element->second, ctx, it, end);
 3399|       |                        }
 3400|       |                        else {
 3401|       |                           skip_value<JSON>::op<Opts>(ctx, it, end);
 3402|       |                        }
 3403|       |                     }
 3404|       |                     else {
 3405|       |                        parse<JSON>::op<ws_handled<Opts>()>(value[key], ctx, it, end);
 3406|       |                     }
 3407|       |                  };
 3408|       |
 3409|       |                  // using Key = std::conditional_t<heterogeneous_map<T>, sv, typename T::key_type>;
 3410|       |                  using Key = typename T::key_type;
 3411|       |                  if constexpr (std::is_same_v<Key, std::string>) {
 3412|       |                     ctx.scratch.clear();
 3413|       |                     parse<JSON>::op<Opts>(ctx.scratch, ctx, it, end);
 3414|       |                     if (bool(ctx.error)) [[unlikely]]
 3415|       |                        return;
 3416|       |
 3417|       |                     if (parse_ws_colon<Opts>(ctx, it, end)) {
 3418|       |                        return;
 3419|       |                     }
 3420|       |
 3421|       |                     reading(ctx.scratch);
 3422|       |                     if constexpr (Opts.partial_read) {
 3423|       |                        if (read_count == value.size()) {
 3424|       |                           return;
 3425|       |                        }
 3426|       |                     }
 3427|       |                     if (bool(ctx.error)) [[unlikely]]
 3428|       |                        return;
 3429|       |                  }
 3430|       |                  else if constexpr (str_t<Key>) {
 3431|       |                     Key key;
 3432|       |                     parse<JSON>::op<Opts>(key, ctx, it, end);
 3433|       |                     if (bool(ctx.error)) [[unlikely]]
 3434|       |                        return;
 3435|       |
 3436|       |                     if (parse_ws_colon<Opts>(ctx, it, end)) {
 3437|       |                        return;
 3438|       |                     }
 3439|       |
 3440|       |                     reading(key);
 3441|       |                     if constexpr (Opts.partial_read) {
 3442|       |                        if (read_count == value.size()) {
 3443|       |                           return;
 3444|       |                        }
 3445|       |                     }
 3446|       |                     if (bool(ctx.error)) [[unlikely]]
 3447|       |                        return;
 3448|       |                  }
 3449|       |                  else {
 3450|       |                     Key key_value{};
 3451|       |                     if constexpr (is_named_enum<Key> || mimics_str_t<Key>) {
 3452|       |                        parse<JSON>::op<Opts>(key_value, ctx, it, end);
 3453|       |                     }
 3454|       |                     else if constexpr (std::is_arithmetic_v<Key>) {
 3455|       |                        // prefer over quoted_t below to avoid double parsing of quoted_t
 3456|       |                        parse<JSON>::op<opt_true<Opts, quoted_num_opt_tag{}>>(key_value, ctx, it, end);
 3457|       |                     }
 3458|       |                     else {
 3459|       |                        parse<JSON>::op<opt_false<Opts, raw_string_opt_tag{}>>(quoted_t<Key>{key_value}, ctx, it, end);
 3460|       |                     }
 3461|       |                     if (bool(ctx.error)) [[unlikely]]
 3462|       |                        return;
 3463|       |
 3464|       |                     if (parse_ws_colon<Opts>(ctx, it, end)) {
 3465|       |                        return;
 3466|       |                     }
 3467|       |
 3468|       |                     reading(key_value);
 3469|       |                     if constexpr (Opts.partial_read) {
 3470|       |                        if (read_count == value.size()) {
 3471|       |                           return;
 3472|       |                        }
 3473|       |                     }
 3474|       |                     if (bool(ctx.error)) [[unlikely]]
 3475|       |                        return;
 3476|       |                  }
 3477|       |               }
 3478|       |
 3479|       |               // Streaming refill point: after parsing each key-value pair, refill if buffer is low
 3480|       |               if constexpr (has_streaming_state<decltype(ctx)>) {
 3481|       |                  if (ctx.stream.enabled()) {
 3482|       |                     const size_t consumed = static_cast<size_t>(it - ctx.stream.data());
 3483|       |                     // Refill when less than 25% of buffer remains to ensure enough space for next element
 3484|       |                     if (ctx.stream.size() - consumed <= ctx.stream.size() / 4 || it >= end) {
 3485|       |                        const char* new_it;
 3486|       |                        const char* new_end;
 3487|       |                        ctx.stream.consume_and_refill(consumed, new_it, new_end);
 3488|       |                        it = new_it;
 3489|       |                        end = new_end;
 3490|       |                        if (it >= end && ctx.stream.at_eof()) {
 3491|       |                           ctx.error = error_code::unexpected_end;
 3492|       |                           return;
 3493|       |                        }
 3494|       |                     }
 3495|       |                  }
 3496|       |               }
 3497|       |
 3498|  4.15k|               if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (3498:20): [True: 0, False: 4.15k]
  ------------------
 3499|      0|                  return;
 3500|      0|               }
 3501|  4.15k|            }
 3502|  1.18k|         }
 3503|  1.18k|      }
_ZZN3glz4fromILj10EN12jsonrpc_fuzz5pointEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnNS_14string_literalEXtlNS6_ILm1EEEEERS2_TkNS_10is_contextERNS_7contextERPKcSC_EEvOT1_OT2_OT3_T4_ENKUlvE_clEv:
 3148|    914|            decltype(auto) fields = [&]() -> decltype(auto) {
 3149|       |               if constexpr ((glaze_object_t<T> || reflectable<T>) &&
 3150|       |                             (Opts.error_on_missing_keys || Opts.partial_read)) {
 3151|       |                  return bit_array<num_members>{};
 3152|       |               }
 3153|    914|               else {
 3154|    914|                  return nullptr;
 3155|    914|               }
 3156|    914|            }();
_ZN3glz16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz5pointERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT3_OT4_OT5_DpOT2_:
  376|  7.36k|   {
  377|  7.36k|      constexpr auto N = reflect<T>::size;
  378|       |
  379|       |      if constexpr (N == 1) {
  380|       |         decode_index<Opts, T, 0>(value, ctx, it, end, selected_index...);
  381|       |      }
  382|       |      else if constexpr (check_linear_search(Opts)) {
  383|       |         // Linear search path
  384|       |         auto key_start = it;
  385|       |         const auto index = decode_linear<T>(ctx, it, end);
  386|       |         if (bool(ctx.error)) [[unlikely]]
  387|       |            return;
  388|       |
  389|       |         if (index >= N) [[unlikely]] {
  390|       |            if constexpr (Opts.error_on_unknown_keys) {
  391|       |               ctx.error = error_code::unknown_key;
  392|       |               return;
  393|       |            }
  394|       |            else {
  395|       |               // it sits one past the closing quote, so the raw key spans [key_start, it - 1)
  396|       |               if (validate_utf8_span<Opts>(ctx, key_start, it - 1)) [[unlikely]] {
  397|       |                  return;
  398|       |               }
  399|       |               const sv key{key_start, size_t(it - key_start - 1)};
  400|       |               if constexpr (not Opts.null_terminated) {
  401|       |                  if (it == end) [[unlikely]] {
  402|       |                     ctx.error = error_code::unexpected_end;
  403|       |                     return;
  404|       |                  }
  405|       |               }
  406|       |               if (parse_ws_colon<Opts>(ctx, it, end)) {
  407|       |                  return;
  408|       |               }
  409|       |               parse<JSON>::handle_unknown<Opts>(key, value, ctx, it, end);
  410|       |               return;
  411|       |            }
  412|       |         }
  413|       |
  414|       |         if constexpr (not Opts.null_terminated) {
  415|       |            if (it == end) [[unlikely]] {
  416|       |               ctx.error = error_code::unexpected_end;
  417|       |               return;
  418|       |            }
  419|       |         }
  420|       |         if (skip_ws<Opts>(ctx, it, end)) {
  421|       |            return;
  422|       |         }
  423|       |         if (match_invalid_end<':', Opts>(ctx, it, end)) {
  424|       |            return;
  425|       |         }
  426|       |         if (skip_ws<Opts>(ctx, it, end)) {
  427|       |            return;
  428|       |         }
  429|       |
  430|       |         // Fold expression dispatch - avoids jump table overhead for smaller binary size.
  431|       |         // For linear_search, pass Opts through to the field parser to avoid duplicate template
  432|       |         // instantiations; the whitespace before the value has already been skipped either way.
  433|       |         [&]<size_t... Is>(std::index_sequence<Is...>) {
  434|       |            (void)(((index == Is ? (decode_field_value<Opts, Opts, T, Is>(value, ctx, it, end, selected_index...), true)
  435|       |                                 : false) ||
  436|       |                    ...));
  437|       |         }(std::make_index_sequence<N>{});
  438|       |      }
  439|  7.36k|      else {
  440|       |         // Hash-based lookup
  441|  7.36k|         constexpr auto& HashInfo = hash_info<T>;
  442|  7.36k|         constexpr auto type = HashInfo.type;
  443|  7.36k|         static_assert(bool(type), "invalid hash algorithm");
  444|       |
  445|  7.36k|         const auto index = decode_hash<JSON, T, HashInfo, HashInfo.type>::op(it, end);
  446|       |
  447|  7.36k|         if (index >= N) [[unlikely]] {
  ------------------
  |  Branch (447:14): [True: 0, False: 7.36k]
  ------------------
  448|      0|            if constexpr (Opts.error_on_unknown_keys) {
  449|      0|               ctx.error = error_code::unknown_key;
  450|      0|               return;
  451|       |            }
  452|       |            else {
  453|       |               auto start = it;
  454|       |               skip_string_view(ctx, it, end);
  455|       |               if (bool(ctx.error)) [[unlikely]]
  456|       |                  return;
  457|       |               if (validate_utf8_span<Opts>(ctx, start, it)) [[unlikely]]
  458|       |                  return;
  459|       |               const sv key = {start, size_t(it - start)};
  460|       |               ++it; // skip the quote
  461|       |               if constexpr (not Opts.null_terminated) {
  462|       |                  if (it == end) [[unlikely]] {
  463|       |                     ctx.error = error_code::unexpected_end;
  464|       |                     return;
  465|       |                  }
  466|       |               }
  467|       |               if (parse_ws_colon<Opts>(ctx, it, end)) {
  468|       |                  return;
  469|       |               }
  470|       |               parse<JSON>::handle_unknown<Opts>(key, value, ctx, it, end);
  471|       |               return;
  472|       |            }
  473|      0|         }
  474|       |
  475|  7.36k|         if constexpr (N == 2) {
  476|  7.36k|            if (index == 0) {
  ------------------
  |  Branch (476:17): [True: 5.72k, False: 1.64k]
  ------------------
  477|  5.72k|               decode_index<Opts, T, 0>(value, ctx, it, end, selected_index...);
  478|  5.72k|            }
  479|  1.64k|            else {
  480|  1.64k|               decode_index<Opts, T, 1>(value, ctx, it, end, selected_index...);
  481|  1.64k|            }
  482|       |         }
  483|       |         else {
  484|       |            visit<N>([&]<size_t I>() { decode_index<Opts, T, I>(value, ctx, it, end, selected_index...); }, index);
  485|       |         }
  486|  7.36k|      }
  487|  7.36k|   }
_ZN3glz12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz5pointELm0ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT2_OT4_OT5_OT6_DpOT3_:
  311|  5.72k|   {
  312|  5.72k|      static constexpr auto Key = get<I>(reflect<T>::keys);
  313|  5.72k|      static constexpr auto KeyWithEndQuote = join_v<Key, chars<"\"">>;
  314|  5.72k|      static constexpr auto Length = KeyWithEndQuote.size();
  315|       |
  316|  5.72k|      if (((it + Length) < end) && comparitor<KeyWithEndQuote>(it)) [[likely]] {
  ------------------
  |  Branch (316:11): [True: 5.72k, False: 0]
  |  Branch (316:36): [True: 5.70k, False: 13]
  ------------------
  317|  5.70k|         it += Length;
  318|  5.70k|         if constexpr (not Opts.null_terminated) {
  319|  5.70k|            if (it == end) [[unlikely]] {
  ------------------
  |  Branch (319:17): [True: 0, False: 5.70k]
  ------------------
  320|      0|               ctx.error = error_code::unexpected_end;
  321|      0|               return;
  322|      0|            }
  323|  5.70k|         }
  324|       |
  325|  5.70k|         if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (325:14): [True: 0, False: 5.70k]
  ------------------
  326|      0|            return;
  327|      0|         }
  328|  5.70k|         if (match_invalid_end<':', Opts>(ctx, it, end)) {
  ------------------
  |  Branch (328:14): [True: 47, False: 5.66k]
  ------------------
  329|     47|            return;
  330|     47|         }
  331|  5.66k|         if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (331:14): [True: 0, False: 5.66k]
  ------------------
  332|      0|            return;
  333|      0|         }
  334|       |
  335|       |         // The hash path has already consumed the whitespace before the value
  336|  5.66k|         decode_field_value<Opts, ws_handled<Opts>(), T, I>(value, ctx, it, end, selected_index...);
  337|  5.66k|      }
  338|     13|      else [[unlikely]] {
  339|     13|         decode_index_unknown_key<Opts, T>(value, ctx, it, end);
  340|     13|      }
  341|  5.72k|   }
_ZN3glz18decode_field_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnDaXtlS1_Lj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEEN12jsonrpc_fuzz5pointELm0ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT1_E11reflectableISA_EEEvOT3_OT5_OT6_OT7_DpOT4_:
  245|  5.66k|   {
  246|       |      // Check for null value skipping on read
  247|       |      if constexpr (check_skip_null_members_on_read(Opts)) {
  248|       |         if (*it == 'n') {
  249|       |            ++it;
  250|       |            if constexpr (not Opts.null_terminated) {
  251|       |               if (it == end) [[unlikely]] {
  252|       |                  ctx.error = error_code::unexpected_end;
  253|       |                  return;
  254|       |               }
  255|       |            }
  256|       |            match<"ull", Opts>(ctx, it, end);
  257|       |            if (bool(ctx.error)) [[unlikely]]
  258|       |               return;
  259|       |            // Successfully matched "null", skip it
  260|       |            if constexpr (Opts.error_on_missing_keys || Opts.partial_read) {
  261|       |               ((selected_index = I), ...); // Mark as handled even if skipped
  262|       |            }
  263|       |            return;
  264|       |         }
  265|       |      }
  266|       |
  267|       |      if constexpr (skipped_by_meta<T, I, operation::parse>) {
  268|       |         skip_value<JSON>::op<Opts>(ctx, it, end);
  269|       |         if (bool(ctx.error)) [[unlikely]]
  270|       |            return; // Propagate error from skip_value
  271|       |      }
  272|  5.66k|      else {
  273|  5.66k|         using V = refl_t<T, I>;
  274|       |
  275|       |         if constexpr (const_value_v<V>) {
  276|       |            if constexpr (check_error_on_const_read(Opts)) {
  277|       |               ctx.error = error_code::attempt_const_read;
  278|       |            }
  279|       |            else {
  280|       |               // do not read anything into the const value
  281|       |               skip_value<JSON>::op<Opts>(ctx, it, end);
  282|       |            }
  283|       |         }
  284|       |         else if constexpr (is_function_ptr_or_ref<V>) {
  285|       |            // Function pointers cannot be deserialized from JSON.
  286|       |            // When write_function_pointers is enabled the writer emits a type-name string,
  287|       |            // but there is nothing meaningful to reconstruct on read — just skip the value.
  288|       |            // When write_function_pointers is off the key is never written, so this branch
  289|       |            // is unreachable in that case.
  290|       |            skip_value<JSON>::op<Opts>(ctx, it, end);
  291|       |         }
  292|       |         else if constexpr (glaze_object_t<T>) {
  293|       |            from<JSON, std::remove_cvref_t<V>>::template op<FieldOpts>(get_member(value, get<I>(reflect<T>::values)),
  294|       |                                                                       ctx, it, end);
  295|       |         }
  296|  5.66k|         else {
  297|  5.66k|            from<JSON, std::remove_cvref_t<V>>::template op<FieldOpts>(get_member(value, get<I>(to_tie(value))), ctx,
  298|  5.66k|                                                                       it, end);
  299|  5.66k|         }
  300|  5.66k|      }
  301|       |
  302|       |      // The key was present and handled, even when the value itself was skipped
  303|       |      if constexpr (Opts.error_on_missing_keys || Opts.partial_read) {
  304|       |         ((selected_index = I), ...);
  305|       |      }
  306|  5.66k|   }
_ZN3glz4fromILj10EdE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEERPKcRdTkNS_10is_contextERNS_7contextES5_EEvOT1_OT2_OT0_T3_:
  767|   909k|      {
  768|       |         if constexpr (check_quoted_num(Opts)) {
  769|       |            if (skip_ws<Opts>(ctx, it, end)) {
  770|       |               return;
  771|       |            }
  772|       |            if (match_invalid_end<'"', Opts>(ctx, it, end)) {
  773|       |               return;
  774|       |            }
  775|       |         }
  776|       |
  777|       |         if constexpr (!check_ws_handled(Opts)) {
  778|       |            if (skip_ws<Opts>(ctx, it, end)) {
  779|       |               return;
  780|       |            }
  781|       |         }
  782|       |
  783|   909k|         using V = std::decay_t<decltype(value)>;
  784|       |         if constexpr (int_t<V>) {
  785|       |            static_assert(sizeof(*it) == sizeof(char));
  786|       |
  787|       |            if constexpr (Opts.null_terminated) {
  788|       |               if (not glz::atoi(value, it)) [[unlikely]] {
  789|       |                  ctx.error = error_code::parse_number_failure;
  790|       |                  return;
  791|       |               }
  792|       |            }
  793|       |            else {
  794|       |               if (not glz::atoi(value, it, end)) [[unlikely]] {
  795|       |                  ctx.error = error_code::parse_number_failure;
  796|       |                  return;
  797|       |               }
  798|       |            }
  799|       |         }
  800|   909k|         else {
  801|       |// float128_t requires std::from_chars for floating-point, unavailable on older Apple platforms (iOS < 16.3)
  802|   909k|#if !defined(_LIBCPP_VERSION) || defined(_LIBCPP_AVAILABILITY_HAS_TO_CHARS_FLOATING_POINT)
  803|       |            if constexpr (is_float128<V>) {
  804|       |               auto [ptr, ec] = std::from_chars(it, end, value);
  805|       |               if (ec != std::errc()) {
  806|       |                  ctx.error = error_code::parse_number_failure;
  807|       |                  return;
  808|       |               }
  809|       |               it = ptr;
  810|       |            }
  811|       |            else
  812|       |#endif
  813|   909k|            {
  814|       |               if constexpr (std::is_volatile_v<std::remove_reference_t<decltype(value)>>) {
  815|       |                  // Hardware may interact with value changes, so we parse into a temporary and assign in one
  816|       |                  // place
  817|       |                  V temp;
  818|       |                  if constexpr (is_size_optimized(Opts)) {
  819|       |                     auto [ptr, ec] = simple_float::from_chars<Opts.null_terminated>(it, end, temp);
  820|       |                     if (ec != std::errc{}) [[unlikely]] {
  821|       |                        ctx.error = error_code::parse_number_failure;
  822|       |                        return;
  823|       |                     }
  824|       |                     it = ptr;
  825|       |                  }
  826|       |                  else {
  827|       |                     auto [ptr, ec] = glz::from_chars<Opts.null_terminated>(it, end, temp);
  828|       |                     if (ec != std::errc()) [[unlikely]] {
  829|       |                        ctx.error = error_code::parse_number_failure;
  830|       |                        return;
  831|       |                     }
  832|       |                     it = ptr;
  833|       |                  }
  834|       |                  value = temp;
  835|       |               }
  836|   909k|               else {
  837|       |                  if constexpr (is_size_optimized(Opts)) {
  838|       |                     auto [ptr, ec] = simple_float::from_chars<Opts.null_terminated>(it, end, value);
  839|       |                     if (ec != std::errc{}) [[unlikely]] {
  840|       |                        ctx.error = error_code::parse_number_failure;
  841|       |                        return;
  842|       |                     }
  843|       |                     it = ptr;
  844|       |                  }
  845|   909k|                  else {
  846|   909k|                     auto [ptr, ec] = glz::from_chars<Opts.null_terminated>(it, end, value);
  847|   909k|                     if (ec != std::errc()) [[unlikely]] {
  ------------------
  |  Branch (847:26): [True: 1.15k, False: 908k]
  ------------------
  848|  1.15k|                        ctx.error = error_code::parse_number_failure;
  849|  1.15k|                        return;
  850|  1.15k|                     }
  851|   908k|                     it = ptr;
  852|   908k|                  }
  853|   909k|               }
  854|   909k|            }
  855|   909k|         }
  856|       |
  857|       |         if constexpr (check_quoted_num(Opts)) {
  858|       |            if constexpr (not Opts.null_terminated) {
  859|       |               if (it == end) [[unlikely]] {
  860|       |                  ctx.error = error_code::unexpected_end;
  861|       |                  return;
  862|       |               }
  863|       |            }
  864|       |            if (match<'"'>(ctx, it)) {
  865|       |               return;
  866|       |            }
  867|       |            if constexpr (not Opts.null_terminated) {
  868|       |               if (it == end) {
  869|       |                  ctx.error = error_code::end_reached;
  870|       |                  return;
  871|       |               }
  872|       |            }
  873|       |         }
  874|   909k|         else {
  875|   909k|            if constexpr (not Opts.null_terminated) {
  876|   909k|               if (it == end) {
  ------------------
  |  Branch (876:20): [True: 0, False: 909k]
  ------------------
  877|      0|                  ctx.error = error_code::end_reached;
  878|      0|                  return;
  879|      0|               }
  880|   909k|            }
  881|   909k|         }
  882|   909k|      }
_ZN3glz24decode_index_unknown_keyITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz5pointERS3_TkNS_10is_contextERNS_7contextERPKcS8_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT2_OT3_T4_:
  177|    119|   {
  178|    119|      if constexpr (Opts.error_on_unknown_keys) {
  179|    119|         ctx.error = error_code::unknown_key;
  180|       |      }
  181|       |      else {
  182|       |         auto* start = it;
  183|       |         skip_string_view(ctx, it, end);
  184|       |         if (bool(ctx.error)) [[unlikely]]
  185|       |            return;
  186|       |         if (validate_utf8_span<Opts>(ctx, start, it)) [[unlikely]]
  187|       |            return;
  188|       |         const sv key = {start, size_t(it - start)};
  189|       |         ++it;
  190|       |         if constexpr (not Opts.null_terminated) {
  191|       |            if (it == end) [[unlikely]] {
  192|       |               ctx.error = error_code::unexpected_end;
  193|       |               return;
  194|       |            }
  195|       |         }
  196|       |
  197|       |         if (parse_ws_colon<Opts>(ctx, it, end)) {
  198|       |            return;
  199|       |         }
  200|       |
  201|       |         parse<JSON>::handle_unknown<Opts>(key, value, ctx, it, end);
  202|       |      }
  203|    119|   }
_ZN3glz12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz5pointELm1ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT2_OT4_OT5_OT6_DpOT3_:
  311|  1.64k|   {
  312|  1.64k|      static constexpr auto Key = get<I>(reflect<T>::keys);
  313|  1.64k|      static constexpr auto KeyWithEndQuote = join_v<Key, chars<"\"">>;
  314|  1.64k|      static constexpr auto Length = KeyWithEndQuote.size();
  315|       |
  316|  1.64k|      if (((it + Length) < end) && comparitor<KeyWithEndQuote>(it)) [[likely]] {
  ------------------
  |  Branch (316:11): [True: 1.63k, False: 6]
  |  Branch (316:36): [True: 1.53k, False: 100]
  ------------------
  317|  1.53k|         it += Length;
  318|  1.53k|         if constexpr (not Opts.null_terminated) {
  319|  1.53k|            if (it == end) [[unlikely]] {
  ------------------
  |  Branch (319:17): [True: 0, False: 1.53k]
  ------------------
  320|      0|               ctx.error = error_code::unexpected_end;
  321|      0|               return;
  322|      0|            }
  323|  1.53k|         }
  324|       |
  325|  1.53k|         if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (325:14): [True: 0, False: 1.53k]
  ------------------
  326|      0|            return;
  327|      0|         }
  328|  1.53k|         if (match_invalid_end<':', Opts>(ctx, it, end)) {
  ------------------
  |  Branch (328:14): [True: 40, False: 1.49k]
  ------------------
  329|     40|            return;
  330|     40|         }
  331|  1.49k|         if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (331:14): [True: 0, False: 1.49k]
  ------------------
  332|      0|            return;
  333|      0|         }
  334|       |
  335|       |         // The hash path has already consumed the whitespace before the value
  336|  1.49k|         decode_field_value<Opts, ws_handled<Opts>(), T, I>(value, ctx, it, end, selected_index...);
  337|  1.49k|      }
  338|    106|      else [[unlikely]] {
  339|    106|         decode_index_unknown_key<Opts, T>(value, ctx, it, end);
  340|    106|      }
  341|  1.64k|   }
_ZN3glz18decode_field_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnDaXtlS1_Lj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEEN12jsonrpc_fuzz5pointELm1ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT1_E11reflectableISA_EEEvOT3_OT5_OT6_OT7_DpOT4_:
  245|  1.49k|   {
  246|       |      // Check for null value skipping on read
  247|       |      if constexpr (check_skip_null_members_on_read(Opts)) {
  248|       |         if (*it == 'n') {
  249|       |            ++it;
  250|       |            if constexpr (not Opts.null_terminated) {
  251|       |               if (it == end) [[unlikely]] {
  252|       |                  ctx.error = error_code::unexpected_end;
  253|       |                  return;
  254|       |               }
  255|       |            }
  256|       |            match<"ull", Opts>(ctx, it, end);
  257|       |            if (bool(ctx.error)) [[unlikely]]
  258|       |               return;
  259|       |            // Successfully matched "null", skip it
  260|       |            if constexpr (Opts.error_on_missing_keys || Opts.partial_read) {
  261|       |               ((selected_index = I), ...); // Mark as handled even if skipped
  262|       |            }
  263|       |            return;
  264|       |         }
  265|       |      }
  266|       |
  267|       |      if constexpr (skipped_by_meta<T, I, operation::parse>) {
  268|       |         skip_value<JSON>::op<Opts>(ctx, it, end);
  269|       |         if (bool(ctx.error)) [[unlikely]]
  270|       |            return; // Propagate error from skip_value
  271|       |      }
  272|  1.49k|      else {
  273|  1.49k|         using V = refl_t<T, I>;
  274|       |
  275|       |         if constexpr (const_value_v<V>) {
  276|       |            if constexpr (check_error_on_const_read(Opts)) {
  277|       |               ctx.error = error_code::attempt_const_read;
  278|       |            }
  279|       |            else {
  280|       |               // do not read anything into the const value
  281|       |               skip_value<JSON>::op<Opts>(ctx, it, end);
  282|       |            }
  283|       |         }
  284|       |         else if constexpr (is_function_ptr_or_ref<V>) {
  285|       |            // Function pointers cannot be deserialized from JSON.
  286|       |            // When write_function_pointers is enabled the writer emits a type-name string,
  287|       |            // but there is nothing meaningful to reconstruct on read — just skip the value.
  288|       |            // When write_function_pointers is off the key is never written, so this branch
  289|       |            // is unreachable in that case.
  290|       |            skip_value<JSON>::op<Opts>(ctx, it, end);
  291|       |         }
  292|       |         else if constexpr (glaze_object_t<T>) {
  293|       |            from<JSON, std::remove_cvref_t<V>>::template op<FieldOpts>(get_member(value, get<I>(reflect<T>::values)),
  294|       |                                                                       ctx, it, end);
  295|       |         }
  296|  1.49k|         else {
  297|  1.49k|            from<JSON, std::remove_cvref_t<V>>::template op<FieldOpts>(get_member(value, get<I>(to_tie(value))), ctx,
  298|  1.49k|                                                                       it, end);
  299|  1.49k|         }
  300|  1.49k|      }
  301|       |
  302|       |      // The key was present and handled, even when the value itself was skipped
  303|       |      if constexpr (Opts.error_on_missing_keys || Opts.partial_read) {
  304|       |         ((selected_index = I), ...);
  305|       |      }
  306|  1.49k|   }
_ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERN12jsonrpc_fuzz8fuzz_apiETkNS_10is_contextERNS_7contextERPKcSA_EEvOT0_OT1_OT2_T3_:
   49|  5.21k|      {
   50|       |         if constexpr (const_value_v<T>) {
   51|       |            if constexpr (check_error_on_const_read(Opts)) {
   52|       |               ctx.error = error_code::attempt_const_read;
   53|       |            }
   54|       |            else {
   55|       |               // do not read anything into the const value
   56|       |               skip_value<JSON>::op<Opts>(std::forward<Ctx>(ctx), std::forward<It0>(it), end);
   57|       |            }
   58|       |         }
   59|  5.21k|         else {
   60|  5.21k|            using V = std::remove_cvref_t<T>;
   61|  5.21k|            from<JSON, V>::template op<Opts>(std::forward<T>(value), std::forward<Ctx>(ctx), std::forward<It0>(it),
   62|  5.21k|                                             end);
   63|  5.21k|         }
   64|  5.21k|      }
_ZN3glz4fromILj10EN12jsonrpc_fuzz8fuzz_apiEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnNS_14string_literalEXtlNS6_ILm1EEEEERS2_TkNS_10is_contextERNS_7contextERPKcSC_EEvOT1_OT2_OT3_T4_:
 3044|  5.21k|      {
 3045|  5.21k|         static constexpr auto num_members = reflect<T>::size;
 3046|       |
 3047|  5.21k|         static constexpr auto Opts = opening_handled_off<ws_handled_off<Options>()>();
 3048|  5.21k|         if constexpr (!check_opening_handled(Options)) {
 3049|  5.21k|            if constexpr (!check_ws_handled(Options)) {
 3050|  5.21k|               if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (3050:20): [True: 0, False: 5.21k]
  ------------------
 3051|      0|                  return;
 3052|      0|               }
 3053|  5.21k|            }
 3054|  5.21k|            if (match_invalid_end<'{', Opts>(ctx, it, end)) {
  ------------------
  |  Branch (3054:17): [True: 58, False: 5.15k]
  ------------------
 3055|     58|               return;
 3056|     58|            }
 3057|  5.15k|            if constexpr (not Opts.null_terminated) {
 3058|  5.15k|               if (it == end) [[unlikely]] {
  ------------------
  |  Branch (3058:20): [True: 0, False: 5.15k]
  ------------------
 3059|      0|                  ctx.error = error_code::unexpected_end;
 3060|      0|                  return;
 3061|      0|               }
 3062|  5.15k|            }
 3063|       |            // one nesting level (see enter_depth): counted in both modes so the limit binds,
 3064|       |            // released at each syntactic close below
 3065|  5.15k|            if (enter_depth(ctx)) [[unlikely]] {
  ------------------
  |  Branch (3065:17): [True: 0, False: 5.15k]
  ------------------
 3066|      0|               return;
 3067|      0|            }
 3068|  5.15k|         }
 3069|  5.15k|         const auto ws_start = it;
 3070|  5.21k|         if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (3070:14): [True: 0, False: 5.21k]
  ------------------
 3071|      0|            return;
 3072|      0|         }
 3073|  5.21k|         const size_t ws_size = size_t(it - ws_start);
 3074|       |
 3075|       |         if constexpr ((glaze_object_t<T> || reflectable<T>) && num_members == 0 && Opts.error_on_unknown_keys) {
 3076|       |            if constexpr (not tag.sv().empty()) {
 3077|       |               if (*it == '"') {
 3078|       |                  ++it;
 3079|       |                  if constexpr (not Opts.null_terminated) {
 3080|       |                     if (it == end) [[unlikely]] {
 3081|       |                        ctx.error = error_code::unexpected_end;
 3082|       |                        return;
 3083|       |                     }
 3084|       |                  }
 3085|       |
 3086|       |                  const auto start = it;
 3087|       |                  skip_string_view(ctx, it, end);
 3088|       |                  if (bool(ctx.error)) [[unlikely]]
 3089|       |                     return;
 3090|       |                  if (validate_utf8_span<Opts>(ctx, start, it)) [[unlikely]]
 3091|       |                     return;
 3092|       |                  const sv key{start, size_t(it - start)};
 3093|       |                  ++it;
 3094|       |                  if constexpr (not Opts.null_terminated) {
 3095|       |                     if (it == end) [[unlikely]] {
 3096|       |                        ctx.error = error_code::unexpected_end;
 3097|       |                        return;
 3098|       |                     }
 3099|       |                  }
 3100|       |
 3101|       |                  if (key == tag.sv()) {
 3102|       |                     if (parse_ws_colon<Opts>(ctx, it, end)) {
 3103|       |                        return;
 3104|       |                     }
 3105|       |
 3106|       |                     parse<JSON>::handle_unknown<Opts>(key, value, ctx, it, end);
 3107|       |                     if (bool(ctx.error)) [[unlikely]]
 3108|       |                        return;
 3109|       |
 3110|       |                     if (skip_ws<Opts>(ctx, it, end)) {
 3111|       |                        return;
 3112|       |                     }
 3113|       |                  }
 3114|       |                  else {
 3115|       |                     ctx.error = error_code::unknown_key;
 3116|       |                     return;
 3117|       |                  }
 3118|       |               }
 3119|       |            }
 3120|       |
 3121|       |            if (*it == '}') [[likely]] {
 3122|       |               --ctx.depth;
 3123|       |               if constexpr (glaze_object_t<T> || reflectable<T>) {
 3124|       |                  if constexpr (has_self_constraint_v<T> && !check_skip_self_constraint(Opts)) {
 3125|       |                     auto wrapper = self_constraint_v<T>(value);
 3126|       |                     from<JSON, decltype(wrapper)>::template op<ws_handled<Opts>()>(wrapper, ctx, it, end);
 3127|       |                     if (bool(ctx.error)) {
 3128|       |                        return;
 3129|       |                     }
 3130|       |                  }
 3131|       |               }
 3132|       |               ++it;
 3133|       |               if constexpr (not Opts.null_terminated) {
 3134|       |                  if (it == end) {
 3135|       |                     ctx.error = error_code::end_reached;
 3136|       |                     return;
 3137|       |                  }
 3138|       |               }
 3139|       |               if constexpr (Opts.partial_read) {
 3140|       |                  ctx.error = error_code::partial_read_complete;
 3141|       |               }
 3142|       |               return;
 3143|       |            }
 3144|       |            ctx.error = error_code::unknown_key;
 3145|       |            return;
 3146|       |         }
 3147|  5.21k|         else {
 3148|  5.21k|            decltype(auto) fields = [&]() -> decltype(auto) {
 3149|  5.21k|               if constexpr ((glaze_object_t<T> || reflectable<T>) &&
 3150|  5.21k|                             (Opts.error_on_missing_keys || Opts.partial_read)) {
 3151|  5.21k|                  return bit_array<num_members>{};
 3152|  5.21k|               }
 3153|  5.21k|               else {
 3154|  5.21k|                  return nullptr;
 3155|  5.21k|               }
 3156|  5.21k|            }();
 3157|       |
 3158|  5.21k|            size_t read_count{}; // for partial_read
 3159|       |
 3160|  5.21k|            bool first = true;
 3161|  34.5k|            while (true) {
  ------------------
  |  Branch (3161:20): [True: 30.2k, Folded]
  ------------------
 3162|       |               if constexpr ((glaze_object_t<T> || reflectable<T>) && Opts.partial_read) {
 3163|       |                  static constexpr bit_array<num_members> all_fields = [] {
 3164|       |                     bit_array<num_members> arr{};
 3165|       |                     for (size_t i = 0; i < num_members; ++i) {
 3166|       |                        arr[i] = true;
 3167|       |                     }
 3168|       |                     return arr;
 3169|       |                  }();
 3170|       |
 3171|       |                  if ((all_fields & fields) == all_fields) {
 3172|       |                     ctx.error = error_code::partial_read_complete;
 3173|       |                     --ctx.depth; // as above: an early success still closes this level
 3174|       |                     return;
 3175|       |                  }
 3176|       |               }
 3177|       |
 3178|       |               // Streaming refill point: at start of each iteration, ensure buffer has data
 3179|       |               if constexpr (has_streaming_state<decltype(ctx)>) {
 3180|       |                  if (ctx.stream.enabled()) {
 3181|       |                     const size_t consumed = static_cast<size_t>(it - ctx.stream.data());
 3182|       |                     const size_t remaining = ctx.stream.size() - consumed;
 3183|       |                     // Refill when less than half of buffer remains to ensure space for next key-value pair
 3184|       |                     if (remaining <= ctx.stream.size() / 2 || it >= end) {
 3185|       |                        const char* new_it;
 3186|       |                        const char* new_end;
 3187|       |                        ctx.stream.consume_and_refill(consumed, new_it, new_end);
 3188|       |                        it = new_it;
 3189|       |                        end = new_end;
 3190|       |                        if (it >= end && ctx.stream.at_eof()) {
 3191|       |                           ctx.error = error_code::unexpected_end;
 3192|       |                           return;
 3193|       |                        }
 3194|       |                     }
 3195|       |                  }
 3196|       |               }
 3197|       |
 3198|  30.2k|               if (*it == '}') {
  ------------------
  |  Branch (3198:20): [True: 640, False: 29.6k]
  ------------------
 3199|    640|                  --ctx.depth;
 3200|       |                  if constexpr ((glaze_object_t<T> || reflectable<T>) && Opts.error_on_missing_keys) {
 3201|       |                     constexpr auto req_fields = required_fields<T, Opts>();
 3202|       |                     if ((req_fields & fields) != req_fields) {
 3203|       |                        for (size_t i = 0; i < num_members; ++i) {
 3204|       |                           if (not fields[i] && req_fields[i]) {
 3205|       |                              ctx.custom_error_message = reflect<T>::keys[i];
 3206|       |                              // We just return the first missing key in order to avoid heap allocations
 3207|       |                              break;
 3208|       |                           }
 3209|       |                        }
 3210|       |
 3211|       |                        ctx.error = error_code::missing_key;
 3212|       |                        return;
 3213|       |                     }
 3214|       |                  }
 3215|    640|                  if constexpr (glaze_object_t<T> || reflectable<T>) {
 3216|       |                     if constexpr (has_self_constraint_v<T> && !check_skip_self_constraint(Opts)) {
 3217|       |                        auto wrapper = self_constraint_v<T>(value);
 3218|       |                        from<JSON, decltype(wrapper)>::template op<ws_handled<Opts>()>(wrapper, ctx, it, end);
 3219|       |                        if (bool(ctx.error)) {
 3220|       |                           return;
 3221|       |                        }
 3222|       |                     }
 3223|    640|                  }
 3224|    640|                  ++it; // Increment after checking for missing keys so errors are within buffer bounds
 3225|    640|                  if constexpr (not Opts.null_terminated) {
 3226|    640|                     if (it == end) {
  ------------------
  |  Branch (3226:26): [True: 640, False: 0]
  ------------------
 3227|    640|                        ctx.error = error_code::end_reached;
 3228|    640|                        return;
 3229|    640|                     }
 3230|    640|                  }
 3231|      0|                  return;
 3232|    640|               }
 3233|  29.6k|               else if (first) {
  ------------------
  |  Branch (3233:25): [True: 5.13k, False: 24.4k]
  ------------------
 3234|  5.13k|                  first = false;
 3235|  5.13k|               }
 3236|  24.4k|               else {
 3237|  24.4k|                  if (match_invalid_end<',', Opts>(ctx, it, end)) {
  ------------------
  |  Branch (3237:23): [True: 333, False: 24.1k]
  ------------------
 3238|    333|                     return;
 3239|    333|                  }
 3240|  24.1k|                  if constexpr (not Opts.null_terminated) {
 3241|  24.1k|                     if (it == end) [[unlikely]] {
  ------------------
  |  Branch (3241:26): [True: 0, False: 24.1k]
  ------------------
 3242|      0|                        ctx.error = error_code::unexpected_end;
 3243|      0|                        return;
 3244|      0|                     }
 3245|  24.1k|                  }
 3246|       |
 3247|       |                  if constexpr ((not Opts.minified) && (num_members > 1 || not Opts.error_on_unknown_keys) &&
 3248|  24.1k|                                (!Opts.comments)) {
 3249|  24.1k|                     if (ws_size && ws_size < size_t(end - it)) {
  ------------------
  |  Branch (3249:26): [True: 10.1k, False: 14.0k]
  |  Branch (3249:37): [True: 9.82k, False: 278]
  ------------------
 3250|  9.82k|                        skip_matching_ws(ws_start, it, ws_size);
 3251|  9.82k|                     }
 3252|  24.1k|                  }
 3253|       |
 3254|  24.1k|                  if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (3254:23): [True: 0, False: 24.1k]
  ------------------
 3255|      0|                     return;
 3256|      0|                  }
 3257|  24.1k|               }
 3258|       |
 3259|  29.2k|               constexpr auto reflection_type = glaze_object_t<T> || reflectable<T>;
  ------------------
  |  Branch (3259:49): [Folded, False: 0]
  |  Branch (3259:70): [True: 0, Folded]
  ------------------
 3260|       |
 3261|       |               if constexpr (reflection_type && (num_members == 0)) {
 3262|       |                  if constexpr (Opts.error_on_unknown_keys) {
 3263|       |                     static_assert(false_v<T>, "This should be unreachable");
 3264|       |                  }
 3265|       |                  else {
 3266|       |                     if (match_invalid_end<'"', Opts>(ctx, it, end)) {
 3267|       |                        return;
 3268|       |                     }
 3269|       |
 3270|       |                     // parsing to an empty object, but at this point the JSON presents keys
 3271|       |
 3272|       |                     // Unknown key handler does not unescape keys. Unknown escaped keys are
 3273|       |                     // handled by the user.
 3274|       |
 3275|       |                     const auto start = it;
 3276|       |                     skip_string_view(ctx, it, end);
 3277|       |                     if (bool(ctx.error)) [[unlikely]]
 3278|       |                        return;
 3279|       |                     if (validate_utf8_span<Opts>(ctx, start, it)) [[unlikely]]
 3280|       |                        return;
 3281|       |                     const sv key{start, size_t(it - start)};
 3282|       |                     ++it;
 3283|       |                     if constexpr (not Opts.null_terminated) {
 3284|       |                        if (it == end) [[unlikely]] {
 3285|       |                           ctx.error = error_code::unexpected_end;
 3286|       |                           return;
 3287|       |                        }
 3288|       |                     }
 3289|       |
 3290|       |                     if (parse_ws_colon<Opts>(ctx, it, end)) {
 3291|       |                        return;
 3292|       |                     }
 3293|       |
 3294|       |                     // Check if this key is the variant tag that should be skipped
 3295|       |                     if constexpr (not tag.sv().empty()) {
 3296|       |                        if (key == tag.sv()) {
 3297|       |                           // Skip the tag value
 3298|       |                           skip_value<JSON>::op<Opts>(ctx, it, end);
 3299|       |                           if (bool(ctx.error)) [[unlikely]]
 3300|       |                              return;
 3301|       |                           resync_window_end(ctx, end); // a streaming skip refills
 3302|       |                           if (skip_ws<Opts>(ctx, it, end)) {
 3303|       |                              return;
 3304|       |                           }
 3305|       |                           continue;
 3306|       |                        }
 3307|       |                     }
 3308|       |
 3309|       |                     parse<JSON>::handle_unknown<Opts>(key, value, ctx, it, end);
 3310|       |                     if (bool(ctx.error)) [[unlikely]]
 3311|       |                        return;
 3312|       |                     if constexpr (not Opts.null_terminated) {
 3313|       |                        if (it == end) [[unlikely]] {
 3314|       |                           ctx.error = error_code::unexpected_end;
 3315|       |                           return;
 3316|       |                        }
 3317|       |                     }
 3318|       |                     if (skip_ws<Opts>(ctx, it, end)) {
 3319|       |                        return;
 3320|       |                     }
 3321|       |                  }
 3322|       |               }
 3323|  29.2k|               else if constexpr (reflection_type) {
 3324|  29.2k|                  static_assert(bool(hash_info<T>.type));
 3325|       |
 3326|  29.2k|                  if (*it != '"') [[unlikely]] {
  ------------------
  |  Branch (3326:23): [True: 767, False: 28.5k]
  ------------------
 3327|    767|                     ctx.error = error_code::expected_quote;
 3328|    767|                     return;
 3329|    767|                  }
 3330|  28.5k|                  ++it;
 3331|  28.5k|                  if constexpr (not Opts.null_terminated) {
 3332|  28.5k|                     if (it == end) [[unlikely]] {
  ------------------
  |  Branch (3332:26): [True: 0, False: 28.5k]
  ------------------
 3333|      0|                        ctx.error = error_code::unexpected_end;
 3334|      0|                        return;
 3335|      0|                     }
 3336|  28.5k|                  }
 3337|       |
 3338|       |                  if constexpr (not tag.sv().empty() && not contains_tag<T, tag>()) {
 3339|       |                     // For tagged variants we first check to see if the key matches the tag
 3340|       |                     // We only need to do this if the tag is not part of the keys
 3341|       |
 3342|       |                     const auto start = it;
 3343|       |                     skip_string_view(ctx, it, end);
 3344|       |                     if (bool(ctx.error)) [[unlikely]]
 3345|       |                        return;
 3346|       |                     if (validate_utf8_span<Opts>(ctx, start, it)) [[unlikely]]
 3347|       |                        return;
 3348|       |                     const sv key{start, size_t(it - start)};
 3349|       |                     ++it;
 3350|       |                     if constexpr (not Opts.null_terminated) {
 3351|       |                        if (it == end) [[unlikely]] {
 3352|       |                           ctx.error = error_code::unexpected_end;
 3353|       |                           return;
 3354|       |                        }
 3355|       |                     }
 3356|       |
 3357|       |                     if (key == tag.sv()) {
 3358|       |                        if (parse_ws_colon<Opts>(ctx, it, end)) {
 3359|       |                           return;
 3360|       |                        }
 3361|       |
 3362|       |                        parse<JSON>::handle_unknown<Opts>(key, value, ctx, it, end);
 3363|       |                        if (bool(ctx.error)) [[unlikely]]
 3364|       |                           return;
 3365|       |
 3366|       |                        if (skip_ws<Opts>(ctx, it, end)) {
 3367|       |                           return;
 3368|       |                        }
 3369|       |                        continue;
 3370|       |                     }
 3371|       |                     else {
 3372|       |                        it = start; // reset the iterator
 3373|       |                     }
 3374|       |                  }
 3375|       |
 3376|       |                  if constexpr (Opts.error_on_missing_keys || Opts.partial_read) {
 3377|       |                     size_t index = num_members;
 3378|       |                     parse_and_invoke<Opts, T>(value, ctx, it, end, index);
 3379|       |                     if (bool(ctx.error)) [[unlikely]]
 3380|       |                        return;
 3381|       |                     if (index < num_members) {
 3382|       |                        fields[index] = true;
 3383|       |                     }
 3384|       |                  }
 3385|  28.5k|                  else {
 3386|  28.5k|                     parse_and_invoke<Opts, T>(value, ctx, it, end);
 3387|  28.5k|                     if (bool(ctx.error)) [[unlikely]]
  ------------------
  |  Branch (3387:26): [True: 3.41k, False: 25.1k]
  ------------------
 3388|  3.41k|                        return;
 3389|  28.5k|                  }
 3390|       |               }
 3391|       |               else {
 3392|       |                  // For types like std::map, std::unordered_map
 3393|       |
 3394|       |                  auto reading = [&](auto&& key) {
 3395|       |                     if constexpr (Opts.partial_read) {
 3396|       |                        if (auto element = value.find(key); element != value.end()) {
 3397|       |                           ++read_count;
 3398|       |                           parse<JSON>::op<ws_handled<Opts>()>(element->second, ctx, it, end);
 3399|       |                        }
 3400|       |                        else {
 3401|       |                           skip_value<JSON>::op<Opts>(ctx, it, end);
 3402|       |                        }
 3403|       |                     }
 3404|       |                     else {
 3405|       |                        parse<JSON>::op<ws_handled<Opts>()>(value[key], ctx, it, end);
 3406|       |                     }
 3407|       |                  };
 3408|       |
 3409|       |                  // using Key = std::conditional_t<heterogeneous_map<T>, sv, typename T::key_type>;
 3410|       |                  using Key = typename T::key_type;
 3411|       |                  if constexpr (std::is_same_v<Key, std::string>) {
 3412|       |                     ctx.scratch.clear();
 3413|       |                     parse<JSON>::op<Opts>(ctx.scratch, ctx, it, end);
 3414|       |                     if (bool(ctx.error)) [[unlikely]]
 3415|       |                        return;
 3416|       |
 3417|       |                     if (parse_ws_colon<Opts>(ctx, it, end)) {
 3418|       |                        return;
 3419|       |                     }
 3420|       |
 3421|       |                     reading(ctx.scratch);
 3422|       |                     if constexpr (Opts.partial_read) {
 3423|       |                        if (read_count == value.size()) {
 3424|       |                           return;
 3425|       |                        }
 3426|       |                     }
 3427|       |                     if (bool(ctx.error)) [[unlikely]]
 3428|       |                        return;
 3429|       |                  }
 3430|       |                  else if constexpr (str_t<Key>) {
 3431|       |                     Key key;
 3432|       |                     parse<JSON>::op<Opts>(key, ctx, it, end);
 3433|       |                     if (bool(ctx.error)) [[unlikely]]
 3434|       |                        return;
 3435|       |
 3436|       |                     if (parse_ws_colon<Opts>(ctx, it, end)) {
 3437|       |                        return;
 3438|       |                     }
 3439|       |
 3440|       |                     reading(key);
 3441|       |                     if constexpr (Opts.partial_read) {
 3442|       |                        if (read_count == value.size()) {
 3443|       |                           return;
 3444|       |                        }
 3445|       |                     }
 3446|       |                     if (bool(ctx.error)) [[unlikely]]
 3447|       |                        return;
 3448|       |                  }
 3449|       |                  else {
 3450|       |                     Key key_value{};
 3451|       |                     if constexpr (is_named_enum<Key> || mimics_str_t<Key>) {
 3452|       |                        parse<JSON>::op<Opts>(key_value, ctx, it, end);
 3453|       |                     }
 3454|       |                     else if constexpr (std::is_arithmetic_v<Key>) {
 3455|       |                        // prefer over quoted_t below to avoid double parsing of quoted_t
 3456|       |                        parse<JSON>::op<opt_true<Opts, quoted_num_opt_tag{}>>(key_value, ctx, it, end);
 3457|       |                     }
 3458|       |                     else {
 3459|       |                        parse<JSON>::op<opt_false<Opts, raw_string_opt_tag{}>>(quoted_t<Key>{key_value}, ctx, it, end);
 3460|       |                     }
 3461|       |                     if (bool(ctx.error)) [[unlikely]]
 3462|       |                        return;
 3463|       |
 3464|       |                     if (parse_ws_colon<Opts>(ctx, it, end)) {
 3465|       |                        return;
 3466|       |                     }
 3467|       |
 3468|       |                     reading(key_value);
 3469|       |                     if constexpr (Opts.partial_read) {
 3470|       |                        if (read_count == value.size()) {
 3471|       |                           return;
 3472|       |                        }
 3473|       |                     }
 3474|       |                     if (bool(ctx.error)) [[unlikely]]
 3475|       |                        return;
 3476|       |                  }
 3477|       |               }
 3478|       |
 3479|       |               // Streaming refill point: after parsing each key-value pair, refill if buffer is low
 3480|       |               if constexpr (has_streaming_state<decltype(ctx)>) {
 3481|       |                  if (ctx.stream.enabled()) {
 3482|       |                     const size_t consumed = static_cast<size_t>(it - ctx.stream.data());
 3483|       |                     // Refill when less than 25% of buffer remains to ensure enough space for next element
 3484|       |                     if (ctx.stream.size() - consumed <= ctx.stream.size() / 4 || it >= end) {
 3485|       |                        const char* new_it;
 3486|       |                        const char* new_end;
 3487|       |                        ctx.stream.consume_and_refill(consumed, new_it, new_end);
 3488|       |                        it = new_it;
 3489|       |                        end = new_end;
 3490|       |                        if (it >= end && ctx.stream.at_eof()) {
 3491|       |                           ctx.error = error_code::unexpected_end;
 3492|       |                           return;
 3493|       |                        }
 3494|       |                     }
 3495|       |                  }
 3496|       |               }
 3497|       |
 3498|  29.2k|               if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (3498:20): [True: 0, False: 29.2k]
  ------------------
 3499|      0|                  return;
 3500|      0|               }
 3501|  29.2k|            }
 3502|  5.21k|         }
 3503|  5.21k|      }
_ZZN3glz4fromILj10EN12jsonrpc_fuzz8fuzz_apiEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnNS_14string_literalEXtlNS6_ILm1EEEEERS2_TkNS_10is_contextERNS_7contextERPKcSC_EEvOT1_OT2_OT3_T4_ENKUlvE_clEv:
 3148|  5.15k|            decltype(auto) fields = [&]() -> decltype(auto) {
 3149|       |               if constexpr ((glaze_object_t<T> || reflectable<T>) &&
 3150|       |                             (Opts.error_on_missing_keys || Opts.partial_read)) {
 3151|       |                  return bit_array<num_members>{};
 3152|       |               }
 3153|  5.15k|               else {
 3154|  5.15k|                  return nullptr;
 3155|  5.15k|               }
 3156|  5.15k|            }();
_ZN3glz16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT3_OT4_OT5_DpOT2_:
  376|  28.5k|   {
  377|  28.5k|      constexpr auto N = reflect<T>::size;
  378|       |
  379|       |      if constexpr (N == 1) {
  380|       |         decode_index<Opts, T, 0>(value, ctx, it, end, selected_index...);
  381|       |      }
  382|       |      else if constexpr (check_linear_search(Opts)) {
  383|       |         // Linear search path
  384|       |         auto key_start = it;
  385|       |         const auto index = decode_linear<T>(ctx, it, end);
  386|       |         if (bool(ctx.error)) [[unlikely]]
  387|       |            return;
  388|       |
  389|       |         if (index >= N) [[unlikely]] {
  390|       |            if constexpr (Opts.error_on_unknown_keys) {
  391|       |               ctx.error = error_code::unknown_key;
  392|       |               return;
  393|       |            }
  394|       |            else {
  395|       |               // it sits one past the closing quote, so the raw key spans [key_start, it - 1)
  396|       |               if (validate_utf8_span<Opts>(ctx, key_start, it - 1)) [[unlikely]] {
  397|       |                  return;
  398|       |               }
  399|       |               const sv key{key_start, size_t(it - key_start - 1)};
  400|       |               if constexpr (not Opts.null_terminated) {
  401|       |                  if (it == end) [[unlikely]] {
  402|       |                     ctx.error = error_code::unexpected_end;
  403|       |                     return;
  404|       |                  }
  405|       |               }
  406|       |               if (parse_ws_colon<Opts>(ctx, it, end)) {
  407|       |                  return;
  408|       |               }
  409|       |               parse<JSON>::handle_unknown<Opts>(key, value, ctx, it, end);
  410|       |               return;
  411|       |            }
  412|       |         }
  413|       |
  414|       |         if constexpr (not Opts.null_terminated) {
  415|       |            if (it == end) [[unlikely]] {
  416|       |               ctx.error = error_code::unexpected_end;
  417|       |               return;
  418|       |            }
  419|       |         }
  420|       |         if (skip_ws<Opts>(ctx, it, end)) {
  421|       |            return;
  422|       |         }
  423|       |         if (match_invalid_end<':', Opts>(ctx, it, end)) {
  424|       |            return;
  425|       |         }
  426|       |         if (skip_ws<Opts>(ctx, it, end)) {
  427|       |            return;
  428|       |         }
  429|       |
  430|       |         // Fold expression dispatch - avoids jump table overhead for smaller binary size.
  431|       |         // For linear_search, pass Opts through to the field parser to avoid duplicate template
  432|       |         // instantiations; the whitespace before the value has already been skipped either way.
  433|       |         [&]<size_t... Is>(std::index_sequence<Is...>) {
  434|       |            (void)(((index == Is ? (decode_field_value<Opts, Opts, T, Is>(value, ctx, it, end, selected_index...), true)
  435|       |                                 : false) ||
  436|       |                    ...));
  437|       |         }(std::make_index_sequence<N>{});
  438|       |      }
  439|  28.5k|      else {
  440|       |         // Hash-based lookup
  441|  28.5k|         constexpr auto& HashInfo = hash_info<T>;
  442|  28.5k|         constexpr auto type = HashInfo.type;
  443|  28.5k|         static_assert(bool(type), "invalid hash algorithm");
  444|       |
  445|  28.5k|         const auto index = decode_hash<JSON, T, HashInfo, HashInfo.type>::op(it, end);
  446|       |
  447|  28.5k|         if (index >= N) [[unlikely]] {
  ------------------
  |  Branch (447:14): [True: 61, False: 28.4k]
  ------------------
  448|     61|            if constexpr (Opts.error_on_unknown_keys) {
  449|     61|               ctx.error = error_code::unknown_key;
  450|     61|               return;
  451|       |            }
  452|       |            else {
  453|       |               auto start = it;
  454|       |               skip_string_view(ctx, it, end);
  455|       |               if (bool(ctx.error)) [[unlikely]]
  456|       |                  return;
  457|       |               if (validate_utf8_span<Opts>(ctx, start, it)) [[unlikely]]
  458|       |                  return;
  459|       |               const sv key = {start, size_t(it - start)};
  460|       |               ++it; // skip the quote
  461|       |               if constexpr (not Opts.null_terminated) {
  462|       |                  if (it == end) [[unlikely]] {
  463|       |                     ctx.error = error_code::unexpected_end;
  464|       |                     return;
  465|       |                  }
  466|       |               }
  467|       |               if (parse_ws_colon<Opts>(ctx, it, end)) {
  468|       |                  return;
  469|       |               }
  470|       |               parse<JSON>::handle_unknown<Opts>(key, value, ctx, it, end);
  471|       |               return;
  472|       |            }
  473|     61|         }
  474|       |
  475|       |         if constexpr (N == 2) {
  476|       |            if (index == 0) {
  477|       |               decode_index<Opts, T, 0>(value, ctx, it, end, selected_index...);
  478|       |            }
  479|       |            else {
  480|       |               decode_index<Opts, T, 1>(value, ctx, it, end, selected_index...);
  481|       |            }
  482|       |         }
  483|  28.5k|         else {
  484|  28.5k|            visit<N>([&]<size_t I>() { decode_index<Opts, T, I>(value, ctx, it, end, selected_index...); }, index);
  485|  28.5k|         }
  486|  28.5k|      }
  487|  28.5k|   }
_ZZN3glz16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT3_OT4_OT5_DpOT2_ENKUlTnmvE_clILm0EEEDav:
  484|  14.2k|            visit<N>([&]<size_t I>() { decode_index<Opts, T, I>(value, ctx, it, end, selected_index...); }, index);
_ZN3glz12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiELm0ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT2_OT4_OT5_OT6_DpOT3_:
  311|  14.2k|   {
  312|  14.2k|      static constexpr auto Key = get<I>(reflect<T>::keys);
  313|  14.2k|      static constexpr auto KeyWithEndQuote = join_v<Key, chars<"\"">>;
  314|  14.2k|      static constexpr auto Length = KeyWithEndQuote.size();
  315|       |
  316|  14.2k|      if (((it + Length) < end) && comparitor<KeyWithEndQuote>(it)) [[likely]] {
  ------------------
  |  Branch (316:11): [True: 14.1k, False: 3]
  |  Branch (316:36): [True: 14.1k, False: 23]
  ------------------
  317|  14.1k|         it += Length;
  318|  14.1k|         if constexpr (not Opts.null_terminated) {
  319|  14.1k|            if (it == end) [[unlikely]] {
  ------------------
  |  Branch (319:17): [True: 0, False: 14.1k]
  ------------------
  320|      0|               ctx.error = error_code::unexpected_end;
  321|      0|               return;
  322|      0|            }
  323|  14.1k|         }
  324|       |
  325|  14.1k|         if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (325:14): [True: 0, False: 14.1k]
  ------------------
  326|      0|            return;
  327|      0|         }
  328|  14.1k|         if (match_invalid_end<':', Opts>(ctx, it, end)) {
  ------------------
  |  Branch (328:14): [True: 26, False: 14.1k]
  ------------------
  329|     26|            return;
  330|     26|         }
  331|  14.1k|         if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (331:14): [True: 0, False: 14.1k]
  ------------------
  332|      0|            return;
  333|      0|         }
  334|       |
  335|       |         // The hash path has already consumed the whitespace before the value
  336|  14.1k|         decode_field_value<Opts, ws_handled<Opts>(), T, I>(value, ctx, it, end, selected_index...);
  337|  14.1k|      }
  338|     26|      else [[unlikely]] {
  339|     26|         decode_index_unknown_key<Opts, T>(value, ctx, it, end);
  340|     26|      }
  341|  14.2k|   }
_ZN3glz18decode_field_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnDaXtlS1_Lj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEEN12jsonrpc_fuzz8fuzz_apiELm0ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT1_E11reflectableISA_EEEvOT3_OT5_OT6_OT7_DpOT4_:
  245|  14.1k|   {
  246|       |      // Check for null value skipping on read
  247|       |      if constexpr (check_skip_null_members_on_read(Opts)) {
  248|       |         if (*it == 'n') {
  249|       |            ++it;
  250|       |            if constexpr (not Opts.null_terminated) {
  251|       |               if (it == end) [[unlikely]] {
  252|       |                  ctx.error = error_code::unexpected_end;
  253|       |                  return;
  254|       |               }
  255|       |            }
  256|       |            match<"ull", Opts>(ctx, it, end);
  257|       |            if (bool(ctx.error)) [[unlikely]]
  258|       |               return;
  259|       |            // Successfully matched "null", skip it
  260|       |            if constexpr (Opts.error_on_missing_keys || Opts.partial_read) {
  261|       |               ((selected_index = I), ...); // Mark as handled even if skipped
  262|       |            }
  263|       |            return;
  264|       |         }
  265|       |      }
  266|       |
  267|       |      if constexpr (skipped_by_meta<T, I, operation::parse>) {
  268|       |         skip_value<JSON>::op<Opts>(ctx, it, end);
  269|       |         if (bool(ctx.error)) [[unlikely]]
  270|       |            return; // Propagate error from skip_value
  271|       |      }
  272|  14.1k|      else {
  273|  14.1k|         using V = refl_t<T, I>;
  274|       |
  275|       |         if constexpr (const_value_v<V>) {
  276|       |            if constexpr (check_error_on_const_read(Opts)) {
  277|       |               ctx.error = error_code::attempt_const_read;
  278|       |            }
  279|       |            else {
  280|       |               // do not read anything into the const value
  281|       |               skip_value<JSON>::op<Opts>(ctx, it, end);
  282|       |            }
  283|       |         }
  284|       |         else if constexpr (is_function_ptr_or_ref<V>) {
  285|       |            // Function pointers cannot be deserialized from JSON.
  286|       |            // When write_function_pointers is enabled the writer emits a type-name string,
  287|       |            // but there is nothing meaningful to reconstruct on read — just skip the value.
  288|       |            // When write_function_pointers is off the key is never written, so this branch
  289|       |            // is unreachable in that case.
  290|       |            skip_value<JSON>::op<Opts>(ctx, it, end);
  291|       |         }
  292|       |         else if constexpr (glaze_object_t<T>) {
  293|       |            from<JSON, std::remove_cvref_t<V>>::template op<FieldOpts>(get_member(value, get<I>(reflect<T>::values)),
  294|       |                                                                       ctx, it, end);
  295|       |         }
  296|  14.1k|         else {
  297|  14.1k|            from<JSON, std::remove_cvref_t<V>>::template op<FieldOpts>(get_member(value, get<I>(to_tie(value))), ctx,
  298|  14.1k|                                                                       it, end);
  299|  14.1k|         }
  300|  14.1k|      }
  301|       |
  302|       |      // The key was present and handled, even when the value itself was skipped
  303|       |      if constexpr (Opts.error_on_missing_keys || Opts.partial_read) {
  304|       |         ((selected_index = I), ...);
  305|       |      }
  306|  14.1k|   }
_ZN3glz24decode_index_unknown_keyITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiERS3_TkNS_10is_contextERNS_7contextERPKcS8_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT2_OT3_T4_:
  177|    370|   {
  178|    370|      if constexpr (Opts.error_on_unknown_keys) {
  179|    370|         ctx.error = error_code::unknown_key;
  180|       |      }
  181|       |      else {
  182|       |         auto* start = it;
  183|       |         skip_string_view(ctx, it, end);
  184|       |         if (bool(ctx.error)) [[unlikely]]
  185|       |            return;
  186|       |         if (validate_utf8_span<Opts>(ctx, start, it)) [[unlikely]]
  187|       |            return;
  188|       |         const sv key = {start, size_t(it - start)};
  189|       |         ++it;
  190|       |         if constexpr (not Opts.null_terminated) {
  191|       |            if (it == end) [[unlikely]] {
  192|       |               ctx.error = error_code::unexpected_end;
  193|       |               return;
  194|       |            }
  195|       |         }
  196|       |
  197|       |         if (parse_ws_colon<Opts>(ctx, it, end)) {
  198|       |            return;
  199|       |         }
  200|       |
  201|       |         parse<JSON>::handle_unknown<Opts>(key, value, ctx, it, end);
  202|       |      }
  203|    370|   }
_ZZN3glz16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT3_OT4_OT5_DpOT2_ENKUlTnmvE_clILm1EEEDav:
  484|    287|            visit<N>([&]<size_t I>() { decode_index<Opts, T, I>(value, ctx, it, end, selected_index...); }, index);
_ZN3glz12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiELm1ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT2_OT4_OT5_OT6_DpOT3_:
  311|    287|   {
  312|    287|      static constexpr auto Key = get<I>(reflect<T>::keys);
  313|    287|      static constexpr auto KeyWithEndQuote = join_v<Key, chars<"\"">>;
  314|    287|      static constexpr auto Length = KeyWithEndQuote.size();
  315|       |
  316|    287|      if (((it + Length) < end) && comparitor<KeyWithEndQuote>(it)) [[likely]] {
  ------------------
  |  Branch (316:11): [True: 282, False: 5]
  |  Branch (316:36): [True: 226, False: 56]
  ------------------
  317|    226|         it += Length;
  318|    226|         if constexpr (not Opts.null_terminated) {
  319|    226|            if (it == end) [[unlikely]] {
  ------------------
  |  Branch (319:17): [True: 0, False: 226]
  ------------------
  320|      0|               ctx.error = error_code::unexpected_end;
  321|      0|               return;
  322|      0|            }
  323|    226|         }
  324|       |
  325|    226|         if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (325:14): [True: 0, False: 226]
  ------------------
  326|      0|            return;
  327|      0|         }
  328|    226|         if (match_invalid_end<':', Opts>(ctx, it, end)) {
  ------------------
  |  Branch (328:14): [True: 22, False: 204]
  ------------------
  329|     22|            return;
  330|     22|         }
  331|    204|         if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (331:14): [True: 0, False: 204]
  ------------------
  332|      0|            return;
  333|      0|         }
  334|       |
  335|       |         // The hash path has already consumed the whitespace before the value
  336|    204|         decode_field_value<Opts, ws_handled<Opts>(), T, I>(value, ctx, it, end, selected_index...);
  337|    204|      }
  338|     61|      else [[unlikely]] {
  339|     61|         decode_index_unknown_key<Opts, T>(value, ctx, it, end);
  340|     61|      }
  341|    287|   }
_ZN3glz18decode_field_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnDaXtlS1_Lj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEEN12jsonrpc_fuzz8fuzz_apiELm1ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT1_E11reflectableISA_EEEvOT3_OT5_OT6_OT7_DpOT4_:
  245|    204|   {
  246|       |      // Check for null value skipping on read
  247|       |      if constexpr (check_skip_null_members_on_read(Opts)) {
  248|       |         if (*it == 'n') {
  249|       |            ++it;
  250|       |            if constexpr (not Opts.null_terminated) {
  251|       |               if (it == end) [[unlikely]] {
  252|       |                  ctx.error = error_code::unexpected_end;
  253|       |                  return;
  254|       |               }
  255|       |            }
  256|       |            match<"ull", Opts>(ctx, it, end);
  257|       |            if (bool(ctx.error)) [[unlikely]]
  258|       |               return;
  259|       |            // Successfully matched "null", skip it
  260|       |            if constexpr (Opts.error_on_missing_keys || Opts.partial_read) {
  261|       |               ((selected_index = I), ...); // Mark as handled even if skipped
  262|       |            }
  263|       |            return;
  264|       |         }
  265|       |      }
  266|       |
  267|       |      if constexpr (skipped_by_meta<T, I, operation::parse>) {
  268|       |         skip_value<JSON>::op<Opts>(ctx, it, end);
  269|       |         if (bool(ctx.error)) [[unlikely]]
  270|       |            return; // Propagate error from skip_value
  271|       |      }
  272|    204|      else {
  273|    204|         using V = refl_t<T, I>;
  274|       |
  275|       |         if constexpr (const_value_v<V>) {
  276|       |            if constexpr (check_error_on_const_read(Opts)) {
  277|       |               ctx.error = error_code::attempt_const_read;
  278|       |            }
  279|       |            else {
  280|       |               // do not read anything into the const value
  281|       |               skip_value<JSON>::op<Opts>(ctx, it, end);
  282|       |            }
  283|       |         }
  284|       |         else if constexpr (is_function_ptr_or_ref<V>) {
  285|       |            // Function pointers cannot be deserialized from JSON.
  286|       |            // When write_function_pointers is enabled the writer emits a type-name string,
  287|       |            // but there is nothing meaningful to reconstruct on read — just skip the value.
  288|       |            // When write_function_pointers is off the key is never written, so this branch
  289|       |            // is unreachable in that case.
  290|       |            skip_value<JSON>::op<Opts>(ctx, it, end);
  291|       |         }
  292|       |         else if constexpr (glaze_object_t<T>) {
  293|       |            from<JSON, std::remove_cvref_t<V>>::template op<FieldOpts>(get_member(value, get<I>(reflect<T>::values)),
  294|       |                                                                       ctx, it, end);
  295|       |         }
  296|    204|         else {
  297|    204|            from<JSON, std::remove_cvref_t<V>>::template op<FieldOpts>(get_member(value, get<I>(to_tie(value))), ctx,
  298|    204|                                                                       it, end);
  299|    204|         }
  300|    204|      }
  301|       |
  302|       |      // The key was present and handled, even when the value itself was skipped
  303|       |      if constexpr (Opts.error_on_missing_keys || Opts.partial_read) {
  304|       |         ((selected_index = I), ...);
  305|       |      }
  306|    204|   }
_ZN3glz4fromILj10ENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEERPKcSC_S7_TkNS_10is_contextERNS_7contextEQntcl15check_is_paddedTL0__EEEvRT2_OT3_OT0_T1_:
 1043|   761k|      {
 1044|       |         if constexpr (check_string_as_number(Opts)) {
 1045|       |            auto start = it;
 1046|       |            skip_number<Opts>(ctx, it, end);
 1047|       |            if (bool(ctx.error)) [[unlikely]] {
 1048|       |               return;
 1049|       |            }
 1050|       |            if (start == it) [[unlikely]] {
 1051|       |               ctx.error = error_code::parse_number_failure;
 1052|       |               return;
 1053|       |            }
 1054|       |            value.append(start, size_t(it - start));
 1055|       |         }
 1056|   761k|         else {
 1057|   761k|            if constexpr (!check_opening_handled(Opts)) {
 1058|       |               if constexpr (!check_ws_handled(Opts)) {
 1059|       |                  if (skip_ws<Opts>(ctx, it, end)) {
 1060|       |                     return;
 1061|       |                  }
 1062|       |               }
 1063|       |
 1064|   761k|               if (match_invalid_end<'"', Opts>(ctx, it, end)) {
  ------------------
  |  Branch (1064:20): [True: 95, False: 761k]
  ------------------
 1065|     95|                  return;
 1066|     95|               }
 1067|   761k|            }
 1068|       |
 1069|   761k|            if constexpr (not check_raw_string(Opts)) {
 1070|   761k|               static constexpr auto string_padding_bytes = 8;
 1071|       |
 1072|   761k|               if (size_t(end - it) >= 8) {
  ------------------
  |  Branch (1072:20): [True: 761k, False: 419]
  ------------------
 1073|   761k|                  auto start = it;
 1074|   761k|                  uint64_t ascii_acc{};
 1075|   761k|                  const auto end8 = end - 8;
 1076|  10.8M|                  while (true) {
  ------------------
  |  Branch (1076:26): [True: 10.8M, Folded]
  ------------------
 1077|  10.8M|                     if (it >= end8) [[unlikely]] {
  ------------------
  |  Branch (1077:26): [True: 847, False: 10.8M]
  ------------------
 1078|    847|                        break;
 1079|    847|                     }
 1080|       |
 1081|  10.8M|                     uint64_t chunk;
 1082|  10.8M|                     std::memcpy(&chunk, it, 8);
 1083|       |                     if constexpr (std::endian::native == std::endian::big) {
 1084|       |                        chunk = std::byteswap(chunk);
 1085|       |                     }
 1086|  10.8M|                     ascii_acc |= chunk;
 1087|  10.8M|                     const uint64_t test_chars = has_quote(chunk);
 1088|  10.8M|                     if (test_chars) {
  ------------------
  |  Branch (1088:26): [True: 986k, False: 9.87M]
  ------------------
 1089|   986k|                        it += (countr_zero(test_chars) >> 3);
 1090|       |
 1091|   986k|                        auto* prev = it - 1;
 1092|  1.26M|                        while (*prev == '\\') {
  ------------------
  |  Branch (1092:32): [True: 281k, False: 986k]
  ------------------
 1093|   281k|                           --prev;
 1094|   281k|                        }
 1095|   986k|                        if (size_t(it - prev) % 2) {
  ------------------
  |  Branch (1095:29): [True: 760k, False: 225k]
  ------------------
 1096|   760k|                           goto continue_decode;
 1097|   760k|                        }
 1098|   225k|                        ++it; // skip the escaped quote
 1099|   225k|                     }
 1100|  9.87M|                     else {
 1101|  9.87M|                        it += 8;
 1102|  9.87M|                     }
 1103|  10.8M|                  }
 1104|       |
 1105|  2.43k|                  while (it[-1] == '\\') [[unlikely]] {
  ------------------
  |  Branch (1105:26): [True: 1.58k, False: 847]
  ------------------
 1106|       |                     // if we ended on an escape character then we need to rewind
 1107|       |                     // because we lost our context
 1108|  1.58k|                     --it;
 1109|  1.58k|                  }
 1110|       |
 1111|       |                  // The byte-wise tail keeps feeding the accumulator: it has to cover every byte of
 1112|       |                  // the string, or a non-ASCII byte reached here would be waved through unvalidated.
 1113|  5.54k|                  for (; it < end; ++it) {
  ------------------
  |  Branch (1113:26): [True: 5.54k, False: 0]
  ------------------
 1114|  5.54k|                     ascii_acc |= uint8_t(*it);
 1115|  5.54k|                     if (*it == '"') {
  ------------------
  |  Branch (1115:26): [True: 877, False: 4.66k]
  ------------------
 1116|    877|                        auto* prev = it - 1;
 1117|  1.92k|                        while (*prev == '\\') {
  ------------------
  |  Branch (1117:32): [True: 1.04k, False: 877]
  ------------------
 1118|  1.04k|                           --prev;
 1119|  1.04k|                        }
 1120|    877|                        if (size_t(it - prev) % 2) {
  ------------------
  |  Branch (1120:29): [True: 847, False: 30]
  ------------------
 1121|    847|                           goto continue_decode;
 1122|    847|                        }
 1123|    877|                     }
 1124|  5.54k|                  }
 1125|       |
 1126|      0|                  ctx.error = error_code::unexpected_end;
 1127|      0|                  return;
 1128|       |
 1129|   761k|               continue_decode:
 1130|       |
 1131|   761k|                  if (validate_utf8_span<Opts>(ctx, start, it, ascii_acc)) [[unlikely]] {
  ------------------
  |  Branch (1131:23): [True: 13.6k, False: 747k]
  ------------------
 1132|  13.6k|                     return;
 1133|  13.6k|                  }
 1134|       |
 1135|   747k|                  const auto available_padding = size_t(end - it);
 1136|   747k|                  auto n = size_t(it - start);
 1137|   747k|                  if (available_padding >= 8) [[likely]] {
  ------------------
  |  Branch (1137:23): [True: 746k, False: 925]
  ------------------
 1138|   746k|                     value.resize(n + string_padding_bytes);
 1139|       |
 1140|   746k|                     auto* p = value.data();
 1141|       |
 1142|  4.40M|                     while (true) {
  ------------------
  |  Branch (1142:29): [True: 4.40M, Folded]
  ------------------
 1143|  4.40M|                        if (start >= it) {
  ------------------
  |  Branch (1143:29): [True: 738k, False: 3.66M]
  ------------------
 1144|   738k|                           break;
 1145|   738k|                        }
 1146|       |
 1147|  3.66M|                        std::memcpy(p, start, 8);
 1148|  3.66M|                        uint64_t swar;
 1149|  3.66M|                        std::memcpy(&swar, p, 8);
 1150|       |                        if constexpr (std::endian::native == std::endian::big) {
 1151|       |                           swar = std::byteswap(swar);
 1152|       |                        }
 1153|       |
 1154|  3.66M|                        constexpr uint64_t lo7_mask = repeat_byte8(0b01111111);
 1155|  3.66M|                        const uint64_t lo7 = swar & lo7_mask;
 1156|  3.66M|                        const uint64_t backslash = (lo7 ^ repeat_byte8('\\')) + lo7_mask;
 1157|  3.66M|                        const uint64_t less_32 = (swar & repeat_byte8(0b01100000)) + lo7_mask;
 1158|  3.66M|                        uint64_t next = ~((backslash & less_32) | swar);
 1159|       |
 1160|  3.66M|                        next &= repeat_byte8(0b10000000);
 1161|  3.66M|                        if (next == 0) {
  ------------------
  |  Branch (1161:29): [True: 3.21M, False: 450k]
  ------------------
 1162|  3.21M|                           start += 8;
 1163|  3.21M|                           p += 8;
 1164|  3.21M|                           continue;
 1165|  3.21M|                        }
 1166|       |
 1167|   450k|                        next = countr_zero(next) >> 3;
 1168|   450k|                        start += next;
 1169|   450k|                        if (start >= it) {
  ------------------
  |  Branch (1169:29): [True: 267, False: 450k]
  ------------------
 1170|    267|                           break;
 1171|    267|                        }
 1172|       |
 1173|   450k|                        if ((*start & 0b11100000) == 0) [[unlikely]] {
  ------------------
  |  Branch (1173:29): [True: 8.21k, False: 441k]
  ------------------
 1174|  8.21k|                           ctx.error = error_code::syntax_error;
 1175|  8.21k|                           return;
 1176|  8.21k|                        }
 1177|   441k|                        ++start; // skip the escape
 1178|   441k|                        if (*start == 'u') {
  ------------------
  |  Branch (1178:29): [True: 1.94k, False: 439k]
  ------------------
 1179|  1.94k|                           ++start;
 1180|  1.94k|                           p += next;
 1181|  1.94k|                           const auto mark = start;
 1182|  1.94k|                           const auto offset = handle_unicode_code_point(start, p, end);
 1183|  1.94k|                           if (offset == 0) [[unlikely]] {
  ------------------
  |  Branch (1183:32): [True: 99, False: 1.84k]
  ------------------
 1184|     99|                              ctx.error = error_code::unicode_escape_conversion_failure;
 1185|     99|                              return;
 1186|     99|                           }
 1187|  1.84k|                           n += offset;
 1188|       |                           // escape + u + unicode code points
 1189|  1.84k|                           n -= 2 + uint32_t(start - mark);
 1190|  1.84k|                        }
 1191|   439k|                        else {
 1192|   439k|                           p += next;
 1193|   439k|                           *p = char_unescape_table[uint8_t(*start)];
 1194|   439k|                           if (*p == 0) [[unlikely]] {
  ------------------
  |  Branch (1194:32): [True: 20, False: 439k]
  ------------------
 1195|     20|                              ctx.error = error_code::invalid_escape;
 1196|     20|                              return;
 1197|     20|                           }
 1198|   439k|                           ++p;
 1199|   439k|                           ++start;
 1200|   439k|                           --n;
 1201|   439k|                        }
 1202|   441k|                     }
 1203|       |
 1204|   738k|                     value.resize(n);
 1205|   738k|                     ++it;
 1206|   738k|                  }
 1207|    925|                  else {
 1208|       |                     // For large inputs this case of running out of buffer is very rare
 1209|    925|                     value.resize(n);
 1210|    925|                     auto* p = value.data();
 1211|       |
 1212|    925|                     it = start;
 1213|  4.14M|                     while (it < end) [[likely]] {
  ------------------
  |  Branch (1213:29): [True: 4.14M, False: 0]
  ------------------
 1214|  4.14M|                        if (*it == '"') {
  ------------------
  |  Branch (1214:29): [True: 395, False: 4.14M]
  ------------------
 1215|    395|                           value.resize(size_t(p - value.data()));
 1216|    395|                           ++it;
 1217|    395|                           return;
 1218|    395|                        }
 1219|       |
 1220|  4.14M|                        if ((*it & 0b11100000) == 0) [[unlikely]] {
  ------------------
  |  Branch (1220:29): [True: 364, False: 4.14M]
  ------------------
 1221|    364|                           ctx.error = error_code::syntax_error;
 1222|    364|                           return;
 1223|    364|                        }
 1224|       |
 1225|  4.14M|                        *p = *it;
 1226|       |
 1227|  4.14M|                        if (*it == '\\') {
  ------------------
  |  Branch (1227:29): [True: 28.1k, False: 4.11M]
  ------------------
 1228|  28.1k|                           ++it; // skip the escape
 1229|  28.1k|                           if (*it == 'u') {
  ------------------
  |  Branch (1229:32): [True: 1.98k, False: 26.1k]
  ------------------
 1230|  1.98k|                              ++it;
 1231|  1.98k|                              if (!handle_unicode_code_point(it, p, end)) [[unlikely]] {
  ------------------
  |  Branch (1231:35): [True: 134, False: 1.85k]
  ------------------
 1232|    134|                                 ctx.error = error_code::unicode_escape_conversion_failure;
 1233|    134|                                 return;
 1234|    134|                              }
 1235|  1.98k|                           }
 1236|  26.1k|                           else {
 1237|  26.1k|                              *p = char_unescape_table[uint8_t(*it)];
 1238|  26.1k|                              if (*p == 0) [[unlikely]] {
  ------------------
  |  Branch (1238:35): [True: 32, False: 26.1k]
  ------------------
 1239|     32|                                 ctx.error = error_code::invalid_escape;
 1240|     32|                                 return;
 1241|     32|                              }
 1242|  26.1k|                              ++p;
 1243|  26.1k|                              ++it;
 1244|  26.1k|                           }
 1245|  28.1k|                        }
 1246|  4.11M|                        else {
 1247|  4.11M|                           ++it;
 1248|  4.11M|                           ++p;
 1249|  4.11M|                        }
 1250|  4.14M|                     }
 1251|       |
 1252|      0|                     ctx.error = error_code::unexpected_end;
 1253|      0|                  }
 1254|   747k|               }
 1255|    419|               else {
 1256|       |                  // For short strings
 1257|       |
 1258|    419|                  std::array<char, 8> buffer{};
 1259|       |
 1260|    419|                  auto* p = buffer.data();
 1261|    419|                  const auto* const utf8_start = it;
 1262|       |
 1263|    955|                  while (it < end) [[likely]] {
  ------------------
  |  Branch (1263:26): [True: 860, False: 95]
  ------------------
 1264|    860|                     *p = *it;
 1265|    860|                     if (*it == '"') {
  ------------------
  |  Branch (1265:26): [True: 267, False: 593]
  ------------------
 1266|    267|                        if (validate_utf8_span<Opts>(ctx, utf8_start, it)) [[unlikely]] {
  ------------------
  |  Branch (1266:29): [True: 0, False: 267]
  ------------------
 1267|      0|                           return;
 1268|      0|                        }
 1269|    267|                        const size_t n = size_t(p - buffer.data());
 1270|    267|#if __has_cpp_attribute(assume) >= 202207L
 1271|    267|                        [[assume(n <= sizeof(buffer))]];
 1272|    267|#endif
 1273|    267|                        value.assign(buffer.data(), n);
 1274|    267|                        ++it;
 1275|    267|                        if constexpr (not Opts.null_terminated) {
 1276|    267|                           if (it == end) {
  ------------------
  |  Branch (1276:32): [True: 180, False: 87]
  ------------------
 1277|    180|                              ctx.error = error_code::end_reached;
 1278|    180|                              return;
 1279|    180|                           }
 1280|    267|                        }
 1281|     87|                        return;
 1282|    267|                     }
 1283|    593|                     else if (*it == '\\') {
  ------------------
  |  Branch (1283:31): [True: 115, False: 478]
  ------------------
 1284|    115|                        ++it; // skip the escape
 1285|    115|                        if constexpr (not Opts.null_terminated) {
 1286|    115|                           if (it == end) [[unlikely]] {
  ------------------
  |  Branch (1286:32): [True: 0, False: 115]
  ------------------
 1287|      0|                              ctx.error = error_code::unexpected_end;
 1288|      0|                              return;
 1289|      0|                           }
 1290|    115|                        }
 1291|    115|                        if (*it == 'u') {
  ------------------
  |  Branch (1291:29): [True: 73, False: 42]
  ------------------
 1292|     73|                           ++it;
 1293|     73|                           if constexpr (not Opts.null_terminated) {
 1294|     73|                              if (it == end) [[unlikely]] {
  ------------------
  |  Branch (1294:35): [True: 0, False: 73]
  ------------------
 1295|      0|                                 ctx.error = error_code::unexpected_end;
 1296|      0|                                 return;
 1297|      0|                              }
 1298|     73|                           }
 1299|     73|                           if (!handle_unicode_code_point(it, p, end)) [[unlikely]] {
  ------------------
  |  Branch (1299:32): [True: 20, False: 53]
  ------------------
 1300|     20|                              ctx.error = error_code::unicode_escape_conversion_failure;
 1301|     20|                              return;
 1302|     20|                           }
 1303|     73|                        }
 1304|     42|                        else {
 1305|     42|                           *p = char_unescape_table[uint8_t(*it)];
 1306|     42|                           if (*p == 0) [[unlikely]] {
  ------------------
  |  Branch (1306:32): [True: 5, False: 37]
  ------------------
 1307|      5|                              ctx.error = error_code::invalid_escape;
 1308|      5|                              return;
 1309|      5|                           }
 1310|     37|                           ++p;
 1311|     37|                           ++it;
 1312|     37|                        }
 1313|    115|                     }
 1314|    478|                     else if ((*it & 0b11100000) == 0) [[unlikely]] {
  ------------------
  |  Branch (1314:31): [True: 32, False: 446]
  ------------------
 1315|     32|                        ctx.error = error_code::syntax_error;
 1316|     32|                        return;
 1317|     32|                     }
 1318|    446|                     else {
 1319|    446|                        ++it;
 1320|    446|                        ++p;
 1321|    446|                     }
 1322|    860|                  }
 1323|       |
 1324|     95|                  ctx.error = error_code::unexpected_end;
 1325|     95|               }
 1326|       |            }
 1327|       |            else {
 1328|       |               // raw_string
 1329|       |               auto start = it;
 1330|       |               skip_string_view(ctx, it, end);
 1331|       |               if (bool(ctx.error)) [[unlikely]]
 1332|       |                  return;
 1333|       |
 1334|       |               if (validate_utf8_span<Opts>(ctx, start, it)) [[unlikely]] {
 1335|       |                  return;
 1336|       |               }
 1337|       |
 1338|       |               value.assign(start, size_t(it - start));
 1339|       |               ++it;
 1340|       |            }
 1341|   761k|         }
 1342|   761k|      }
_ZZN3glz16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT3_OT4_OT5_DpOT2_ENKUlTnmvE_clILm2EEEDav:
  484|    728|            visit<N>([&]<size_t I>() { decode_index<Opts, T, I>(value, ctx, it, end, selected_index...); }, index);
_ZN3glz12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiELm2ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT2_OT4_OT5_OT6_DpOT3_:
  311|    728|   {
  312|    728|      static constexpr auto Key = get<I>(reflect<T>::keys);
  313|    728|      static constexpr auto KeyWithEndQuote = join_v<Key, chars<"\"">>;
  314|    728|      static constexpr auto Length = KeyWithEndQuote.size();
  315|       |
  316|    728|      if (((it + Length) < end) && comparitor<KeyWithEndQuote>(it)) [[likely]] {
  ------------------
  |  Branch (316:11): [True: 724, False: 4]
  |  Branch (316:36): [True: 697, False: 27]
  ------------------
  317|    697|         it += Length;
  318|    697|         if constexpr (not Opts.null_terminated) {
  319|    697|            if (it == end) [[unlikely]] {
  ------------------
  |  Branch (319:17): [True: 0, False: 697]
  ------------------
  320|      0|               ctx.error = error_code::unexpected_end;
  321|      0|               return;
  322|      0|            }
  323|    697|         }
  324|       |
  325|    697|         if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (325:14): [True: 0, False: 697]
  ------------------
  326|      0|            return;
  327|      0|         }
  328|    697|         if (match_invalid_end<':', Opts>(ctx, it, end)) {
  ------------------
  |  Branch (328:14): [True: 39, False: 658]
  ------------------
  329|     39|            return;
  330|     39|         }
  331|    658|         if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (331:14): [True: 0, False: 658]
  ------------------
  332|      0|            return;
  333|      0|         }
  334|       |
  335|       |         // The hash path has already consumed the whitespace before the value
  336|    658|         decode_field_value<Opts, ws_handled<Opts>(), T, I>(value, ctx, it, end, selected_index...);
  337|    658|      }
  338|     31|      else [[unlikely]] {
  339|     31|         decode_index_unknown_key<Opts, T>(value, ctx, it, end);
  340|     31|      }
  341|    728|   }
_ZN3glz18decode_field_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnDaXtlS1_Lj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEEN12jsonrpc_fuzz8fuzz_apiELm2ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT1_E11reflectableISA_EEEvOT3_OT5_OT6_OT7_DpOT4_:
  245|    658|   {
  246|       |      // Check for null value skipping on read
  247|       |      if constexpr (check_skip_null_members_on_read(Opts)) {
  248|       |         if (*it == 'n') {
  249|       |            ++it;
  250|       |            if constexpr (not Opts.null_terminated) {
  251|       |               if (it == end) [[unlikely]] {
  252|       |                  ctx.error = error_code::unexpected_end;
  253|       |                  return;
  254|       |               }
  255|       |            }
  256|       |            match<"ull", Opts>(ctx, it, end);
  257|       |            if (bool(ctx.error)) [[unlikely]]
  258|       |               return;
  259|       |            // Successfully matched "null", skip it
  260|       |            if constexpr (Opts.error_on_missing_keys || Opts.partial_read) {
  261|       |               ((selected_index = I), ...); // Mark as handled even if skipped
  262|       |            }
  263|       |            return;
  264|       |         }
  265|       |      }
  266|       |
  267|       |      if constexpr (skipped_by_meta<T, I, operation::parse>) {
  268|       |         skip_value<JSON>::op<Opts>(ctx, it, end);
  269|       |         if (bool(ctx.error)) [[unlikely]]
  270|       |            return; // Propagate error from skip_value
  271|       |      }
  272|    658|      else {
  273|    658|         using V = refl_t<T, I>;
  274|       |
  275|       |         if constexpr (const_value_v<V>) {
  276|       |            if constexpr (check_error_on_const_read(Opts)) {
  277|       |               ctx.error = error_code::attempt_const_read;
  278|       |            }
  279|       |            else {
  280|       |               // do not read anything into the const value
  281|       |               skip_value<JSON>::op<Opts>(ctx, it, end);
  282|       |            }
  283|       |         }
  284|       |         else if constexpr (is_function_ptr_or_ref<V>) {
  285|       |            // Function pointers cannot be deserialized from JSON.
  286|       |            // When write_function_pointers is enabled the writer emits a type-name string,
  287|       |            // but there is nothing meaningful to reconstruct on read — just skip the value.
  288|       |            // When write_function_pointers is off the key is never written, so this branch
  289|       |            // is unreachable in that case.
  290|       |            skip_value<JSON>::op<Opts>(ctx, it, end);
  291|       |         }
  292|       |         else if constexpr (glaze_object_t<T>) {
  293|       |            from<JSON, std::remove_cvref_t<V>>::template op<FieldOpts>(get_member(value, get<I>(reflect<T>::values)),
  294|       |                                                                       ctx, it, end);
  295|       |         }
  296|    658|         else {
  297|    658|            from<JSON, std::remove_cvref_t<V>>::template op<FieldOpts>(get_member(value, get<I>(to_tie(value))), ctx,
  298|    658|                                                                       it, end);
  299|    658|         }
  300|    658|      }
  301|       |
  302|       |      // The key was present and handled, even when the value itself was skipped
  303|       |      if constexpr (Opts.error_on_missing_keys || Opts.partial_read) {
  304|       |         ((selected_index = I), ...);
  305|       |      }
  306|    658|   }
_ZN3glz4fromILj10EN12jsonrpc_fuzz5pointEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEETnNS_14string_literalEXtlNS6_ILm1EEEEERS2_TkNS_10is_contextERNS_7contextERPKcSC_EEvOT1_OT2_OT3_T4_:
 3044|    658|      {
 3045|    658|         static constexpr auto num_members = reflect<T>::size;
 3046|       |
 3047|    658|         static constexpr auto Opts = opening_handled_off<ws_handled_off<Options>()>();
 3048|    658|         if constexpr (!check_opening_handled(Options)) {
 3049|       |            if constexpr (!check_ws_handled(Options)) {
 3050|       |               if (skip_ws<Opts>(ctx, it, end)) {
 3051|       |                  return;
 3052|       |               }
 3053|       |            }
 3054|    658|            if (match_invalid_end<'{', Opts>(ctx, it, end)) {
  ------------------
  |  Branch (3054:17): [True: 35, False: 623]
  ------------------
 3055|     35|               return;
 3056|     35|            }
 3057|    623|            if constexpr (not Opts.null_terminated) {
 3058|    623|               if (it == end) [[unlikely]] {
  ------------------
  |  Branch (3058:20): [True: 0, False: 623]
  ------------------
 3059|      0|                  ctx.error = error_code::unexpected_end;
 3060|      0|                  return;
 3061|      0|               }
 3062|    623|            }
 3063|       |            // one nesting level (see enter_depth): counted in both modes so the limit binds,
 3064|       |            // released at each syntactic close below
 3065|    623|            if (enter_depth(ctx)) [[unlikely]] {
  ------------------
  |  Branch (3065:17): [True: 0, False: 623]
  ------------------
 3066|      0|               return;
 3067|      0|            }
 3068|    623|         }
 3069|    623|         const auto ws_start = it;
 3070|    658|         if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (3070:14): [True: 0, False: 658]
  ------------------
 3071|      0|            return;
 3072|      0|         }
 3073|    658|         const size_t ws_size = size_t(it - ws_start);
 3074|       |
 3075|       |         if constexpr ((glaze_object_t<T> || reflectable<T>) && num_members == 0 && Opts.error_on_unknown_keys) {
 3076|       |            if constexpr (not tag.sv().empty()) {
 3077|       |               if (*it == '"') {
 3078|       |                  ++it;
 3079|       |                  if constexpr (not Opts.null_terminated) {
 3080|       |                     if (it == end) [[unlikely]] {
 3081|       |                        ctx.error = error_code::unexpected_end;
 3082|       |                        return;
 3083|       |                     }
 3084|       |                  }
 3085|       |
 3086|       |                  const auto start = it;
 3087|       |                  skip_string_view(ctx, it, end);
 3088|       |                  if (bool(ctx.error)) [[unlikely]]
 3089|       |                     return;
 3090|       |                  if (validate_utf8_span<Opts>(ctx, start, it)) [[unlikely]]
 3091|       |                     return;
 3092|       |                  const sv key{start, size_t(it - start)};
 3093|       |                  ++it;
 3094|       |                  if constexpr (not Opts.null_terminated) {
 3095|       |                     if (it == end) [[unlikely]] {
 3096|       |                        ctx.error = error_code::unexpected_end;
 3097|       |                        return;
 3098|       |                     }
 3099|       |                  }
 3100|       |
 3101|       |                  if (key == tag.sv()) {
 3102|       |                     if (parse_ws_colon<Opts>(ctx, it, end)) {
 3103|       |                        return;
 3104|       |                     }
 3105|       |
 3106|       |                     parse<JSON>::handle_unknown<Opts>(key, value, ctx, it, end);
 3107|       |                     if (bool(ctx.error)) [[unlikely]]
 3108|       |                        return;
 3109|       |
 3110|       |                     if (skip_ws<Opts>(ctx, it, end)) {
 3111|       |                        return;
 3112|       |                     }
 3113|       |                  }
 3114|       |                  else {
 3115|       |                     ctx.error = error_code::unknown_key;
 3116|       |                     return;
 3117|       |                  }
 3118|       |               }
 3119|       |            }
 3120|       |
 3121|       |            if (*it == '}') [[likely]] {
 3122|       |               --ctx.depth;
 3123|       |               if constexpr (glaze_object_t<T> || reflectable<T>) {
 3124|       |                  if constexpr (has_self_constraint_v<T> && !check_skip_self_constraint(Opts)) {
 3125|       |                     auto wrapper = self_constraint_v<T>(value);
 3126|       |                     from<JSON, decltype(wrapper)>::template op<ws_handled<Opts>()>(wrapper, ctx, it, end);
 3127|       |                     if (bool(ctx.error)) {
 3128|       |                        return;
 3129|       |                     }
 3130|       |                  }
 3131|       |               }
 3132|       |               ++it;
 3133|       |               if constexpr (not Opts.null_terminated) {
 3134|       |                  if (it == end) {
 3135|       |                     ctx.error = error_code::end_reached;
 3136|       |                     return;
 3137|       |                  }
 3138|       |               }
 3139|       |               if constexpr (Opts.partial_read) {
 3140|       |                  ctx.error = error_code::partial_read_complete;
 3141|       |               }
 3142|       |               return;
 3143|       |            }
 3144|       |            ctx.error = error_code::unknown_key;
 3145|       |            return;
 3146|       |         }
 3147|    658|         else {
 3148|    658|            decltype(auto) fields = [&]() -> decltype(auto) {
 3149|    658|               if constexpr ((glaze_object_t<T> || reflectable<T>) &&
 3150|    658|                             (Opts.error_on_missing_keys || Opts.partial_read)) {
 3151|    658|                  return bit_array<num_members>{};
 3152|    658|               }
 3153|    658|               else {
 3154|    658|                  return nullptr;
 3155|    658|               }
 3156|    658|            }();
 3157|       |
 3158|    658|            size_t read_count{}; // for partial_read
 3159|       |
 3160|    658|            bool first = true;
 3161|  4.81k|            while (true) {
  ------------------
  |  Branch (3161:20): [True: 4.29k, Folded]
  ------------------
 3162|       |               if constexpr ((glaze_object_t<T> || reflectable<T>) && Opts.partial_read) {
 3163|       |                  static constexpr bit_array<num_members> all_fields = [] {
 3164|       |                     bit_array<num_members> arr{};
 3165|       |                     for (size_t i = 0; i < num_members; ++i) {
 3166|       |                        arr[i] = true;
 3167|       |                     }
 3168|       |                     return arr;
 3169|       |                  }();
 3170|       |
 3171|       |                  if ((all_fields & fields) == all_fields) {
 3172|       |                     ctx.error = error_code::partial_read_complete;
 3173|       |                     --ctx.depth; // as above: an early success still closes this level
 3174|       |                     return;
 3175|       |                  }
 3176|       |               }
 3177|       |
 3178|       |               // Streaming refill point: at start of each iteration, ensure buffer has data
 3179|       |               if constexpr (has_streaming_state<decltype(ctx)>) {
 3180|       |                  if (ctx.stream.enabled()) {
 3181|       |                     const size_t consumed = static_cast<size_t>(it - ctx.stream.data());
 3182|       |                     const size_t remaining = ctx.stream.size() - consumed;
 3183|       |                     // Refill when less than half of buffer remains to ensure space for next key-value pair
 3184|       |                     if (remaining <= ctx.stream.size() / 2 || it >= end) {
 3185|       |                        const char* new_it;
 3186|       |                        const char* new_end;
 3187|       |                        ctx.stream.consume_and_refill(consumed, new_it, new_end);
 3188|       |                        it = new_it;
 3189|       |                        end = new_end;
 3190|       |                        if (it >= end && ctx.stream.at_eof()) {
 3191|       |                           ctx.error = error_code::unexpected_end;
 3192|       |                           return;
 3193|       |                        }
 3194|       |                     }
 3195|       |                  }
 3196|       |               }
 3197|       |
 3198|  4.29k|               if (*it == '}') {
  ------------------
  |  Branch (3198:20): [True: 116, False: 4.18k]
  ------------------
 3199|    116|                  --ctx.depth;
 3200|       |                  if constexpr ((glaze_object_t<T> || reflectable<T>) && Opts.error_on_missing_keys) {
 3201|       |                     constexpr auto req_fields = required_fields<T, Opts>();
 3202|       |                     if ((req_fields & fields) != req_fields) {
 3203|       |                        for (size_t i = 0; i < num_members; ++i) {
 3204|       |                           if (not fields[i] && req_fields[i]) {
 3205|       |                              ctx.custom_error_message = reflect<T>::keys[i];
 3206|       |                              // We just return the first missing key in order to avoid heap allocations
 3207|       |                              break;
 3208|       |                           }
 3209|       |                        }
 3210|       |
 3211|       |                        ctx.error = error_code::missing_key;
 3212|       |                        return;
 3213|       |                     }
 3214|       |                  }
 3215|    116|                  if constexpr (glaze_object_t<T> || reflectable<T>) {
 3216|       |                     if constexpr (has_self_constraint_v<T> && !check_skip_self_constraint(Opts)) {
 3217|       |                        auto wrapper = self_constraint_v<T>(value);
 3218|       |                        from<JSON, decltype(wrapper)>::template op<ws_handled<Opts>()>(wrapper, ctx, it, end);
 3219|       |                        if (bool(ctx.error)) {
 3220|       |                           return;
 3221|       |                        }
 3222|       |                     }
 3223|    116|                  }
 3224|    116|                  ++it; // Increment after checking for missing keys so errors are within buffer bounds
 3225|    116|                  if constexpr (not Opts.null_terminated) {
 3226|    116|                     if (it == end) {
  ------------------
  |  Branch (3226:26): [True: 0, False: 116]
  ------------------
 3227|      0|                        ctx.error = error_code::end_reached;
 3228|      0|                        return;
 3229|      0|                     }
 3230|    116|                  }
 3231|    116|                  return;
 3232|    116|               }
 3233|  4.18k|               else if (first) {
  ------------------
  |  Branch (3233:25): [True: 579, False: 3.60k]
  ------------------
 3234|    579|                  first = false;
 3235|    579|               }
 3236|  3.60k|               else {
 3237|  3.60k|                  if (match_invalid_end<',', Opts>(ctx, it, end)) {
  ------------------
  |  Branch (3237:23): [True: 25, False: 3.57k]
  ------------------
 3238|     25|                     return;
 3239|     25|                  }
 3240|  3.57k|                  if constexpr (not Opts.null_terminated) {
 3241|  3.57k|                     if (it == end) [[unlikely]] {
  ------------------
  |  Branch (3241:26): [True: 0, False: 3.57k]
  ------------------
 3242|      0|                        ctx.error = error_code::unexpected_end;
 3243|      0|                        return;
 3244|      0|                     }
 3245|  3.57k|                  }
 3246|       |
 3247|       |                  if constexpr ((not Opts.minified) && (num_members > 1 || not Opts.error_on_unknown_keys) &&
 3248|  3.57k|                                (!Opts.comments)) {
 3249|  3.57k|                     if (ws_size && ws_size < size_t(end - it)) {
  ------------------
  |  Branch (3249:26): [True: 3.36k, False: 212]
  |  Branch (3249:37): [True: 2.55k, False: 811]
  ------------------
 3250|  2.55k|                        skip_matching_ws(ws_start, it, ws_size);
 3251|  2.55k|                     }
 3252|  3.57k|                  }
 3253|       |
 3254|  3.57k|                  if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (3254:23): [True: 0, False: 3.57k]
  ------------------
 3255|      0|                     return;
 3256|      0|                  }
 3257|  3.57k|               }
 3258|       |
 3259|  4.15k|               constexpr auto reflection_type = glaze_object_t<T> || reflectable<T>;
  ------------------
  |  Branch (3259:49): [Folded, False: 0]
  |  Branch (3259:70): [True: 0, Folded]
  ------------------
 3260|       |
 3261|       |               if constexpr (reflection_type && (num_members == 0)) {
 3262|       |                  if constexpr (Opts.error_on_unknown_keys) {
 3263|       |                     static_assert(false_v<T>, "This should be unreachable");
 3264|       |                  }
 3265|       |                  else {
 3266|       |                     if (match_invalid_end<'"', Opts>(ctx, it, end)) {
 3267|       |                        return;
 3268|       |                     }
 3269|       |
 3270|       |                     // parsing to an empty object, but at this point the JSON presents keys
 3271|       |
 3272|       |                     // Unknown key handler does not unescape keys. Unknown escaped keys are
 3273|       |                     // handled by the user.
 3274|       |
 3275|       |                     const auto start = it;
 3276|       |                     skip_string_view(ctx, it, end);
 3277|       |                     if (bool(ctx.error)) [[unlikely]]
 3278|       |                        return;
 3279|       |                     if (validate_utf8_span<Opts>(ctx, start, it)) [[unlikely]]
 3280|       |                        return;
 3281|       |                     const sv key{start, size_t(it - start)};
 3282|       |                     ++it;
 3283|       |                     if constexpr (not Opts.null_terminated) {
 3284|       |                        if (it == end) [[unlikely]] {
 3285|       |                           ctx.error = error_code::unexpected_end;
 3286|       |                           return;
 3287|       |                        }
 3288|       |                     }
 3289|       |
 3290|       |                     if (parse_ws_colon<Opts>(ctx, it, end)) {
 3291|       |                        return;
 3292|       |                     }
 3293|       |
 3294|       |                     // Check if this key is the variant tag that should be skipped
 3295|       |                     if constexpr (not tag.sv().empty()) {
 3296|       |                        if (key == tag.sv()) {
 3297|       |                           // Skip the tag value
 3298|       |                           skip_value<JSON>::op<Opts>(ctx, it, end);
 3299|       |                           if (bool(ctx.error)) [[unlikely]]
 3300|       |                              return;
 3301|       |                           resync_window_end(ctx, end); // a streaming skip refills
 3302|       |                           if (skip_ws<Opts>(ctx, it, end)) {
 3303|       |                              return;
 3304|       |                           }
 3305|       |                           continue;
 3306|       |                        }
 3307|       |                     }
 3308|       |
 3309|       |                     parse<JSON>::handle_unknown<Opts>(key, value, ctx, it, end);
 3310|       |                     if (bool(ctx.error)) [[unlikely]]
 3311|       |                        return;
 3312|       |                     if constexpr (not Opts.null_terminated) {
 3313|       |                        if (it == end) [[unlikely]] {
 3314|       |                           ctx.error = error_code::unexpected_end;
 3315|       |                           return;
 3316|       |                        }
 3317|       |                     }
 3318|       |                     if (skip_ws<Opts>(ctx, it, end)) {
 3319|       |                        return;
 3320|       |                     }
 3321|       |                  }
 3322|       |               }
 3323|  4.15k|               else if constexpr (reflection_type) {
 3324|  4.15k|                  static_assert(bool(hash_info<T>.type));
 3325|       |
 3326|  4.15k|                  if (*it != '"') [[unlikely]] {
  ------------------
  |  Branch (3326:23): [True: 442, False: 3.71k]
  ------------------
 3327|    442|                     ctx.error = error_code::expected_quote;
 3328|    442|                     return;
 3329|    442|                  }
 3330|  3.71k|                  ++it;
 3331|  3.71k|                  if constexpr (not Opts.null_terminated) {
 3332|  3.71k|                     if (it == end) [[unlikely]] {
  ------------------
  |  Branch (3332:26): [True: 0, False: 3.71k]
  ------------------
 3333|      0|                        ctx.error = error_code::unexpected_end;
 3334|      0|                        return;
 3335|      0|                     }
 3336|  3.71k|                  }
 3337|       |
 3338|       |                  if constexpr (not tag.sv().empty() && not contains_tag<T, tag>()) {
 3339|       |                     // For tagged variants we first check to see if the key matches the tag
 3340|       |                     // We only need to do this if the tag is not part of the keys
 3341|       |
 3342|       |                     const auto start = it;
 3343|       |                     skip_string_view(ctx, it, end);
 3344|       |                     if (bool(ctx.error)) [[unlikely]]
 3345|       |                        return;
 3346|       |                     if (validate_utf8_span<Opts>(ctx, start, it)) [[unlikely]]
 3347|       |                        return;
 3348|       |                     const sv key{start, size_t(it - start)};
 3349|       |                     ++it;
 3350|       |                     if constexpr (not Opts.null_terminated) {
 3351|       |                        if (it == end) [[unlikely]] {
 3352|       |                           ctx.error = error_code::unexpected_end;
 3353|       |                           return;
 3354|       |                        }
 3355|       |                     }
 3356|       |
 3357|       |                     if (key == tag.sv()) {
 3358|       |                        if (parse_ws_colon<Opts>(ctx, it, end)) {
 3359|       |                           return;
 3360|       |                        }
 3361|       |
 3362|       |                        parse<JSON>::handle_unknown<Opts>(key, value, ctx, it, end);
 3363|       |                        if (bool(ctx.error)) [[unlikely]]
 3364|       |                           return;
 3365|       |
 3366|       |                        if (skip_ws<Opts>(ctx, it, end)) {
 3367|       |                           return;
 3368|       |                        }
 3369|       |                        continue;
 3370|       |                     }
 3371|       |                     else {
 3372|       |                        it = start; // reset the iterator
 3373|       |                     }
 3374|       |                  }
 3375|       |
 3376|       |                  if constexpr (Opts.error_on_missing_keys || Opts.partial_read) {
 3377|       |                     size_t index = num_members;
 3378|       |                     parse_and_invoke<Opts, T>(value, ctx, it, end, index);
 3379|       |                     if (bool(ctx.error)) [[unlikely]]
 3380|       |                        return;
 3381|       |                     if (index < num_members) {
 3382|       |                        fields[index] = true;
 3383|       |                     }
 3384|       |                  }
 3385|  3.71k|                  else {
 3386|  3.71k|                     parse_and_invoke<Opts, T>(value, ctx, it, end);
 3387|  3.71k|                     if (bool(ctx.error)) [[unlikely]]
  ------------------
  |  Branch (3387:26): [True: 40, False: 3.67k]
  ------------------
 3388|     40|                        return;
 3389|  3.71k|                  }
 3390|       |               }
 3391|       |               else {
 3392|       |                  // For types like std::map, std::unordered_map
 3393|       |
 3394|       |                  auto reading = [&](auto&& key) {
 3395|       |                     if constexpr (Opts.partial_read) {
 3396|       |                        if (auto element = value.find(key); element != value.end()) {
 3397|       |                           ++read_count;
 3398|       |                           parse<JSON>::op<ws_handled<Opts>()>(element->second, ctx, it, end);
 3399|       |                        }
 3400|       |                        else {
 3401|       |                           skip_value<JSON>::op<Opts>(ctx, it, end);
 3402|       |                        }
 3403|       |                     }
 3404|       |                     else {
 3405|       |                        parse<JSON>::op<ws_handled<Opts>()>(value[key], ctx, it, end);
 3406|       |                     }
 3407|       |                  };
 3408|       |
 3409|       |                  // using Key = std::conditional_t<heterogeneous_map<T>, sv, typename T::key_type>;
 3410|       |                  using Key = typename T::key_type;
 3411|       |                  if constexpr (std::is_same_v<Key, std::string>) {
 3412|       |                     ctx.scratch.clear();
 3413|       |                     parse<JSON>::op<Opts>(ctx.scratch, ctx, it, end);
 3414|       |                     if (bool(ctx.error)) [[unlikely]]
 3415|       |                        return;
 3416|       |
 3417|       |                     if (parse_ws_colon<Opts>(ctx, it, end)) {
 3418|       |                        return;
 3419|       |                     }
 3420|       |
 3421|       |                     reading(ctx.scratch);
 3422|       |                     if constexpr (Opts.partial_read) {
 3423|       |                        if (read_count == value.size()) {
 3424|       |                           return;
 3425|       |                        }
 3426|       |                     }
 3427|       |                     if (bool(ctx.error)) [[unlikely]]
 3428|       |                        return;
 3429|       |                  }
 3430|       |                  else if constexpr (str_t<Key>) {
 3431|       |                     Key key;
 3432|       |                     parse<JSON>::op<Opts>(key, ctx, it, end);
 3433|       |                     if (bool(ctx.error)) [[unlikely]]
 3434|       |                        return;
 3435|       |
 3436|       |                     if (parse_ws_colon<Opts>(ctx, it, end)) {
 3437|       |                        return;
 3438|       |                     }
 3439|       |
 3440|       |                     reading(key);
 3441|       |                     if constexpr (Opts.partial_read) {
 3442|       |                        if (read_count == value.size()) {
 3443|       |                           return;
 3444|       |                        }
 3445|       |                     }
 3446|       |                     if (bool(ctx.error)) [[unlikely]]
 3447|       |                        return;
 3448|       |                  }
 3449|       |                  else {
 3450|       |                     Key key_value{};
 3451|       |                     if constexpr (is_named_enum<Key> || mimics_str_t<Key>) {
 3452|       |                        parse<JSON>::op<Opts>(key_value, ctx, it, end);
 3453|       |                     }
 3454|       |                     else if constexpr (std::is_arithmetic_v<Key>) {
 3455|       |                        // prefer over quoted_t below to avoid double parsing of quoted_t
 3456|       |                        parse<JSON>::op<opt_true<Opts, quoted_num_opt_tag{}>>(key_value, ctx, it, end);
 3457|       |                     }
 3458|       |                     else {
 3459|       |                        parse<JSON>::op<opt_false<Opts, raw_string_opt_tag{}>>(quoted_t<Key>{key_value}, ctx, it, end);
 3460|       |                     }
 3461|       |                     if (bool(ctx.error)) [[unlikely]]
 3462|       |                        return;
 3463|       |
 3464|       |                     if (parse_ws_colon<Opts>(ctx, it, end)) {
 3465|       |                        return;
 3466|       |                     }
 3467|       |
 3468|       |                     reading(key_value);
 3469|       |                     if constexpr (Opts.partial_read) {
 3470|       |                        if (read_count == value.size()) {
 3471|       |                           return;
 3472|       |                        }
 3473|       |                     }
 3474|       |                     if (bool(ctx.error)) [[unlikely]]
 3475|       |                        return;
 3476|       |                  }
 3477|       |               }
 3478|       |
 3479|       |               // Streaming refill point: after parsing each key-value pair, refill if buffer is low
 3480|       |               if constexpr (has_streaming_state<decltype(ctx)>) {
 3481|       |                  if (ctx.stream.enabled()) {
 3482|       |                     const size_t consumed = static_cast<size_t>(it - ctx.stream.data());
 3483|       |                     // Refill when less than 25% of buffer remains to ensure enough space for next element
 3484|       |                     if (ctx.stream.size() - consumed <= ctx.stream.size() / 4 || it >= end) {
 3485|       |                        const char* new_it;
 3486|       |                        const char* new_end;
 3487|       |                        ctx.stream.consume_and_refill(consumed, new_it, new_end);
 3488|       |                        it = new_it;
 3489|       |                        end = new_end;
 3490|       |                        if (it >= end && ctx.stream.at_eof()) {
 3491|       |                           ctx.error = error_code::unexpected_end;
 3492|       |                           return;
 3493|       |                        }
 3494|       |                     }
 3495|       |                  }
 3496|       |               }
 3497|       |
 3498|  4.15k|               if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (3498:20): [True: 0, False: 4.15k]
  ------------------
 3499|      0|                  return;
 3500|      0|               }
 3501|  4.15k|            }
 3502|    658|         }
 3503|    658|      }
_ZZN3glz4fromILj10EN12jsonrpc_fuzz5pointEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEETnNS_14string_literalEXtlNS6_ILm1EEEEERS2_TkNS_10is_contextERNS_7contextERPKcSC_EEvOT1_OT2_OT3_T4_ENKUlvE_clEv:
 3148|    623|            decltype(auto) fields = [&]() -> decltype(auto) {
 3149|       |               if constexpr ((glaze_object_t<T> || reflectable<T>) &&
 3150|       |                             (Opts.error_on_missing_keys || Opts.partial_read)) {
 3151|       |                  return bit_array<num_members>{};
 3152|       |               }
 3153|    623|               else {
 3154|    623|                  return nullptr;
 3155|    623|               }
 3156|    623|            }();
_ZZN3glz16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT3_OT4_OT5_DpOT2_ENKUlTnmvE_clILm3EEEDav:
  484|    837|            visit<N>([&]<size_t I>() { decode_index<Opts, T, I>(value, ctx, it, end, selected_index...); }, index);
_ZN3glz12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiELm3ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT2_OT4_OT5_OT6_DpOT3_:
  311|    837|   {
  312|    837|      static constexpr auto Key = get<I>(reflect<T>::keys);
  313|    837|      static constexpr auto KeyWithEndQuote = join_v<Key, chars<"\"">>;
  314|    837|      static constexpr auto Length = KeyWithEndQuote.size();
  315|       |
  316|    837|      if (((it + Length) < end) && comparitor<KeyWithEndQuote>(it)) [[likely]] {
  ------------------
  |  Branch (316:11): [True: 834, False: 3]
  |  Branch (316:36): [True: 829, False: 5]
  ------------------
  317|    829|         it += Length;
  318|    829|         if constexpr (not Opts.null_terminated) {
  319|    829|            if (it == end) [[unlikely]] {
  ------------------
  |  Branch (319:17): [True: 0, False: 829]
  ------------------
  320|      0|               ctx.error = error_code::unexpected_end;
  321|      0|               return;
  322|      0|            }
  323|    829|         }
  324|       |
  325|    829|         if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (325:14): [True: 0, False: 829]
  ------------------
  326|      0|            return;
  327|      0|         }
  328|    829|         if (match_invalid_end<':', Opts>(ctx, it, end)) {
  ------------------
  |  Branch (328:14): [True: 34, False: 795]
  ------------------
  329|     34|            return;
  330|     34|         }
  331|    795|         if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (331:14): [True: 0, False: 795]
  ------------------
  332|      0|            return;
  333|      0|         }
  334|       |
  335|       |         // The hash path has already consumed the whitespace before the value
  336|    795|         decode_field_value<Opts, ws_handled<Opts>(), T, I>(value, ctx, it, end, selected_index...);
  337|    795|      }
  338|      8|      else [[unlikely]] {
  339|      8|         decode_index_unknown_key<Opts, T>(value, ctx, it, end);
  340|      8|      }
  341|    837|   }
_ZN3glz18decode_field_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnDaXtlS1_Lj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEEN12jsonrpc_fuzz8fuzz_apiELm3ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT1_E11reflectableISA_EEEvOT3_OT5_OT6_OT7_DpOT4_:
  245|    795|   {
  246|       |      // Check for null value skipping on read
  247|       |      if constexpr (check_skip_null_members_on_read(Opts)) {
  248|       |         if (*it == 'n') {
  249|       |            ++it;
  250|       |            if constexpr (not Opts.null_terminated) {
  251|       |               if (it == end) [[unlikely]] {
  252|       |                  ctx.error = error_code::unexpected_end;
  253|       |                  return;
  254|       |               }
  255|       |            }
  256|       |            match<"ull", Opts>(ctx, it, end);
  257|       |            if (bool(ctx.error)) [[unlikely]]
  258|       |               return;
  259|       |            // Successfully matched "null", skip it
  260|       |            if constexpr (Opts.error_on_missing_keys || Opts.partial_read) {
  261|       |               ((selected_index = I), ...); // Mark as handled even if skipped
  262|       |            }
  263|       |            return;
  264|       |         }
  265|       |      }
  266|       |
  267|       |      if constexpr (skipped_by_meta<T, I, operation::parse>) {
  268|       |         skip_value<JSON>::op<Opts>(ctx, it, end);
  269|       |         if (bool(ctx.error)) [[unlikely]]
  270|       |            return; // Propagate error from skip_value
  271|       |      }
  272|    795|      else {
  273|    795|         using V = refl_t<T, I>;
  274|       |
  275|       |         if constexpr (const_value_v<V>) {
  276|       |            if constexpr (check_error_on_const_read(Opts)) {
  277|       |               ctx.error = error_code::attempt_const_read;
  278|       |            }
  279|       |            else {
  280|       |               // do not read anything into the const value
  281|       |               skip_value<JSON>::op<Opts>(ctx, it, end);
  282|       |            }
  283|       |         }
  284|       |         else if constexpr (is_function_ptr_or_ref<V>) {
  285|       |            // Function pointers cannot be deserialized from JSON.
  286|       |            // When write_function_pointers is enabled the writer emits a type-name string,
  287|       |            // but there is nothing meaningful to reconstruct on read — just skip the value.
  288|       |            // When write_function_pointers is off the key is never written, so this branch
  289|       |            // is unreachable in that case.
  290|       |            skip_value<JSON>::op<Opts>(ctx, it, end);
  291|       |         }
  292|       |         else if constexpr (glaze_object_t<T>) {
  293|       |            from<JSON, std::remove_cvref_t<V>>::template op<FieldOpts>(get_member(value, get<I>(reflect<T>::values)),
  294|       |                                                                       ctx, it, end);
  295|       |         }
  296|    795|         else {
  297|    795|            from<JSON, std::remove_cvref_t<V>>::template op<FieldOpts>(get_member(value, get<I>(to_tie(value))), ctx,
  298|    795|                                                                       it, end);
  299|    795|         }
  300|    795|      }
  301|       |
  302|       |      // The key was present and handled, even when the value itself was skipped
  303|       |      if constexpr (Opts.error_on_missing_keys || Opts.partial_read) {
  304|       |         ((selected_index = I), ...);
  305|       |      }
  306|    795|   }
_ZN3glz4fromILj10EN12jsonrpc_fuzz6nestedEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEETnNS_14string_literalEXtlNS6_ILm1EEEEERS2_TkNS_10is_contextERNS_7contextERPKcSC_EEvOT1_OT2_OT3_T4_:
 3044|    795|      {
 3045|    795|         static constexpr auto num_members = reflect<T>::size;
 3046|       |
 3047|    795|         static constexpr auto Opts = opening_handled_off<ws_handled_off<Options>()>();
 3048|    795|         if constexpr (!check_opening_handled(Options)) {
 3049|       |            if constexpr (!check_ws_handled(Options)) {
 3050|       |               if (skip_ws<Opts>(ctx, it, end)) {
 3051|       |                  return;
 3052|       |               }
 3053|       |            }
 3054|    795|            if (match_invalid_end<'{', Opts>(ctx, it, end)) {
  ------------------
  |  Branch (3054:17): [True: 30, False: 765]
  ------------------
 3055|     30|               return;
 3056|     30|            }
 3057|    765|            if constexpr (not Opts.null_terminated) {
 3058|    765|               if (it == end) [[unlikely]] {
  ------------------
  |  Branch (3058:20): [True: 0, False: 765]
  ------------------
 3059|      0|                  ctx.error = error_code::unexpected_end;
 3060|      0|                  return;
 3061|      0|               }
 3062|    765|            }
 3063|       |            // one nesting level (see enter_depth): counted in both modes so the limit binds,
 3064|       |            // released at each syntactic close below
 3065|    765|            if (enter_depth(ctx)) [[unlikely]] {
  ------------------
  |  Branch (3065:17): [True: 0, False: 765]
  ------------------
 3066|      0|               return;
 3067|      0|            }
 3068|    765|         }
 3069|    765|         const auto ws_start = it;
 3070|    795|         if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (3070:14): [True: 0, False: 795]
  ------------------
 3071|      0|            return;
 3072|      0|         }
 3073|    795|         const size_t ws_size = size_t(it - ws_start);
 3074|       |
 3075|       |         if constexpr ((glaze_object_t<T> || reflectable<T>) && num_members == 0 && Opts.error_on_unknown_keys) {
 3076|       |            if constexpr (not tag.sv().empty()) {
 3077|       |               if (*it == '"') {
 3078|       |                  ++it;
 3079|       |                  if constexpr (not Opts.null_terminated) {
 3080|       |                     if (it == end) [[unlikely]] {
 3081|       |                        ctx.error = error_code::unexpected_end;
 3082|       |                        return;
 3083|       |                     }
 3084|       |                  }
 3085|       |
 3086|       |                  const auto start = it;
 3087|       |                  skip_string_view(ctx, it, end);
 3088|       |                  if (bool(ctx.error)) [[unlikely]]
 3089|       |                     return;
 3090|       |                  if (validate_utf8_span<Opts>(ctx, start, it)) [[unlikely]]
 3091|       |                     return;
 3092|       |                  const sv key{start, size_t(it - start)};
 3093|       |                  ++it;
 3094|       |                  if constexpr (not Opts.null_terminated) {
 3095|       |                     if (it == end) [[unlikely]] {
 3096|       |                        ctx.error = error_code::unexpected_end;
 3097|       |                        return;
 3098|       |                     }
 3099|       |                  }
 3100|       |
 3101|       |                  if (key == tag.sv()) {
 3102|       |                     if (parse_ws_colon<Opts>(ctx, it, end)) {
 3103|       |                        return;
 3104|       |                     }
 3105|       |
 3106|       |                     parse<JSON>::handle_unknown<Opts>(key, value, ctx, it, end);
 3107|       |                     if (bool(ctx.error)) [[unlikely]]
 3108|       |                        return;
 3109|       |
 3110|       |                     if (skip_ws<Opts>(ctx, it, end)) {
 3111|       |                        return;
 3112|       |                     }
 3113|       |                  }
 3114|       |                  else {
 3115|       |                     ctx.error = error_code::unknown_key;
 3116|       |                     return;
 3117|       |                  }
 3118|       |               }
 3119|       |            }
 3120|       |
 3121|       |            if (*it == '}') [[likely]] {
 3122|       |               --ctx.depth;
 3123|       |               if constexpr (glaze_object_t<T> || reflectable<T>) {
 3124|       |                  if constexpr (has_self_constraint_v<T> && !check_skip_self_constraint(Opts)) {
 3125|       |                     auto wrapper = self_constraint_v<T>(value);
 3126|       |                     from<JSON, decltype(wrapper)>::template op<ws_handled<Opts>()>(wrapper, ctx, it, end);
 3127|       |                     if (bool(ctx.error)) {
 3128|       |                        return;
 3129|       |                     }
 3130|       |                  }
 3131|       |               }
 3132|       |               ++it;
 3133|       |               if constexpr (not Opts.null_terminated) {
 3134|       |                  if (it == end) {
 3135|       |                     ctx.error = error_code::end_reached;
 3136|       |                     return;
 3137|       |                  }
 3138|       |               }
 3139|       |               if constexpr (Opts.partial_read) {
 3140|       |                  ctx.error = error_code::partial_read_complete;
 3141|       |               }
 3142|       |               return;
 3143|       |            }
 3144|       |            ctx.error = error_code::unknown_key;
 3145|       |            return;
 3146|       |         }
 3147|    795|         else {
 3148|    795|            decltype(auto) fields = [&]() -> decltype(auto) {
 3149|    795|               if constexpr ((glaze_object_t<T> || reflectable<T>) &&
 3150|    795|                             (Opts.error_on_missing_keys || Opts.partial_read)) {
 3151|    795|                  return bit_array<num_members>{};
 3152|    795|               }
 3153|    795|               else {
 3154|    795|                  return nullptr;
 3155|    795|               }
 3156|    795|            }();
 3157|       |
 3158|    795|            size_t read_count{}; // for partial_read
 3159|       |
 3160|    795|            bool first = true;
 3161|  4.77k|            while (true) {
  ------------------
  |  Branch (3161:20): [True: 4.04k, Folded]
  ------------------
 3162|       |               if constexpr ((glaze_object_t<T> || reflectable<T>) && Opts.partial_read) {
 3163|       |                  static constexpr bit_array<num_members> all_fields = [] {
 3164|       |                     bit_array<num_members> arr{};
 3165|       |                     for (size_t i = 0; i < num_members; ++i) {
 3166|       |                        arr[i] = true;
 3167|       |                     }
 3168|       |                     return arr;
 3169|       |                  }();
 3170|       |
 3171|       |                  if ((all_fields & fields) == all_fields) {
 3172|       |                     ctx.error = error_code::partial_read_complete;
 3173|       |                     --ctx.depth; // as above: an early success still closes this level
 3174|       |                     return;
 3175|       |                  }
 3176|       |               }
 3177|       |
 3178|       |               // Streaming refill point: at start of each iteration, ensure buffer has data
 3179|       |               if constexpr (has_streaming_state<decltype(ctx)>) {
 3180|       |                  if (ctx.stream.enabled()) {
 3181|       |                     const size_t consumed = static_cast<size_t>(it - ctx.stream.data());
 3182|       |                     const size_t remaining = ctx.stream.size() - consumed;
 3183|       |                     // Refill when less than half of buffer remains to ensure space for next key-value pair
 3184|       |                     if (remaining <= ctx.stream.size() / 2 || it >= end) {
 3185|       |                        const char* new_it;
 3186|       |                        const char* new_end;
 3187|       |                        ctx.stream.consume_and_refill(consumed, new_it, new_end);
 3188|       |                        it = new_it;
 3189|       |                        end = new_end;
 3190|       |                        if (it >= end && ctx.stream.at_eof()) {
 3191|       |                           ctx.error = error_code::unexpected_end;
 3192|       |                           return;
 3193|       |                        }
 3194|       |                     }
 3195|       |                  }
 3196|       |               }
 3197|       |
 3198|  4.04k|               if (*it == '}') {
  ------------------
  |  Branch (3198:20): [True: 57, False: 3.98k]
  ------------------
 3199|     57|                  --ctx.depth;
 3200|       |                  if constexpr ((glaze_object_t<T> || reflectable<T>) && Opts.error_on_missing_keys) {
 3201|       |                     constexpr auto req_fields = required_fields<T, Opts>();
 3202|       |                     if ((req_fields & fields) != req_fields) {
 3203|       |                        for (size_t i = 0; i < num_members; ++i) {
 3204|       |                           if (not fields[i] && req_fields[i]) {
 3205|       |                              ctx.custom_error_message = reflect<T>::keys[i];
 3206|       |                              // We just return the first missing key in order to avoid heap allocations
 3207|       |                              break;
 3208|       |                           }
 3209|       |                        }
 3210|       |
 3211|       |                        ctx.error = error_code::missing_key;
 3212|       |                        return;
 3213|       |                     }
 3214|       |                  }
 3215|     57|                  if constexpr (glaze_object_t<T> || reflectable<T>) {
 3216|       |                     if constexpr (has_self_constraint_v<T> && !check_skip_self_constraint(Opts)) {
 3217|       |                        auto wrapper = self_constraint_v<T>(value);
 3218|       |                        from<JSON, decltype(wrapper)>::template op<ws_handled<Opts>()>(wrapper, ctx, it, end);
 3219|       |                        if (bool(ctx.error)) {
 3220|       |                           return;
 3221|       |                        }
 3222|       |                     }
 3223|     57|                  }
 3224|     57|                  ++it; // Increment after checking for missing keys so errors are within buffer bounds
 3225|     57|                  if constexpr (not Opts.null_terminated) {
 3226|     57|                     if (it == end) {
  ------------------
  |  Branch (3226:26): [True: 0, False: 57]
  ------------------
 3227|      0|                        ctx.error = error_code::end_reached;
 3228|      0|                        return;
 3229|      0|                     }
 3230|     57|                  }
 3231|     57|                  return;
 3232|     57|               }
 3233|  3.98k|               else if (first) {
  ------------------
  |  Branch (3233:25): [True: 723, False: 3.26k]
  ------------------
 3234|    723|                  first = false;
 3235|    723|               }
 3236|  3.26k|               else {
 3237|  3.26k|                  if (match_invalid_end<',', Opts>(ctx, it, end)) {
  ------------------
  |  Branch (3237:23): [True: 10, False: 3.25k]
  ------------------
 3238|     10|                     return;
 3239|     10|                  }
 3240|  3.25k|                  if constexpr (not Opts.null_terminated) {
 3241|  3.25k|                     if (it == end) [[unlikely]] {
  ------------------
  |  Branch (3241:26): [True: 0, False: 3.25k]
  ------------------
 3242|      0|                        ctx.error = error_code::unexpected_end;
 3243|      0|                        return;
 3244|      0|                     }
 3245|  3.25k|                  }
 3246|       |
 3247|       |                  if constexpr ((not Opts.minified) && (num_members > 1 || not Opts.error_on_unknown_keys) &&
 3248|  3.25k|                                (!Opts.comments)) {
 3249|  3.25k|                     if (ws_size && ws_size < size_t(end - it)) {
  ------------------
  |  Branch (3249:26): [True: 2.63k, False: 615]
  |  Branch (3249:37): [True: 2.52k, False: 113]
  ------------------
 3250|  2.52k|                        skip_matching_ws(ws_start, it, ws_size);
 3251|  2.52k|                     }
 3252|  3.25k|                  }
 3253|       |
 3254|  3.25k|                  if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (3254:23): [True: 0, False: 3.25k]
  ------------------
 3255|      0|                     return;
 3256|      0|                  }
 3257|  3.25k|               }
 3258|       |
 3259|  3.97k|               constexpr auto reflection_type = glaze_object_t<T> || reflectable<T>;
  ------------------
  |  Branch (3259:49): [Folded, False: 0]
  |  Branch (3259:70): [True: 0, Folded]
  ------------------
 3260|       |
 3261|       |               if constexpr (reflection_type && (num_members == 0)) {
 3262|       |                  if constexpr (Opts.error_on_unknown_keys) {
 3263|       |                     static_assert(false_v<T>, "This should be unreachable");
 3264|       |                  }
 3265|       |                  else {
 3266|       |                     if (match_invalid_end<'"', Opts>(ctx, it, end)) {
 3267|       |                        return;
 3268|       |                     }
 3269|       |
 3270|       |                     // parsing to an empty object, but at this point the JSON presents keys
 3271|       |
 3272|       |                     // Unknown key handler does not unescape keys. Unknown escaped keys are
 3273|       |                     // handled by the user.
 3274|       |
 3275|       |                     const auto start = it;
 3276|       |                     skip_string_view(ctx, it, end);
 3277|       |                     if (bool(ctx.error)) [[unlikely]]
 3278|       |                        return;
 3279|       |                     if (validate_utf8_span<Opts>(ctx, start, it)) [[unlikely]]
 3280|       |                        return;
 3281|       |                     const sv key{start, size_t(it - start)};
 3282|       |                     ++it;
 3283|       |                     if constexpr (not Opts.null_terminated) {
 3284|       |                        if (it == end) [[unlikely]] {
 3285|       |                           ctx.error = error_code::unexpected_end;
 3286|       |                           return;
 3287|       |                        }
 3288|       |                     }
 3289|       |
 3290|       |                     if (parse_ws_colon<Opts>(ctx, it, end)) {
 3291|       |                        return;
 3292|       |                     }
 3293|       |
 3294|       |                     // Check if this key is the variant tag that should be skipped
 3295|       |                     if constexpr (not tag.sv().empty()) {
 3296|       |                        if (key == tag.sv()) {
 3297|       |                           // Skip the tag value
 3298|       |                           skip_value<JSON>::op<Opts>(ctx, it, end);
 3299|       |                           if (bool(ctx.error)) [[unlikely]]
 3300|       |                              return;
 3301|       |                           resync_window_end(ctx, end); // a streaming skip refills
 3302|       |                           if (skip_ws<Opts>(ctx, it, end)) {
 3303|       |                              return;
 3304|       |                           }
 3305|       |                           continue;
 3306|       |                        }
 3307|       |                     }
 3308|       |
 3309|       |                     parse<JSON>::handle_unknown<Opts>(key, value, ctx, it, end);
 3310|       |                     if (bool(ctx.error)) [[unlikely]]
 3311|       |                        return;
 3312|       |                     if constexpr (not Opts.null_terminated) {
 3313|       |                        if (it == end) [[unlikely]] {
 3314|       |                           ctx.error = error_code::unexpected_end;
 3315|       |                           return;
 3316|       |                        }
 3317|       |                     }
 3318|       |                     if (skip_ws<Opts>(ctx, it, end)) {
 3319|       |                        return;
 3320|       |                     }
 3321|       |                  }
 3322|       |               }
 3323|  3.97k|               else if constexpr (reflection_type) {
 3324|  3.97k|                  static_assert(bool(hash_info<T>.type));
 3325|       |
 3326|  3.97k|                  if (*it != '"') [[unlikely]] {
  ------------------
  |  Branch (3326:23): [True: 607, False: 3.37k]
  ------------------
 3327|    607|                     ctx.error = error_code::expected_quote;
 3328|    607|                     return;
 3329|    607|                  }
 3330|  3.37k|                  ++it;
 3331|  3.37k|                  if constexpr (not Opts.null_terminated) {
 3332|  3.37k|                     if (it == end) [[unlikely]] {
  ------------------
  |  Branch (3332:26): [True: 0, False: 3.37k]
  ------------------
 3333|      0|                        ctx.error = error_code::unexpected_end;
 3334|      0|                        return;
 3335|      0|                     }
 3336|  3.37k|                  }
 3337|       |
 3338|       |                  if constexpr (not tag.sv().empty() && not contains_tag<T, tag>()) {
 3339|       |                     // For tagged variants we first check to see if the key matches the tag
 3340|       |                     // We only need to do this if the tag is not part of the keys
 3341|       |
 3342|       |                     const auto start = it;
 3343|       |                     skip_string_view(ctx, it, end);
 3344|       |                     if (bool(ctx.error)) [[unlikely]]
 3345|       |                        return;
 3346|       |                     if (validate_utf8_span<Opts>(ctx, start, it)) [[unlikely]]
 3347|       |                        return;
 3348|       |                     const sv key{start, size_t(it - start)};
 3349|       |                     ++it;
 3350|       |                     if constexpr (not Opts.null_terminated) {
 3351|       |                        if (it == end) [[unlikely]] {
 3352|       |                           ctx.error = error_code::unexpected_end;
 3353|       |                           return;
 3354|       |                        }
 3355|       |                     }
 3356|       |
 3357|       |                     if (key == tag.sv()) {
 3358|       |                        if (parse_ws_colon<Opts>(ctx, it, end)) {
 3359|       |                           return;
 3360|       |                        }
 3361|       |
 3362|       |                        parse<JSON>::handle_unknown<Opts>(key, value, ctx, it, end);
 3363|       |                        if (bool(ctx.error)) [[unlikely]]
 3364|       |                           return;
 3365|       |
 3366|       |                        if (skip_ws<Opts>(ctx, it, end)) {
 3367|       |                           return;
 3368|       |                        }
 3369|       |                        continue;
 3370|       |                     }
 3371|       |                     else {
 3372|       |                        it = start; // reset the iterator
 3373|       |                     }
 3374|       |                  }
 3375|       |
 3376|       |                  if constexpr (Opts.error_on_missing_keys || Opts.partial_read) {
 3377|       |                     size_t index = num_members;
 3378|       |                     parse_and_invoke<Opts, T>(value, ctx, it, end, index);
 3379|       |                     if (bool(ctx.error)) [[unlikely]]
 3380|       |                        return;
 3381|       |                     if (index < num_members) {
 3382|       |                        fields[index] = true;
 3383|       |                     }
 3384|       |                  }
 3385|  3.37k|                  else {
 3386|  3.37k|                     parse_and_invoke<Opts, T>(value, ctx, it, end);
 3387|  3.37k|                     if (bool(ctx.error)) [[unlikely]]
  ------------------
  |  Branch (3387:26): [True: 91, False: 3.27k]
  ------------------
 3388|     91|                        return;
 3389|  3.37k|                  }
 3390|       |               }
 3391|       |               else {
 3392|       |                  // For types like std::map, std::unordered_map
 3393|       |
 3394|       |                  auto reading = [&](auto&& key) {
 3395|       |                     if constexpr (Opts.partial_read) {
 3396|       |                        if (auto element = value.find(key); element != value.end()) {
 3397|       |                           ++read_count;
 3398|       |                           parse<JSON>::op<ws_handled<Opts>()>(element->second, ctx, it, end);
 3399|       |                        }
 3400|       |                        else {
 3401|       |                           skip_value<JSON>::op<Opts>(ctx, it, end);
 3402|       |                        }
 3403|       |                     }
 3404|       |                     else {
 3405|       |                        parse<JSON>::op<ws_handled<Opts>()>(value[key], ctx, it, end);
 3406|       |                     }
 3407|       |                  };
 3408|       |
 3409|       |                  // using Key = std::conditional_t<heterogeneous_map<T>, sv, typename T::key_type>;
 3410|       |                  using Key = typename T::key_type;
 3411|       |                  if constexpr (std::is_same_v<Key, std::string>) {
 3412|       |                     ctx.scratch.clear();
 3413|       |                     parse<JSON>::op<Opts>(ctx.scratch, ctx, it, end);
 3414|       |                     if (bool(ctx.error)) [[unlikely]]
 3415|       |                        return;
 3416|       |
 3417|       |                     if (parse_ws_colon<Opts>(ctx, it, end)) {
 3418|       |                        return;
 3419|       |                     }
 3420|       |
 3421|       |                     reading(ctx.scratch);
 3422|       |                     if constexpr (Opts.partial_read) {
 3423|       |                        if (read_count == value.size()) {
 3424|       |                           return;
 3425|       |                        }
 3426|       |                     }
 3427|       |                     if (bool(ctx.error)) [[unlikely]]
 3428|       |                        return;
 3429|       |                  }
 3430|       |                  else if constexpr (str_t<Key>) {
 3431|       |                     Key key;
 3432|       |                     parse<JSON>::op<Opts>(key, ctx, it, end);
 3433|       |                     if (bool(ctx.error)) [[unlikely]]
 3434|       |                        return;
 3435|       |
 3436|       |                     if (parse_ws_colon<Opts>(ctx, it, end)) {
 3437|       |                        return;
 3438|       |                     }
 3439|       |
 3440|       |                     reading(key);
 3441|       |                     if constexpr (Opts.partial_read) {
 3442|       |                        if (read_count == value.size()) {
 3443|       |                           return;
 3444|       |                        }
 3445|       |                     }
 3446|       |                     if (bool(ctx.error)) [[unlikely]]
 3447|       |                        return;
 3448|       |                  }
 3449|       |                  else {
 3450|       |                     Key key_value{};
 3451|       |                     if constexpr (is_named_enum<Key> || mimics_str_t<Key>) {
 3452|       |                        parse<JSON>::op<Opts>(key_value, ctx, it, end);
 3453|       |                     }
 3454|       |                     else if constexpr (std::is_arithmetic_v<Key>) {
 3455|       |                        // prefer over quoted_t below to avoid double parsing of quoted_t
 3456|       |                        parse<JSON>::op<opt_true<Opts, quoted_num_opt_tag{}>>(key_value, ctx, it, end);
 3457|       |                     }
 3458|       |                     else {
 3459|       |                        parse<JSON>::op<opt_false<Opts, raw_string_opt_tag{}>>(quoted_t<Key>{key_value}, ctx, it, end);
 3460|       |                     }
 3461|       |                     if (bool(ctx.error)) [[unlikely]]
 3462|       |                        return;
 3463|       |
 3464|       |                     if (parse_ws_colon<Opts>(ctx, it, end)) {
 3465|       |                        return;
 3466|       |                     }
 3467|       |
 3468|       |                     reading(key_value);
 3469|       |                     if constexpr (Opts.partial_read) {
 3470|       |                        if (read_count == value.size()) {
 3471|       |                           return;
 3472|       |                        }
 3473|       |                     }
 3474|       |                     if (bool(ctx.error)) [[unlikely]]
 3475|       |                        return;
 3476|       |                  }
 3477|       |               }
 3478|       |
 3479|       |               // Streaming refill point: after parsing each key-value pair, refill if buffer is low
 3480|       |               if constexpr (has_streaming_state<decltype(ctx)>) {
 3481|       |                  if (ctx.stream.enabled()) {
 3482|       |                     const size_t consumed = static_cast<size_t>(it - ctx.stream.data());
 3483|       |                     // Refill when less than 25% of buffer remains to ensure enough space for next element
 3484|       |                     if (ctx.stream.size() - consumed <= ctx.stream.size() / 4 || it >= end) {
 3485|       |                        const char* new_it;
 3486|       |                        const char* new_end;
 3487|       |                        ctx.stream.consume_and_refill(consumed, new_it, new_end);
 3488|       |                        it = new_it;
 3489|       |                        end = new_end;
 3490|       |                        if (it >= end && ctx.stream.at_eof()) {
 3491|       |                           ctx.error = error_code::unexpected_end;
 3492|       |                           return;
 3493|       |                        }
 3494|       |                     }
 3495|       |                  }
 3496|       |               }
 3497|       |
 3498|  3.97k|               if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (3498:20): [True: 0, False: 3.97k]
  ------------------
 3499|      0|                  return;
 3500|      0|               }
 3501|  3.97k|            }
 3502|    795|         }
 3503|    795|      }
_ZZN3glz4fromILj10EN12jsonrpc_fuzz6nestedEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEETnNS_14string_literalEXtlNS6_ILm1EEEEERS2_TkNS_10is_contextERNS_7contextERPKcSC_EEvOT1_OT2_OT3_T4_ENKUlvE_clEv:
 3148|    765|            decltype(auto) fields = [&]() -> decltype(auto) {
 3149|       |               if constexpr ((glaze_object_t<T> || reflectable<T>) &&
 3150|       |                             (Opts.error_on_missing_keys || Opts.partial_read)) {
 3151|       |                  return bit_array<num_members>{};
 3152|       |               }
 3153|    765|               else {
 3154|    765|                  return nullptr;
 3155|    765|               }
 3156|    765|            }();
_ZN3glz16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz6nestedERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT3_OT4_OT5_DpOT2_:
  376|  13.1k|   {
  377|  13.1k|      constexpr auto N = reflect<T>::size;
  378|       |
  379|       |      if constexpr (N == 1) {
  380|       |         decode_index<Opts, T, 0>(value, ctx, it, end, selected_index...);
  381|       |      }
  382|       |      else if constexpr (check_linear_search(Opts)) {
  383|       |         // Linear search path
  384|       |         auto key_start = it;
  385|       |         const auto index = decode_linear<T>(ctx, it, end);
  386|       |         if (bool(ctx.error)) [[unlikely]]
  387|       |            return;
  388|       |
  389|       |         if (index >= N) [[unlikely]] {
  390|       |            if constexpr (Opts.error_on_unknown_keys) {
  391|       |               ctx.error = error_code::unknown_key;
  392|       |               return;
  393|       |            }
  394|       |            else {
  395|       |               // it sits one past the closing quote, so the raw key spans [key_start, it - 1)
  396|       |               if (validate_utf8_span<Opts>(ctx, key_start, it - 1)) [[unlikely]] {
  397|       |                  return;
  398|       |               }
  399|       |               const sv key{key_start, size_t(it - key_start - 1)};
  400|       |               if constexpr (not Opts.null_terminated) {
  401|       |                  if (it == end) [[unlikely]] {
  402|       |                     ctx.error = error_code::unexpected_end;
  403|       |                     return;
  404|       |                  }
  405|       |               }
  406|       |               if (parse_ws_colon<Opts>(ctx, it, end)) {
  407|       |                  return;
  408|       |               }
  409|       |               parse<JSON>::handle_unknown<Opts>(key, value, ctx, it, end);
  410|       |               return;
  411|       |            }
  412|       |         }
  413|       |
  414|       |         if constexpr (not Opts.null_terminated) {
  415|       |            if (it == end) [[unlikely]] {
  416|       |               ctx.error = error_code::unexpected_end;
  417|       |               return;
  418|       |            }
  419|       |         }
  420|       |         if (skip_ws<Opts>(ctx, it, end)) {
  421|       |            return;
  422|       |         }
  423|       |         if (match_invalid_end<':', Opts>(ctx, it, end)) {
  424|       |            return;
  425|       |         }
  426|       |         if (skip_ws<Opts>(ctx, it, end)) {
  427|       |            return;
  428|       |         }
  429|       |
  430|       |         // Fold expression dispatch - avoids jump table overhead for smaller binary size.
  431|       |         // For linear_search, pass Opts through to the field parser to avoid duplicate template
  432|       |         // instantiations; the whitespace before the value has already been skipped either way.
  433|       |         [&]<size_t... Is>(std::index_sequence<Is...>) {
  434|       |            (void)(((index == Is ? (decode_field_value<Opts, Opts, T, Is>(value, ctx, it, end, selected_index...), true)
  435|       |                                 : false) ||
  436|       |                    ...));
  437|       |         }(std::make_index_sequence<N>{});
  438|       |      }
  439|  13.1k|      else {
  440|       |         // Hash-based lookup
  441|  13.1k|         constexpr auto& HashInfo = hash_info<T>;
  442|  13.1k|         constexpr auto type = HashInfo.type;
  443|  13.1k|         static_assert(bool(type), "invalid hash algorithm");
  444|       |
  445|  13.1k|         const auto index = decode_hash<JSON, T, HashInfo, HashInfo.type>::op(it, end);
  446|       |
  447|  13.1k|         if (index >= N) [[unlikely]] {
  ------------------
  |  Branch (447:14): [True: 0, False: 13.1k]
  ------------------
  448|      0|            if constexpr (Opts.error_on_unknown_keys) {
  449|      0|               ctx.error = error_code::unknown_key;
  450|      0|               return;
  451|       |            }
  452|       |            else {
  453|       |               auto start = it;
  454|       |               skip_string_view(ctx, it, end);
  455|       |               if (bool(ctx.error)) [[unlikely]]
  456|       |                  return;
  457|       |               if (validate_utf8_span<Opts>(ctx, start, it)) [[unlikely]]
  458|       |                  return;
  459|       |               const sv key = {start, size_t(it - start)};
  460|       |               ++it; // skip the quote
  461|       |               if constexpr (not Opts.null_terminated) {
  462|       |                  if (it == end) [[unlikely]] {
  463|       |                     ctx.error = error_code::unexpected_end;
  464|       |                     return;
  465|       |                  }
  466|       |               }
  467|       |               if (parse_ws_colon<Opts>(ctx, it, end)) {
  468|       |                  return;
  469|       |               }
  470|       |               parse<JSON>::handle_unknown<Opts>(key, value, ctx, it, end);
  471|       |               return;
  472|       |            }
  473|      0|         }
  474|       |
  475|  13.1k|         if constexpr (N == 2) {
  476|  13.1k|            if (index == 0) {
  ------------------
  |  Branch (476:17): [True: 12.5k, False: 615]
  ------------------
  477|  12.5k|               decode_index<Opts, T, 0>(value, ctx, it, end, selected_index...);
  478|  12.5k|            }
  479|    615|            else {
  480|    615|               decode_index<Opts, T, 1>(value, ctx, it, end, selected_index...);
  481|    615|            }
  482|       |         }
  483|       |         else {
  484|       |            visit<N>([&]<size_t I>() { decode_index<Opts, T, I>(value, ctx, it, end, selected_index...); }, index);
  485|       |         }
  486|  13.1k|      }
  487|  13.1k|   }
_ZN3glz12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz6nestedELm0ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT2_OT4_OT5_OT6_DpOT3_:
  311|  12.5k|   {
  312|  12.5k|      static constexpr auto Key = get<I>(reflect<T>::keys);
  313|  12.5k|      static constexpr auto KeyWithEndQuote = join_v<Key, chars<"\"">>;
  314|  12.5k|      static constexpr auto Length = KeyWithEndQuote.size();
  315|       |
  316|  12.5k|      if (((it + Length) < end) && comparitor<KeyWithEndQuote>(it)) [[likely]] {
  ------------------
  |  Branch (316:11): [True: 12.5k, False: 12]
  |  Branch (316:36): [True: 12.5k, False: 21]
  ------------------
  317|  12.5k|         it += Length;
  318|  12.5k|         if constexpr (not Opts.null_terminated) {
  319|  12.5k|            if (it == end) [[unlikely]] {
  ------------------
  |  Branch (319:17): [True: 0, False: 12.5k]
  ------------------
  320|      0|               ctx.error = error_code::unexpected_end;
  321|      0|               return;
  322|      0|            }
  323|  12.5k|         }
  324|       |
  325|  12.5k|         if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (325:14): [True: 0, False: 12.5k]
  ------------------
  326|      0|            return;
  327|      0|         }
  328|  12.5k|         if (match_invalid_end<':', Opts>(ctx, it, end)) {
  ------------------
  |  Branch (328:14): [True: 32, False: 12.4k]
  ------------------
  329|     32|            return;
  330|     32|         }
  331|  12.4k|         if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (331:14): [True: 0, False: 12.4k]
  ------------------
  332|      0|            return;
  333|      0|         }
  334|       |
  335|       |         // The hash path has already consumed the whitespace before the value
  336|  12.4k|         decode_field_value<Opts, ws_handled<Opts>(), T, I>(value, ctx, it, end, selected_index...);
  337|  12.4k|      }
  338|     33|      else [[unlikely]] {
  339|     33|         decode_index_unknown_key<Opts, T>(value, ctx, it, end);
  340|     33|      }
  341|  12.5k|   }
_ZN3glz18decode_field_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnDaXtlS1_Lj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEEN12jsonrpc_fuzz6nestedELm0ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT1_E11reflectableISA_EEEvOT3_OT5_OT6_OT7_DpOT4_:
  245|  12.4k|   {
  246|       |      // Check for null value skipping on read
  247|       |      if constexpr (check_skip_null_members_on_read(Opts)) {
  248|       |         if (*it == 'n') {
  249|       |            ++it;
  250|       |            if constexpr (not Opts.null_terminated) {
  251|       |               if (it == end) [[unlikely]] {
  252|       |                  ctx.error = error_code::unexpected_end;
  253|       |                  return;
  254|       |               }
  255|       |            }
  256|       |            match<"ull", Opts>(ctx, it, end);
  257|       |            if (bool(ctx.error)) [[unlikely]]
  258|       |               return;
  259|       |            // Successfully matched "null", skip it
  260|       |            if constexpr (Opts.error_on_missing_keys || Opts.partial_read) {
  261|       |               ((selected_index = I), ...); // Mark as handled even if skipped
  262|       |            }
  263|       |            return;
  264|       |         }
  265|       |      }
  266|       |
  267|       |      if constexpr (skipped_by_meta<T, I, operation::parse>) {
  268|       |         skip_value<JSON>::op<Opts>(ctx, it, end);
  269|       |         if (bool(ctx.error)) [[unlikely]]
  270|       |            return; // Propagate error from skip_value
  271|       |      }
  272|  12.4k|      else {
  273|  12.4k|         using V = refl_t<T, I>;
  274|       |
  275|       |         if constexpr (const_value_v<V>) {
  276|       |            if constexpr (check_error_on_const_read(Opts)) {
  277|       |               ctx.error = error_code::attempt_const_read;
  278|       |            }
  279|       |            else {
  280|       |               // do not read anything into the const value
  281|       |               skip_value<JSON>::op<Opts>(ctx, it, end);
  282|       |            }
  283|       |         }
  284|       |         else if constexpr (is_function_ptr_or_ref<V>) {
  285|       |            // Function pointers cannot be deserialized from JSON.
  286|       |            // When write_function_pointers is enabled the writer emits a type-name string,
  287|       |            // but there is nothing meaningful to reconstruct on read — just skip the value.
  288|       |            // When write_function_pointers is off the key is never written, so this branch
  289|       |            // is unreachable in that case.
  290|       |            skip_value<JSON>::op<Opts>(ctx, it, end);
  291|       |         }
  292|       |         else if constexpr (glaze_object_t<T>) {
  293|       |            from<JSON, std::remove_cvref_t<V>>::template op<FieldOpts>(get_member(value, get<I>(reflect<T>::values)),
  294|       |                                                                       ctx, it, end);
  295|       |         }
  296|  12.4k|         else {
  297|  12.4k|            from<JSON, std::remove_cvref_t<V>>::template op<FieldOpts>(get_member(value, get<I>(to_tie(value))), ctx,
  298|  12.4k|                                                                       it, end);
  299|  12.4k|         }
  300|  12.4k|      }
  301|       |
  302|       |      // The key was present and handled, even when the value itself was skipped
  303|       |      if constexpr (Opts.error_on_missing_keys || Opts.partial_read) {
  304|       |         ((selected_index = I), ...);
  305|       |      }
  306|  12.4k|   }
_ZN3glz24decode_index_unknown_keyITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz6nestedERS3_TkNS_10is_contextERNS_7contextERPKcS8_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT2_OT3_T4_:
  177|     86|   {
  178|     86|      if constexpr (Opts.error_on_unknown_keys) {
  179|     86|         ctx.error = error_code::unknown_key;
  180|       |      }
  181|       |      else {
  182|       |         auto* start = it;
  183|       |         skip_string_view(ctx, it, end);
  184|       |         if (bool(ctx.error)) [[unlikely]]
  185|       |            return;
  186|       |         if (validate_utf8_span<Opts>(ctx, start, it)) [[unlikely]]
  187|       |            return;
  188|       |         const sv key = {start, size_t(it - start)};
  189|       |         ++it;
  190|       |         if constexpr (not Opts.null_terminated) {
  191|       |            if (it == end) [[unlikely]] {
  192|       |               ctx.error = error_code::unexpected_end;
  193|       |               return;
  194|       |            }
  195|       |         }
  196|       |
  197|       |         if (parse_ws_colon<Opts>(ctx, it, end)) {
  198|       |            return;
  199|       |         }
  200|       |
  201|       |         parse<JSON>::handle_unknown<Opts>(key, value, ctx, it, end);
  202|       |      }
  203|     86|   }
_ZN3glz12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz6nestedELm1ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT2_OT4_OT5_OT6_DpOT3_:
  311|    615|   {
  312|    615|      static constexpr auto Key = get<I>(reflect<T>::keys);
  313|    615|      static constexpr auto KeyWithEndQuote = join_v<Key, chars<"\"">>;
  314|    615|      static constexpr auto Length = KeyWithEndQuote.size();
  315|       |
  316|    615|      if (((it + Length) < end) && comparitor<KeyWithEndQuote>(it)) [[likely]] {
  ------------------
  |  Branch (316:11): [True: 593, False: 22]
  |  Branch (316:36): [True: 562, False: 31]
  ------------------
  317|    562|         it += Length;
  318|    562|         if constexpr (not Opts.null_terminated) {
  319|    562|            if (it == end) [[unlikely]] {
  ------------------
  |  Branch (319:17): [True: 0, False: 562]
  ------------------
  320|      0|               ctx.error = error_code::unexpected_end;
  321|      0|               return;
  322|      0|            }
  323|    562|         }
  324|       |
  325|    562|         if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (325:14): [True: 0, False: 562]
  ------------------
  326|      0|            return;
  327|      0|         }
  328|    562|         if (match_invalid_end<':', Opts>(ctx, it, end)) {
  ------------------
  |  Branch (328:14): [True: 69, False: 493]
  ------------------
  329|     69|            return;
  330|     69|         }
  331|    493|         if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (331:14): [True: 0, False: 493]
  ------------------
  332|      0|            return;
  333|      0|         }
  334|       |
  335|       |         // The hash path has already consumed the whitespace before the value
  336|    493|         decode_field_value<Opts, ws_handled<Opts>(), T, I>(value, ctx, it, end, selected_index...);
  337|    493|      }
  338|     53|      else [[unlikely]] {
  339|     53|         decode_index_unknown_key<Opts, T>(value, ctx, it, end);
  340|     53|      }
  341|    615|   }
_ZN3glz18decode_field_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnDaXtlS1_Lj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEEN12jsonrpc_fuzz6nestedELm1ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT1_E11reflectableISA_EEEvOT3_OT5_OT6_OT7_DpOT4_:
  245|    493|   {
  246|       |      // Check for null value skipping on read
  247|       |      if constexpr (check_skip_null_members_on_read(Opts)) {
  248|       |         if (*it == 'n') {
  249|       |            ++it;
  250|       |            if constexpr (not Opts.null_terminated) {
  251|       |               if (it == end) [[unlikely]] {
  252|       |                  ctx.error = error_code::unexpected_end;
  253|       |                  return;
  254|       |               }
  255|       |            }
  256|       |            match<"ull", Opts>(ctx, it, end);
  257|       |            if (bool(ctx.error)) [[unlikely]]
  258|       |               return;
  259|       |            // Successfully matched "null", skip it
  260|       |            if constexpr (Opts.error_on_missing_keys || Opts.partial_read) {
  261|       |               ((selected_index = I), ...); // Mark as handled even if skipped
  262|       |            }
  263|       |            return;
  264|       |         }
  265|       |      }
  266|       |
  267|       |      if constexpr (skipped_by_meta<T, I, operation::parse>) {
  268|       |         skip_value<JSON>::op<Opts>(ctx, it, end);
  269|       |         if (bool(ctx.error)) [[unlikely]]
  270|       |            return; // Propagate error from skip_value
  271|       |      }
  272|    493|      else {
  273|    493|         using V = refl_t<T, I>;
  274|       |
  275|       |         if constexpr (const_value_v<V>) {
  276|       |            if constexpr (check_error_on_const_read(Opts)) {
  277|       |               ctx.error = error_code::attempt_const_read;
  278|       |            }
  279|       |            else {
  280|       |               // do not read anything into the const value
  281|       |               skip_value<JSON>::op<Opts>(ctx, it, end);
  282|       |            }
  283|       |         }
  284|       |         else if constexpr (is_function_ptr_or_ref<V>) {
  285|       |            // Function pointers cannot be deserialized from JSON.
  286|       |            // When write_function_pointers is enabled the writer emits a type-name string,
  287|       |            // but there is nothing meaningful to reconstruct on read — just skip the value.
  288|       |            // When write_function_pointers is off the key is never written, so this branch
  289|       |            // is unreachable in that case.
  290|       |            skip_value<JSON>::op<Opts>(ctx, it, end);
  291|       |         }
  292|       |         else if constexpr (glaze_object_t<T>) {
  293|       |            from<JSON, std::remove_cvref_t<V>>::template op<FieldOpts>(get_member(value, get<I>(reflect<T>::values)),
  294|       |                                                                       ctx, it, end);
  295|       |         }
  296|    493|         else {
  297|    493|            from<JSON, std::remove_cvref_t<V>>::template op<FieldOpts>(get_member(value, get<I>(to_tie(value))), ctx,
  298|    493|                                                                       it, end);
  299|    493|         }
  300|    493|      }
  301|       |
  302|       |      // The key was present and handled, even when the value itself was skipped
  303|       |      if constexpr (Opts.error_on_missing_keys || Opts.partial_read) {
  304|       |         ((selected_index = I), ...);
  305|       |      }
  306|    493|   }
_ZZN3glz16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT3_OT4_OT5_DpOT2_ENKUlTnmvE_clILm4EEEDav:
  484|      8|            visit<N>([&]<size_t I>() { decode_index<Opts, T, I>(value, ctx, it, end, selected_index...); }, index);
_ZN3glz12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiELm4ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT2_OT4_OT5_OT6_DpOT3_:
  311|      8|   {
  312|      8|      static constexpr auto Key = get<I>(reflect<T>::keys);
  313|      8|      static constexpr auto KeyWithEndQuote = join_v<Key, chars<"\"">>;
  314|      8|      static constexpr auto Length = KeyWithEndQuote.size();
  315|       |
  316|      8|      if (((it + Length) < end) && comparitor<KeyWithEndQuote>(it)) [[likely]] {
  ------------------
  |  Branch (316:11): [True: 3, False: 5]
  |  Branch (316:36): [True: 0, False: 3]
  ------------------
  317|      0|         it += Length;
  318|      0|         if constexpr (not Opts.null_terminated) {
  319|      0|            if (it == end) [[unlikely]] {
  ------------------
  |  Branch (319:17): [True: 0, False: 0]
  ------------------
  320|      0|               ctx.error = error_code::unexpected_end;
  321|      0|               return;
  322|      0|            }
  323|      0|         }
  324|       |
  325|      0|         if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (325:14): [True: 0, False: 0]
  ------------------
  326|      0|            return;
  327|      0|         }
  328|      0|         if (match_invalid_end<':', Opts>(ctx, it, end)) {
  ------------------
  |  Branch (328:14): [True: 0, False: 0]
  ------------------
  329|      0|            return;
  330|      0|         }
  331|      0|         if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (331:14): [True: 0, False: 0]
  ------------------
  332|      0|            return;
  333|      0|         }
  334|       |
  335|       |         // The hash path has already consumed the whitespace before the value
  336|      0|         decode_field_value<Opts, ws_handled<Opts>(), T, I>(value, ctx, it, end, selected_index...);
  337|      0|      }
  338|      8|      else [[unlikely]] {
  339|      8|         decode_index_unknown_key<Opts, T>(value, ctx, it, end);
  340|      8|      }
  341|      8|   }
_ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEERiTkNS_10is_contextERNS_7contextERPKcS8_EEvOT0_OT1_OT2_T3_:
   49|   616k|      {
   50|       |         if constexpr (const_value_v<T>) {
   51|       |            if constexpr (check_error_on_const_read(Opts)) {
   52|       |               ctx.error = error_code::attempt_const_read;
   53|       |            }
   54|       |            else {
   55|       |               // do not read anything into the const value
   56|       |               skip_value<JSON>::op<Opts>(std::forward<Ctx>(ctx), std::forward<It0>(it), end);
   57|       |            }
   58|       |         }
   59|   616k|         else {
   60|   616k|            using V = std::remove_cvref_t<T>;
   61|   616k|            from<JSON, V>::template op<Opts>(std::forward<T>(value), std::forward<Ctx>(ctx), std::forward<It0>(it),
   62|   616k|                                             end);
   63|   616k|         }
   64|   616k|      }
_ZZN3glz16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT3_OT4_OT5_DpOT2_ENKUlTnmvE_clILm5EEEDav:
  484|  1.13k|            visit<N>([&]<size_t I>() { decode_index<Opts, T, I>(value, ctx, it, end, selected_index...); }, index);
_ZN3glz12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiELm5ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT2_OT4_OT5_OT6_DpOT3_:
  311|  1.13k|   {
  312|  1.13k|      static constexpr auto Key = get<I>(reflect<T>::keys);
  313|  1.13k|      static constexpr auto KeyWithEndQuote = join_v<Key, chars<"\"">>;
  314|  1.13k|      static constexpr auto Length = KeyWithEndQuote.size();
  315|       |
  316|  1.13k|      if (((it + Length) < end) && comparitor<KeyWithEndQuote>(it)) [[likely]] {
  ------------------
  |  Branch (316:11): [True: 1.13k, False: 3]
  |  Branch (316:36): [True: 1.13k, False: 3]
  ------------------
  317|  1.13k|         it += Length;
  318|  1.13k|         if constexpr (not Opts.null_terminated) {
  319|  1.13k|            if (it == end) [[unlikely]] {
  ------------------
  |  Branch (319:17): [True: 0, False: 1.13k]
  ------------------
  320|      0|               ctx.error = error_code::unexpected_end;
  321|      0|               return;
  322|      0|            }
  323|  1.13k|         }
  324|       |
  325|  1.13k|         if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (325:14): [True: 0, False: 1.13k]
  ------------------
  326|      0|            return;
  327|      0|         }
  328|  1.13k|         if (match_invalid_end<':', Opts>(ctx, it, end)) {
  ------------------
  |  Branch (328:14): [True: 26, False: 1.10k]
  ------------------
  329|     26|            return;
  330|     26|         }
  331|  1.10k|         if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (331:14): [True: 0, False: 1.10k]
  ------------------
  332|      0|            return;
  333|      0|         }
  334|       |
  335|       |         // The hash path has already consumed the whitespace before the value
  336|  1.10k|         decode_field_value<Opts, ws_handled<Opts>(), T, I>(value, ctx, it, end, selected_index...);
  337|  1.10k|      }
  338|      6|      else [[unlikely]] {
  339|      6|         decode_index_unknown_key<Opts, T>(value, ctx, it, end);
  340|      6|      }
  341|  1.13k|   }
_ZN3glz18decode_field_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnDaXtlS1_Lj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEEN12jsonrpc_fuzz8fuzz_apiELm5ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT1_E11reflectableISA_EEEvOT3_OT5_OT6_OT7_DpOT4_:
  245|  1.10k|   {
  246|       |      // Check for null value skipping on read
  247|       |      if constexpr (check_skip_null_members_on_read(Opts)) {
  248|       |         if (*it == 'n') {
  249|       |            ++it;
  250|       |            if constexpr (not Opts.null_terminated) {
  251|       |               if (it == end) [[unlikely]] {
  252|       |                  ctx.error = error_code::unexpected_end;
  253|       |                  return;
  254|       |               }
  255|       |            }
  256|       |            match<"ull", Opts>(ctx, it, end);
  257|       |            if (bool(ctx.error)) [[unlikely]]
  258|       |               return;
  259|       |            // Successfully matched "null", skip it
  260|       |            if constexpr (Opts.error_on_missing_keys || Opts.partial_read) {
  261|       |               ((selected_index = I), ...); // Mark as handled even if skipped
  262|       |            }
  263|       |            return;
  264|       |         }
  265|       |      }
  266|       |
  267|       |      if constexpr (skipped_by_meta<T, I, operation::parse>) {
  268|       |         skip_value<JSON>::op<Opts>(ctx, it, end);
  269|       |         if (bool(ctx.error)) [[unlikely]]
  270|       |            return; // Propagate error from skip_value
  271|       |      }
  272|  1.10k|      else {
  273|  1.10k|         using V = refl_t<T, I>;
  274|       |
  275|       |         if constexpr (const_value_v<V>) {
  276|       |            if constexpr (check_error_on_const_read(Opts)) {
  277|       |               ctx.error = error_code::attempt_const_read;
  278|       |            }
  279|       |            else {
  280|       |               // do not read anything into the const value
  281|       |               skip_value<JSON>::op<Opts>(ctx, it, end);
  282|       |            }
  283|       |         }
  284|       |         else if constexpr (is_function_ptr_or_ref<V>) {
  285|       |            // Function pointers cannot be deserialized from JSON.
  286|       |            // When write_function_pointers is enabled the writer emits a type-name string,
  287|       |            // but there is nothing meaningful to reconstruct on read — just skip the value.
  288|       |            // When write_function_pointers is off the key is never written, so this branch
  289|       |            // is unreachable in that case.
  290|       |            skip_value<JSON>::op<Opts>(ctx, it, end);
  291|       |         }
  292|       |         else if constexpr (glaze_object_t<T>) {
  293|       |            from<JSON, std::remove_cvref_t<V>>::template op<FieldOpts>(get_member(value, get<I>(reflect<T>::values)),
  294|       |                                                                       ctx, it, end);
  295|       |         }
  296|  1.10k|         else {
  297|  1.10k|            from<JSON, std::remove_cvref_t<V>>::template op<FieldOpts>(get_member(value, get<I>(to_tie(value))), ctx,
  298|  1.10k|                                                                       it, end);
  299|  1.10k|         }
  300|  1.10k|      }
  301|       |
  302|       |      // The key was present and handled, even when the value itself was skipped
  303|       |      if constexpr (Opts.error_on_missing_keys || Opts.partial_read) {
  304|       |         ((selected_index = I), ...);
  305|       |      }
  306|  1.10k|   }
_ZN3glz4fromILj10ENSt3__13mapINS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEiNS1_4lessIS8_EENS6_INS1_4pairIKS8_iEEEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEETnNS_14string_literalEXtlNSJ_ILm1EEEEERSF_TkNS_10is_contextERNS_7contextERPKcSP_EEvOT1_OT2_OT3_T4_:
 3044|  1.10k|      {
 3045|  1.10k|         static constexpr auto num_members = reflect<T>::size;
 3046|       |
 3047|  1.10k|         static constexpr auto Opts = opening_handled_off<ws_handled_off<Options>()>();
 3048|  1.10k|         if constexpr (!check_opening_handled(Options)) {
 3049|       |            if constexpr (!check_ws_handled(Options)) {
 3050|       |               if (skip_ws<Opts>(ctx, it, end)) {
 3051|       |                  return;
 3052|       |               }
 3053|       |            }
 3054|  1.10k|            if (match_invalid_end<'{', Opts>(ctx, it, end)) {
  ------------------
  |  Branch (3054:17): [True: 30, False: 1.07k]
  ------------------
 3055|     30|               return;
 3056|     30|            }
 3057|  1.07k|            if constexpr (not Opts.null_terminated) {
 3058|  1.07k|               if (it == end) [[unlikely]] {
  ------------------
  |  Branch (3058:20): [True: 0, False: 1.07k]
  ------------------
 3059|      0|                  ctx.error = error_code::unexpected_end;
 3060|      0|                  return;
 3061|      0|               }
 3062|  1.07k|            }
 3063|       |            // one nesting level (see enter_depth): counted in both modes so the limit binds,
 3064|       |            // released at each syntactic close below
 3065|  1.07k|            if (enter_depth(ctx)) [[unlikely]] {
  ------------------
  |  Branch (3065:17): [True: 0, False: 1.07k]
  ------------------
 3066|      0|               return;
 3067|      0|            }
 3068|  1.07k|         }
 3069|  1.07k|         const auto ws_start = it;
 3070|  1.10k|         if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (3070:14): [True: 0, False: 1.10k]
  ------------------
 3071|      0|            return;
 3072|      0|         }
 3073|  1.10k|         const size_t ws_size = size_t(it - ws_start);
 3074|       |
 3075|       |         if constexpr ((glaze_object_t<T> || reflectable<T>) && num_members == 0 && Opts.error_on_unknown_keys) {
 3076|       |            if constexpr (not tag.sv().empty()) {
 3077|       |               if (*it == '"') {
 3078|       |                  ++it;
 3079|       |                  if constexpr (not Opts.null_terminated) {
 3080|       |                     if (it == end) [[unlikely]] {
 3081|       |                        ctx.error = error_code::unexpected_end;
 3082|       |                        return;
 3083|       |                     }
 3084|       |                  }
 3085|       |
 3086|       |                  const auto start = it;
 3087|       |                  skip_string_view(ctx, it, end);
 3088|       |                  if (bool(ctx.error)) [[unlikely]]
 3089|       |                     return;
 3090|       |                  if (validate_utf8_span<Opts>(ctx, start, it)) [[unlikely]]
 3091|       |                     return;
 3092|       |                  const sv key{start, size_t(it - start)};
 3093|       |                  ++it;
 3094|       |                  if constexpr (not Opts.null_terminated) {
 3095|       |                     if (it == end) [[unlikely]] {
 3096|       |                        ctx.error = error_code::unexpected_end;
 3097|       |                        return;
 3098|       |                     }
 3099|       |                  }
 3100|       |
 3101|       |                  if (key == tag.sv()) {
 3102|       |                     if (parse_ws_colon<Opts>(ctx, it, end)) {
 3103|       |                        return;
 3104|       |                     }
 3105|       |
 3106|       |                     parse<JSON>::handle_unknown<Opts>(key, value, ctx, it, end);
 3107|       |                     if (bool(ctx.error)) [[unlikely]]
 3108|       |                        return;
 3109|       |
 3110|       |                     if (skip_ws<Opts>(ctx, it, end)) {
 3111|       |                        return;
 3112|       |                     }
 3113|       |                  }
 3114|       |                  else {
 3115|       |                     ctx.error = error_code::unknown_key;
 3116|       |                     return;
 3117|       |                  }
 3118|       |               }
 3119|       |            }
 3120|       |
 3121|       |            if (*it == '}') [[likely]] {
 3122|       |               --ctx.depth;
 3123|       |               if constexpr (glaze_object_t<T> || reflectable<T>) {
 3124|       |                  if constexpr (has_self_constraint_v<T> && !check_skip_self_constraint(Opts)) {
 3125|       |                     auto wrapper = self_constraint_v<T>(value);
 3126|       |                     from<JSON, decltype(wrapper)>::template op<ws_handled<Opts>()>(wrapper, ctx, it, end);
 3127|       |                     if (bool(ctx.error)) {
 3128|       |                        return;
 3129|       |                     }
 3130|       |                  }
 3131|       |               }
 3132|       |               ++it;
 3133|       |               if constexpr (not Opts.null_terminated) {
 3134|       |                  if (it == end) {
 3135|       |                     ctx.error = error_code::end_reached;
 3136|       |                     return;
 3137|       |                  }
 3138|       |               }
 3139|       |               if constexpr (Opts.partial_read) {
 3140|       |                  ctx.error = error_code::partial_read_complete;
 3141|       |               }
 3142|       |               return;
 3143|       |            }
 3144|       |            ctx.error = error_code::unknown_key;
 3145|       |            return;
 3146|       |         }
 3147|  1.10k|         else {
 3148|  1.10k|            decltype(auto) fields = [&]() -> decltype(auto) {
 3149|  1.10k|               if constexpr ((glaze_object_t<T> || reflectable<T>) &&
 3150|  1.10k|                             (Opts.error_on_missing_keys || Opts.partial_read)) {
 3151|  1.10k|                  return bit_array<num_members>{};
 3152|  1.10k|               }
 3153|  1.10k|               else {
 3154|  1.10k|                  return nullptr;
 3155|  1.10k|               }
 3156|  1.10k|            }();
 3157|       |
 3158|  1.10k|            size_t read_count{}; // for partial_read
 3159|       |
 3160|  1.10k|            bool first = true;
 3161|  18.9k|            while (true) {
  ------------------
  |  Branch (3161:20): [True: 18.3k, Folded]
  ------------------
 3162|       |               if constexpr ((glaze_object_t<T> || reflectable<T>) && Opts.partial_read) {
 3163|       |                  static constexpr bit_array<num_members> all_fields = [] {
 3164|       |                     bit_array<num_members> arr{};
 3165|       |                     for (size_t i = 0; i < num_members; ++i) {
 3166|       |                        arr[i] = true;
 3167|       |                     }
 3168|       |                     return arr;
 3169|       |                  }();
 3170|       |
 3171|       |                  if ((all_fields & fields) == all_fields) {
 3172|       |                     ctx.error = error_code::partial_read_complete;
 3173|       |                     --ctx.depth; // as above: an early success still closes this level
 3174|       |                     return;
 3175|       |                  }
 3176|       |               }
 3177|       |
 3178|       |               // Streaming refill point: at start of each iteration, ensure buffer has data
 3179|       |               if constexpr (has_streaming_state<decltype(ctx)>) {
 3180|       |                  if (ctx.stream.enabled()) {
 3181|       |                     const size_t consumed = static_cast<size_t>(it - ctx.stream.data());
 3182|       |                     const size_t remaining = ctx.stream.size() - consumed;
 3183|       |                     // Refill when less than half of buffer remains to ensure space for next key-value pair
 3184|       |                     if (remaining <= ctx.stream.size() / 2 || it >= end) {
 3185|       |                        const char* new_it;
 3186|       |                        const char* new_end;
 3187|       |                        ctx.stream.consume_and_refill(consumed, new_it, new_end);
 3188|       |                        it = new_it;
 3189|       |                        end = new_end;
 3190|       |                        if (it >= end && ctx.stream.at_eof()) {
 3191|       |                           ctx.error = error_code::unexpected_end;
 3192|       |                           return;
 3193|       |                        }
 3194|       |                     }
 3195|       |                  }
 3196|       |               }
 3197|       |
 3198|  18.3k|               if (*it == '}') {
  ------------------
  |  Branch (3198:20): [True: 313, False: 18.0k]
  ------------------
 3199|    313|                  --ctx.depth;
 3200|       |                  if constexpr ((glaze_object_t<T> || reflectable<T>) && Opts.error_on_missing_keys) {
 3201|       |                     constexpr auto req_fields = required_fields<T, Opts>();
 3202|       |                     if ((req_fields & fields) != req_fields) {
 3203|       |                        for (size_t i = 0; i < num_members; ++i) {
 3204|       |                           if (not fields[i] && req_fields[i]) {
 3205|       |                              ctx.custom_error_message = reflect<T>::keys[i];
 3206|       |                              // We just return the first missing key in order to avoid heap allocations
 3207|       |                              break;
 3208|       |                           }
 3209|       |                        }
 3210|       |
 3211|       |                        ctx.error = error_code::missing_key;
 3212|       |                        return;
 3213|       |                     }
 3214|       |                  }
 3215|       |                  if constexpr (glaze_object_t<T> || reflectable<T>) {
 3216|       |                     if constexpr (has_self_constraint_v<T> && !check_skip_self_constraint(Opts)) {
 3217|       |                        auto wrapper = self_constraint_v<T>(value);
 3218|       |                        from<JSON, decltype(wrapper)>::template op<ws_handled<Opts>()>(wrapper, ctx, it, end);
 3219|       |                        if (bool(ctx.error)) {
 3220|       |                           return;
 3221|       |                        }
 3222|       |                     }
 3223|       |                  }
 3224|    313|                  ++it; // Increment after checking for missing keys so errors are within buffer bounds
 3225|    313|                  if constexpr (not Opts.null_terminated) {
 3226|    313|                     if (it == end) {
  ------------------
  |  Branch (3226:26): [True: 0, False: 313]
  ------------------
 3227|      0|                        ctx.error = error_code::end_reached;
 3228|      0|                        return;
 3229|      0|                     }
 3230|    313|                  }
 3231|    313|                  return;
 3232|    313|               }
 3233|  18.0k|               else if (first) {
  ------------------
  |  Branch (3233:25): [True: 990, False: 17.0k]
  ------------------
 3234|    990|                  first = false;
 3235|    990|               }
 3236|  17.0k|               else {
 3237|  17.0k|                  if (match_invalid_end<',', Opts>(ctx, it, end)) {
  ------------------
  |  Branch (3237:23): [True: 190, False: 16.8k]
  ------------------
 3238|    190|                     return;
 3239|    190|                  }
 3240|  16.8k|                  if constexpr (not Opts.null_terminated) {
 3241|  16.8k|                     if (it == end) [[unlikely]] {
  ------------------
  |  Branch (3241:26): [True: 0, False: 16.8k]
  ------------------
 3242|      0|                        ctx.error = error_code::unexpected_end;
 3243|      0|                        return;
 3244|      0|                     }
 3245|  16.8k|                  }
 3246|       |
 3247|       |                  if constexpr ((not Opts.minified) && (num_members > 1 || not Opts.error_on_unknown_keys) &&
 3248|       |                                (!Opts.comments)) {
 3249|       |                     if (ws_size && ws_size < size_t(end - it)) {
 3250|       |                        skip_matching_ws(ws_start, it, ws_size);
 3251|       |                     }
 3252|       |                  }
 3253|       |
 3254|  16.8k|                  if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (3254:23): [True: 0, False: 16.8k]
  ------------------
 3255|      0|                     return;
 3256|      0|                  }
 3257|  16.8k|               }
 3258|       |
 3259|  17.8k|               constexpr auto reflection_type = glaze_object_t<T> || reflectable<T>;
  ------------------
  |  Branch (3259:49): [Folded, False: 0]
  |  Branch (3259:70): [Folded, False: 0]
  ------------------
 3260|       |
 3261|       |               if constexpr (reflection_type && (num_members == 0)) {
 3262|       |                  if constexpr (Opts.error_on_unknown_keys) {
 3263|       |                     static_assert(false_v<T>, "This should be unreachable");
 3264|       |                  }
 3265|       |                  else {
 3266|       |                     if (match_invalid_end<'"', Opts>(ctx, it, end)) {
 3267|       |                        return;
 3268|       |                     }
 3269|       |
 3270|       |                     // parsing to an empty object, but at this point the JSON presents keys
 3271|       |
 3272|       |                     // Unknown key handler does not unescape keys. Unknown escaped keys are
 3273|       |                     // handled by the user.
 3274|       |
 3275|       |                     const auto start = it;
 3276|       |                     skip_string_view(ctx, it, end);
 3277|       |                     if (bool(ctx.error)) [[unlikely]]
 3278|       |                        return;
 3279|       |                     if (validate_utf8_span<Opts>(ctx, start, it)) [[unlikely]]
 3280|       |                        return;
 3281|       |                     const sv key{start, size_t(it - start)};
 3282|       |                     ++it;
 3283|       |                     if constexpr (not Opts.null_terminated) {
 3284|       |                        if (it == end) [[unlikely]] {
 3285|       |                           ctx.error = error_code::unexpected_end;
 3286|       |                           return;
 3287|       |                        }
 3288|       |                     }
 3289|       |
 3290|       |                     if (parse_ws_colon<Opts>(ctx, it, end)) {
 3291|       |                        return;
 3292|       |                     }
 3293|       |
 3294|       |                     // Check if this key is the variant tag that should be skipped
 3295|       |                     if constexpr (not tag.sv().empty()) {
 3296|       |                        if (key == tag.sv()) {
 3297|       |                           // Skip the tag value
 3298|       |                           skip_value<JSON>::op<Opts>(ctx, it, end);
 3299|       |                           if (bool(ctx.error)) [[unlikely]]
 3300|       |                              return;
 3301|       |                           resync_window_end(ctx, end); // a streaming skip refills
 3302|       |                           if (skip_ws<Opts>(ctx, it, end)) {
 3303|       |                              return;
 3304|       |                           }
 3305|       |                           continue;
 3306|       |                        }
 3307|       |                     }
 3308|       |
 3309|       |                     parse<JSON>::handle_unknown<Opts>(key, value, ctx, it, end);
 3310|       |                     if (bool(ctx.error)) [[unlikely]]
 3311|       |                        return;
 3312|       |                     if constexpr (not Opts.null_terminated) {
 3313|       |                        if (it == end) [[unlikely]] {
 3314|       |                           ctx.error = error_code::unexpected_end;
 3315|       |                           return;
 3316|       |                        }
 3317|       |                     }
 3318|       |                     if (skip_ws<Opts>(ctx, it, end)) {
 3319|       |                        return;
 3320|       |                     }
 3321|       |                  }
 3322|       |               }
 3323|       |               else if constexpr (reflection_type) {
 3324|       |                  static_assert(bool(hash_info<T>.type));
 3325|       |
 3326|       |                  if (*it != '"') [[unlikely]] {
 3327|       |                     ctx.error = error_code::expected_quote;
 3328|       |                     return;
 3329|       |                  }
 3330|       |                  ++it;
 3331|       |                  if constexpr (not Opts.null_terminated) {
 3332|       |                     if (it == end) [[unlikely]] {
 3333|       |                        ctx.error = error_code::unexpected_end;
 3334|       |                        return;
 3335|       |                     }
 3336|       |                  }
 3337|       |
 3338|       |                  if constexpr (not tag.sv().empty() && not contains_tag<T, tag>()) {
 3339|       |                     // For tagged variants we first check to see if the key matches the tag
 3340|       |                     // We only need to do this if the tag is not part of the keys
 3341|       |
 3342|       |                     const auto start = it;
 3343|       |                     skip_string_view(ctx, it, end);
 3344|       |                     if (bool(ctx.error)) [[unlikely]]
 3345|       |                        return;
 3346|       |                     if (validate_utf8_span<Opts>(ctx, start, it)) [[unlikely]]
 3347|       |                        return;
 3348|       |                     const sv key{start, size_t(it - start)};
 3349|       |                     ++it;
 3350|       |                     if constexpr (not Opts.null_terminated) {
 3351|       |                        if (it == end) [[unlikely]] {
 3352|       |                           ctx.error = error_code::unexpected_end;
 3353|       |                           return;
 3354|       |                        }
 3355|       |                     }
 3356|       |
 3357|       |                     if (key == tag.sv()) {
 3358|       |                        if (parse_ws_colon<Opts>(ctx, it, end)) {
 3359|       |                           return;
 3360|       |                        }
 3361|       |
 3362|       |                        parse<JSON>::handle_unknown<Opts>(key, value, ctx, it, end);
 3363|       |                        if (bool(ctx.error)) [[unlikely]]
 3364|       |                           return;
 3365|       |
 3366|       |                        if (skip_ws<Opts>(ctx, it, end)) {
 3367|       |                           return;
 3368|       |                        }
 3369|       |                        continue;
 3370|       |                     }
 3371|       |                     else {
 3372|       |                        it = start; // reset the iterator
 3373|       |                     }
 3374|       |                  }
 3375|       |
 3376|       |                  if constexpr (Opts.error_on_missing_keys || Opts.partial_read) {
 3377|       |                     size_t index = num_members;
 3378|       |                     parse_and_invoke<Opts, T>(value, ctx, it, end, index);
 3379|       |                     if (bool(ctx.error)) [[unlikely]]
 3380|       |                        return;
 3381|       |                     if (index < num_members) {
 3382|       |                        fields[index] = true;
 3383|       |                     }
 3384|       |                  }
 3385|       |                  else {
 3386|       |                     parse_and_invoke<Opts, T>(value, ctx, it, end);
 3387|       |                     if (bool(ctx.error)) [[unlikely]]
 3388|       |                        return;
 3389|       |                  }
 3390|       |               }
 3391|  17.8k|               else {
 3392|       |                  // For types like std::map, std::unordered_map
 3393|       |
 3394|  17.8k|                  auto reading = [&](auto&& key) {
 3395|  17.8k|                     if constexpr (Opts.partial_read) {
 3396|  17.8k|                        if (auto element = value.find(key); element != value.end()) {
 3397|  17.8k|                           ++read_count;
 3398|  17.8k|                           parse<JSON>::op<ws_handled<Opts>()>(element->second, ctx, it, end);
 3399|  17.8k|                        }
 3400|  17.8k|                        else {
 3401|  17.8k|                           skip_value<JSON>::op<Opts>(ctx, it, end);
 3402|  17.8k|                        }
 3403|  17.8k|                     }
 3404|  17.8k|                     else {
 3405|  17.8k|                        parse<JSON>::op<ws_handled<Opts>()>(value[key], ctx, it, end);
 3406|  17.8k|                     }
 3407|  17.8k|                  };
 3408|       |
 3409|       |                  // using Key = std::conditional_t<heterogeneous_map<T>, sv, typename T::key_type>;
 3410|  17.8k|                  using Key = typename T::key_type;
 3411|  17.8k|                  if constexpr (std::is_same_v<Key, std::string>) {
 3412|  17.8k|                     ctx.scratch.clear();
 3413|  17.8k|                     parse<JSON>::op<Opts>(ctx.scratch, ctx, it, end);
 3414|  17.8k|                     if (bool(ctx.error)) [[unlikely]]
  ------------------
  |  Branch (3414:26): [True: 141, False: 17.7k]
  ------------------
 3415|    141|                        return;
 3416|       |
 3417|  17.7k|                     if (parse_ws_colon<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (3417:26): [True: 64, False: 17.6k]
  ------------------
 3418|     64|                        return;
 3419|     64|                     }
 3420|       |
 3421|  17.6k|                     reading(ctx.scratch);
 3422|       |                     if constexpr (Opts.partial_read) {
 3423|       |                        if (read_count == value.size()) {
 3424|       |                           return;
 3425|       |                        }
 3426|       |                     }
 3427|  17.6k|                     if (bool(ctx.error)) [[unlikely]]
  ------------------
  |  Branch (3427:26): [True: 367, False: 17.2k]
  ------------------
 3428|    367|                        return;
 3429|       |                  }
 3430|       |                  else if constexpr (str_t<Key>) {
 3431|       |                     Key key;
 3432|       |                     parse<JSON>::op<Opts>(key, ctx, it, end);
 3433|       |                     if (bool(ctx.error)) [[unlikely]]
 3434|       |                        return;
 3435|       |
 3436|       |                     if (parse_ws_colon<Opts>(ctx, it, end)) {
 3437|       |                        return;
 3438|       |                     }
 3439|       |
 3440|       |                     reading(key);
 3441|       |                     if constexpr (Opts.partial_read) {
 3442|       |                        if (read_count == value.size()) {
 3443|       |                           return;
 3444|       |                        }
 3445|       |                     }
 3446|       |                     if (bool(ctx.error)) [[unlikely]]
 3447|       |                        return;
 3448|       |                  }
 3449|       |                  else {
 3450|       |                     Key key_value{};
 3451|       |                     if constexpr (is_named_enum<Key> || mimics_str_t<Key>) {
 3452|       |                        parse<JSON>::op<Opts>(key_value, ctx, it, end);
 3453|       |                     }
 3454|       |                     else if constexpr (std::is_arithmetic_v<Key>) {
 3455|       |                        // prefer over quoted_t below to avoid double parsing of quoted_t
 3456|       |                        parse<JSON>::op<opt_true<Opts, quoted_num_opt_tag{}>>(key_value, ctx, it, end);
 3457|       |                     }
 3458|       |                     else {
 3459|       |                        parse<JSON>::op<opt_false<Opts, raw_string_opt_tag{}>>(quoted_t<Key>{key_value}, ctx, it, end);
 3460|       |                     }
 3461|       |                     if (bool(ctx.error)) [[unlikely]]
 3462|       |                        return;
 3463|       |
 3464|       |                     if (parse_ws_colon<Opts>(ctx, it, end)) {
 3465|       |                        return;
 3466|       |                     }
 3467|       |
 3468|       |                     reading(key_value);
 3469|       |                     if constexpr (Opts.partial_read) {
 3470|       |                        if (read_count == value.size()) {
 3471|       |                           return;
 3472|       |                        }
 3473|       |                     }
 3474|       |                     if (bool(ctx.error)) [[unlikely]]
 3475|       |                        return;
 3476|       |                  }
 3477|  17.8k|               }
 3478|       |
 3479|       |               // Streaming refill point: after parsing each key-value pair, refill if buffer is low
 3480|       |               if constexpr (has_streaming_state<decltype(ctx)>) {
 3481|       |                  if (ctx.stream.enabled()) {
 3482|       |                     const size_t consumed = static_cast<size_t>(it - ctx.stream.data());
 3483|       |                     // Refill when less than 25% of buffer remains to ensure enough space for next element
 3484|       |                     if (ctx.stream.size() - consumed <= ctx.stream.size() / 4 || it >= end) {
 3485|       |                        const char* new_it;
 3486|       |                        const char* new_end;
 3487|       |                        ctx.stream.consume_and_refill(consumed, new_it, new_end);
 3488|       |                        it = new_it;
 3489|       |                        end = new_end;
 3490|       |                        if (it >= end && ctx.stream.at_eof()) {
 3491|       |                           ctx.error = error_code::unexpected_end;
 3492|       |                           return;
 3493|       |                        }
 3494|       |                     }
 3495|       |                  }
 3496|       |               }
 3497|       |
 3498|  17.8k|               if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (3498:20): [True: 0, False: 17.8k]
  ------------------
 3499|      0|                  return;
 3500|      0|               }
 3501|  17.8k|            }
 3502|  1.10k|         }
 3503|  1.10k|      }
_ZZN3glz4fromILj10ENSt3__13mapINS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEiNS1_4lessIS8_EENS6_INS1_4pairIKS8_iEEEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEETnNS_14string_literalEXtlNSJ_ILm1EEEEERSF_TkNS_10is_contextERNS_7contextERPKcSP_EEvOT1_OT2_OT3_T4_ENKUlvE_clEv:
 3148|  1.07k|            decltype(auto) fields = [&]() -> decltype(auto) {
 3149|       |               if constexpr ((glaze_object_t<T> || reflectable<T>) &&
 3150|       |                             (Opts.error_on_missing_keys || Opts.partial_read)) {
 3151|       |                  return bit_array<num_members>{};
 3152|       |               }
 3153|  1.07k|               else {
 3154|  1.07k|                  return nullptr;
 3155|  1.07k|               }
 3156|  1.07k|            }();
_ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEETkNS_10is_contextERNS_7contextERPKcSF_EEvOT0_OT1_OT2_T3_:
   49|  1.54M|      {
   50|       |         if constexpr (const_value_v<T>) {
   51|       |            if constexpr (check_error_on_const_read(Opts)) {
   52|       |               ctx.error = error_code::attempt_const_read;
   53|       |            }
   54|       |            else {
   55|       |               // do not read anything into the const value
   56|       |               skip_value<JSON>::op<Opts>(std::forward<Ctx>(ctx), std::forward<It0>(it), end);
   57|       |            }
   58|       |         }
   59|  1.54M|         else {
   60|  1.54M|            using V = std::remove_cvref_t<T>;
   61|  1.54M|            from<JSON, V>::template op<Opts>(std::forward<T>(value), std::forward<Ctx>(ctx), std::forward<It0>(it),
   62|  1.54M|                                             end);
   63|  1.54M|         }
   64|  1.54M|      }
_ZN3glz4fromILj10ENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERPKcSC_S7_TkNS_10is_contextERNS_7contextEQntcl15check_is_paddedTL0__EEEvRT2_OT3_OT0_T1_:
 1043|  1.54M|      {
 1044|       |         if constexpr (check_string_as_number(Opts)) {
 1045|       |            auto start = it;
 1046|       |            skip_number<Opts>(ctx, it, end);
 1047|       |            if (bool(ctx.error)) [[unlikely]] {
 1048|       |               return;
 1049|       |            }
 1050|       |            if (start == it) [[unlikely]] {
 1051|       |               ctx.error = error_code::parse_number_failure;
 1052|       |               return;
 1053|       |            }
 1054|       |            value.append(start, size_t(it - start));
 1055|       |         }
 1056|  1.54M|         else {
 1057|  1.54M|            if constexpr (!check_opening_handled(Opts)) {
 1058|  1.54M|               if constexpr (!check_ws_handled(Opts)) {
 1059|  1.54M|                  if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (1059:23): [True: 0, False: 1.54M]
  ------------------
 1060|      0|                     return;
 1061|      0|                  }
 1062|  1.54M|               }
 1063|       |
 1064|  1.54M|               if (match_invalid_end<'"', Opts>(ctx, it, end)) {
  ------------------
  |  Branch (1064:20): [True: 646, False: 1.54M]
  ------------------
 1065|    646|                  return;
 1066|    646|               }
 1067|  1.54M|            }
 1068|       |
 1069|  1.54M|            if constexpr (not check_raw_string(Opts)) {
 1070|  1.54M|               static constexpr auto string_padding_bytes = 8;
 1071|       |
 1072|  1.54M|               if (size_t(end - it) >= 8) {
  ------------------
  |  Branch (1072:20): [True: 1.53M, False: 15.3k]
  ------------------
 1073|  1.53M|                  auto start = it;
 1074|  1.53M|                  uint64_t ascii_acc{};
 1075|  1.53M|                  const auto end8 = end - 8;
 1076|  4.47M|                  while (true) {
  ------------------
  |  Branch (1076:26): [True: 4.47M, Folded]
  ------------------
 1077|  4.47M|                     if (it >= end8) [[unlikely]] {
  ------------------
  |  Branch (1077:26): [True: 949, False: 4.47M]
  ------------------
 1078|    949|                        break;
 1079|    949|                     }
 1080|       |
 1081|  4.47M|                     uint64_t chunk;
 1082|  4.47M|                     std::memcpy(&chunk, it, 8);
 1083|       |                     if constexpr (std::endian::native == std::endian::big) {
 1084|       |                        chunk = std::byteswap(chunk);
 1085|       |                     }
 1086|  4.47M|                     ascii_acc |= chunk;
 1087|  4.47M|                     const uint64_t test_chars = has_quote(chunk);
 1088|  4.47M|                     if (test_chars) {
  ------------------
  |  Branch (1088:26): [True: 1.53M, False: 2.94M]
  ------------------
 1089|  1.53M|                        it += (countr_zero(test_chars) >> 3);
 1090|       |
 1091|  1.53M|                        auto* prev = it - 1;
 1092|  1.55M|                        while (*prev == '\\') {
  ------------------
  |  Branch (1092:32): [True: 23.8k, False: 1.53M]
  ------------------
 1093|  23.8k|                           --prev;
 1094|  23.8k|                        }
 1095|  1.53M|                        if (size_t(it - prev) % 2) {
  ------------------
  |  Branch (1095:29): [True: 1.53M, False: 5.00k]
  ------------------
 1096|  1.53M|                           goto continue_decode;
 1097|  1.53M|                        }
 1098|  5.00k|                        ++it; // skip the escaped quote
 1099|  5.00k|                     }
 1100|  2.94M|                     else {
 1101|  2.94M|                        it += 8;
 1102|  2.94M|                     }
 1103|  4.47M|                  }
 1104|       |
 1105|  2.57k|                  while (it[-1] == '\\') [[unlikely]] {
  ------------------
  |  Branch (1105:26): [True: 1.62k, False: 949]
  ------------------
 1106|       |                     // if we ended on an escape character then we need to rewind
 1107|       |                     // because we lost our context
 1108|  1.62k|                     --it;
 1109|  1.62k|                  }
 1110|       |
 1111|       |                  // The byte-wise tail keeps feeding the accumulator: it has to cover every byte of
 1112|       |                  // the string, or a non-ASCII byte reached here would be waved through unvalidated.
 1113|  5.59k|                  for (; it < end; ++it) {
  ------------------
  |  Branch (1113:26): [True: 5.59k, False: 0]
  ------------------
 1114|  5.59k|                     ascii_acc |= uint8_t(*it);
 1115|  5.59k|                     if (*it == '"') {
  ------------------
  |  Branch (1115:26): [True: 995, False: 4.59k]
  ------------------
 1116|    995|                        auto* prev = it - 1;
 1117|  2.28k|                        while (*prev == '\\') {
  ------------------
  |  Branch (1117:32): [True: 1.29k, False: 995]
  ------------------
 1118|  1.29k|                           --prev;
 1119|  1.29k|                        }
 1120|    995|                        if (size_t(it - prev) % 2) {
  ------------------
  |  Branch (1120:29): [True: 949, False: 46]
  ------------------
 1121|    949|                           goto continue_decode;
 1122|    949|                        }
 1123|    995|                     }
 1124|  5.59k|                  }
 1125|       |
 1126|      0|                  ctx.error = error_code::unexpected_end;
 1127|      0|                  return;
 1128|       |
 1129|  1.53M|               continue_decode:
 1130|       |
 1131|  1.53M|                  if (validate_utf8_span<Opts>(ctx, start, it, ascii_acc)) [[unlikely]] {
  ------------------
  |  Branch (1131:23): [True: 0, False: 1.53M]
  ------------------
 1132|      0|                     return;
 1133|      0|                  }
 1134|       |
 1135|  1.53M|                  const auto available_padding = size_t(end - it);
 1136|  1.53M|                  auto n = size_t(it - start);
 1137|  1.53M|                  if (available_padding >= 8) [[likely]] {
  ------------------
  |  Branch (1137:23): [True: 1.51M, False: 18.3k]
  ------------------
 1138|  1.51M|                     value.resize(n + string_padding_bytes);
 1139|       |
 1140|  1.51M|                     auto* p = value.data();
 1141|       |
 1142|  3.70M|                     while (true) {
  ------------------
  |  Branch (1142:29): [True: 3.70M, Folded]
  ------------------
 1143|  3.70M|                        if (start >= it) {
  ------------------
  |  Branch (1143:29): [True: 1.50M, False: 2.20M]
  ------------------
 1144|  1.50M|                           break;
 1145|  1.50M|                        }
 1146|       |
 1147|  2.20M|                        std::memcpy(p, start, 8);
 1148|  2.20M|                        uint64_t swar;
 1149|  2.20M|                        std::memcpy(&swar, p, 8);
 1150|       |                        if constexpr (std::endian::native == std::endian::big) {
 1151|       |                           swar = std::byteswap(swar);
 1152|       |                        }
 1153|       |
 1154|  2.20M|                        constexpr uint64_t lo7_mask = repeat_byte8(0b01111111);
 1155|  2.20M|                        const uint64_t lo7 = swar & lo7_mask;
 1156|  2.20M|                        const uint64_t backslash = (lo7 ^ repeat_byte8('\\')) + lo7_mask;
 1157|  2.20M|                        const uint64_t less_32 = (swar & repeat_byte8(0b01100000)) + lo7_mask;
 1158|  2.20M|                        uint64_t next = ~((backslash & less_32) | swar);
 1159|       |
 1160|  2.20M|                        next &= repeat_byte8(0b10000000);
 1161|  2.20M|                        if (next == 0) {
  ------------------
  |  Branch (1161:29): [True: 2.18M, False: 13.5k]
  ------------------
 1162|  2.18M|                           start += 8;
 1163|  2.18M|                           p += 8;
 1164|  2.18M|                           continue;
 1165|  2.18M|                        }
 1166|       |
 1167|  13.5k|                        next = countr_zero(next) >> 3;
 1168|  13.5k|                        start += next;
 1169|  13.5k|                        if (start >= it) {
  ------------------
  |  Branch (1169:29): [True: 4.39k, False: 9.12k]
  ------------------
 1170|  4.39k|                           break;
 1171|  4.39k|                        }
 1172|       |
 1173|  9.12k|                        if ((*start & 0b11100000) == 0) [[unlikely]] {
  ------------------
  |  Branch (1173:29): [True: 39, False: 9.08k]
  ------------------
 1174|     39|                           ctx.error = error_code::syntax_error;
 1175|     39|                           return;
 1176|     39|                        }
 1177|  9.08k|                        ++start; // skip the escape
 1178|  9.08k|                        if (*start == 'u') {
  ------------------
  |  Branch (1178:29): [True: 5.92k, False: 3.16k]
  ------------------
 1179|  5.92k|                           ++start;
 1180|  5.92k|                           p += next;
 1181|  5.92k|                           const auto mark = start;
 1182|  5.92k|                           const auto offset = handle_unicode_code_point(start, p, end);
 1183|  5.92k|                           if (offset == 0) [[unlikely]] {
  ------------------
  |  Branch (1183:32): [True: 69, False: 5.85k]
  ------------------
 1184|     69|                              ctx.error = error_code::unicode_escape_conversion_failure;
 1185|     69|                              return;
 1186|     69|                           }
 1187|  5.85k|                           n += offset;
 1188|       |                           // escape + u + unicode code points
 1189|  5.85k|                           n -= 2 + uint32_t(start - mark);
 1190|  5.85k|                        }
 1191|  3.16k|                        else {
 1192|  3.16k|                           p += next;
 1193|  3.16k|                           *p = char_unescape_table[uint8_t(*start)];
 1194|  3.16k|                           if (*p == 0) [[unlikely]] {
  ------------------
  |  Branch (1194:32): [True: 9, False: 3.15k]
  ------------------
 1195|      9|                              ctx.error = error_code::invalid_escape;
 1196|      9|                              return;
 1197|      9|                           }
 1198|  3.15k|                           ++p;
 1199|  3.15k|                           ++start;
 1200|  3.15k|                           --n;
 1201|  3.15k|                        }
 1202|  9.08k|                     }
 1203|       |
 1204|  1.51M|                     value.resize(n);
 1205|  1.51M|                     ++it;
 1206|  1.51M|                  }
 1207|  18.3k|                  else {
 1208|       |                     // For large inputs this case of running out of buffer is very rare
 1209|  18.3k|                     value.resize(n);
 1210|  18.3k|                     auto* p = value.data();
 1211|       |
 1212|  18.3k|                     it = start;
 1213|  12.8M|                     while (it < end) [[likely]] {
  ------------------
  |  Branch (1213:29): [True: 12.8M, False: 0]
  ------------------
 1214|  12.8M|                        if (*it == '"') {
  ------------------
  |  Branch (1214:29): [True: 18.0k, False: 12.8M]
  ------------------
 1215|  18.0k|                           value.resize(size_t(p - value.data()));
 1216|  18.0k|                           ++it;
 1217|  18.0k|                           return;
 1218|  18.0k|                        }
 1219|       |
 1220|  12.8M|                        if ((*it & 0b11100000) == 0) [[unlikely]] {
  ------------------
  |  Branch (1220:29): [True: 153, False: 12.8M]
  ------------------
 1221|    153|                           ctx.error = error_code::syntax_error;
 1222|    153|                           return;
 1223|    153|                        }
 1224|       |
 1225|  12.8M|                        *p = *it;
 1226|       |
 1227|  12.8M|                        if (*it == '\\') {
  ------------------
  |  Branch (1227:29): [True: 30.2k, False: 12.8M]
  ------------------
 1228|  30.2k|                           ++it; // skip the escape
 1229|  30.2k|                           if (*it == 'u') {
  ------------------
  |  Branch (1229:32): [True: 19.5k, False: 10.6k]
  ------------------
 1230|  19.5k|                              ++it;
 1231|  19.5k|                              if (!handle_unicode_code_point(it, p, end)) [[unlikely]] {
  ------------------
  |  Branch (1231:35): [True: 105, False: 19.4k]
  ------------------
 1232|    105|                                 ctx.error = error_code::unicode_escape_conversion_failure;
 1233|    105|                                 return;
 1234|    105|                              }
 1235|  19.5k|                           }
 1236|  10.6k|                           else {
 1237|  10.6k|                              *p = char_unescape_table[uint8_t(*it)];
 1238|  10.6k|                              if (*p == 0) [[unlikely]] {
  ------------------
  |  Branch (1238:35): [True: 44, False: 10.6k]
  ------------------
 1239|     44|                                 ctx.error = error_code::invalid_escape;
 1240|     44|                                 return;
 1241|     44|                              }
 1242|  10.6k|                              ++p;
 1243|  10.6k|                              ++it;
 1244|  10.6k|                           }
 1245|  30.2k|                        }
 1246|  12.8M|                        else {
 1247|  12.8M|                           ++it;
 1248|  12.8M|                           ++p;
 1249|  12.8M|                        }
 1250|  12.8M|                     }
 1251|       |
 1252|      0|                     ctx.error = error_code::unexpected_end;
 1253|      0|                  }
 1254|  1.53M|               }
 1255|  15.3k|               else {
 1256|       |                  // For short strings
 1257|       |
 1258|  15.3k|                  std::array<char, 8> buffer{};
 1259|       |
 1260|  15.3k|                  auto* p = buffer.data();
 1261|  15.3k|                  const auto* const utf8_start = it;
 1262|       |
 1263|  44.0k|                  while (it < end) [[likely]] {
  ------------------
  |  Branch (1263:26): [True: 43.3k, False: 646]
  ------------------
 1264|  43.3k|                     *p = *it;
 1265|  43.3k|                     if (*it == '"') {
  ------------------
  |  Branch (1265:26): [True: 14.6k, False: 28.7k]
  ------------------
 1266|  14.6k|                        if (validate_utf8_span<Opts>(ctx, utf8_start, it)) [[unlikely]] {
  ------------------
  |  Branch (1266:29): [True: 0, False: 14.6k]
  ------------------
 1267|      0|                           return;
 1268|      0|                        }
 1269|  14.6k|                        const size_t n = size_t(p - buffer.data());
 1270|  14.6k|#if __has_cpp_attribute(assume) >= 202207L
 1271|  14.6k|                        [[assume(n <= sizeof(buffer))]];
 1272|  14.6k|#endif
 1273|  14.6k|                        value.assign(buffer.data(), n);
 1274|  14.6k|                        ++it;
 1275|  14.6k|                        if constexpr (not Opts.null_terminated) {
 1276|  14.6k|                           if (it == end) {
  ------------------
  |  Branch (1276:32): [True: 174, False: 14.5k]
  ------------------
 1277|    174|                              ctx.error = error_code::end_reached;
 1278|    174|                              return;
 1279|    174|                           }
 1280|  14.6k|                        }
 1281|  14.5k|                        return;
 1282|  14.6k|                     }
 1283|  28.7k|                     else if (*it == '\\') {
  ------------------
  |  Branch (1283:31): [True: 139, False: 28.5k]
  ------------------
 1284|    139|                        ++it; // skip the escape
 1285|    139|                        if constexpr (not Opts.null_terminated) {
 1286|    139|                           if (it == end) [[unlikely]] {
  ------------------
  |  Branch (1286:32): [True: 0, False: 139]
  ------------------
 1287|      0|                              ctx.error = error_code::unexpected_end;
 1288|      0|                              return;
 1289|      0|                           }
 1290|    139|                        }
 1291|    139|                        if (*it == 'u') {
  ------------------
  |  Branch (1291:29): [True: 73, False: 66]
  ------------------
 1292|     73|                           ++it;
 1293|     73|                           if constexpr (not Opts.null_terminated) {
 1294|     73|                              if (it == end) [[unlikely]] {
  ------------------
  |  Branch (1294:35): [True: 0, False: 73]
  ------------------
 1295|      0|                                 ctx.error = error_code::unexpected_end;
 1296|      0|                                 return;
 1297|      0|                              }
 1298|     73|                           }
 1299|     73|                           if (!handle_unicode_code_point(it, p, end)) [[unlikely]] {
  ------------------
  |  Branch (1299:32): [True: 26, False: 47]
  ------------------
 1300|     26|                              ctx.error = error_code::unicode_escape_conversion_failure;
 1301|     26|                              return;
 1302|     26|                           }
 1303|     73|                        }
 1304|     66|                        else {
 1305|     66|                           *p = char_unescape_table[uint8_t(*it)];
 1306|     66|                           if (*p == 0) [[unlikely]] {
  ------------------
  |  Branch (1306:32): [True: 17, False: 49]
  ------------------
 1307|     17|                              ctx.error = error_code::invalid_escape;
 1308|     17|                              return;
 1309|     17|                           }
 1310|     49|                           ++p;
 1311|     49|                           ++it;
 1312|     49|                        }
 1313|    139|                     }
 1314|  28.5k|                     else if ((*it & 0b11100000) == 0) [[unlikely]] {
  ------------------
  |  Branch (1314:31): [True: 17, False: 28.5k]
  ------------------
 1315|     17|                        ctx.error = error_code::syntax_error;
 1316|     17|                        return;
 1317|     17|                     }
 1318|  28.5k|                     else {
 1319|  28.5k|                        ++it;
 1320|  28.5k|                        ++p;
 1321|  28.5k|                     }
 1322|  43.3k|                  }
 1323|       |
 1324|    646|                  ctx.error = error_code::unexpected_end;
 1325|    646|               }
 1326|       |            }
 1327|       |            else {
 1328|       |               // raw_string
 1329|       |               auto start = it;
 1330|       |               skip_string_view(ctx, it, end);
 1331|       |               if (bool(ctx.error)) [[unlikely]]
 1332|       |                  return;
 1333|       |
 1334|       |               if (validate_utf8_span<Opts>(ctx, start, it)) [[unlikely]] {
 1335|       |                  return;
 1336|       |               }
 1337|       |
 1338|       |               value.assign(start, size_t(it - start));
 1339|       |               ++it;
 1340|       |            }
 1341|  1.54M|         }
 1342|  1.54M|      }
_ZN3glz14parse_ws_colonITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETkNS_10is_contextENS_7contextERPKcS4_EEbRT0_OT1_T2_:
  159|  1.54M|   {
  160|  1.54M|      if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (160:11): [True: 0, False: 1.54M]
  ------------------
  161|      0|         return true;
  162|      0|      }
  163|  1.54M|      if (match_invalid_end<':', Opts>(ctx, it, end)) {
  ------------------
  |  Branch (163:11): [True: 302, False: 1.54M]
  ------------------
  164|    302|         return true;
  165|    302|      }
  166|  1.54M|      if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (166:11): [True: 0, False: 1.54M]
  ------------------
  167|      0|         return true;
  168|      0|      }
  169|  1.54M|      return false;
  170|  1.54M|   }
_ZZN3glz4fromILj10ENSt3__13mapINS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEiNS1_4lessIS8_EENS6_INS1_4pairIKS8_iEEEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEETnNS_14string_literalEXtlNSJ_ILm1EEEEERSF_TkNS_10is_contextERNS_7contextERPKcSP_EEvOT1_OT2_OT3_T4_ENKUlOT_E_clIRS8_EEDaSZ_:
 3394|  17.6k|                  auto reading = [&](auto&& key) {
 3395|       |                     if constexpr (Opts.partial_read) {
 3396|       |                        if (auto element = value.find(key); element != value.end()) {
 3397|       |                           ++read_count;
 3398|       |                           parse<JSON>::op<ws_handled<Opts>()>(element->second, ctx, it, end);
 3399|       |                        }
 3400|       |                        else {
 3401|       |                           skip_value<JSON>::op<Opts>(ctx, it, end);
 3402|       |                        }
 3403|       |                     }
 3404|  17.6k|                     else {
 3405|  17.6k|                        parse<JSON>::op<ws_handled<Opts>()>(value[key], ctx, it, end);
 3406|  17.6k|                     }
 3407|  17.6k|                  };
_ZZN3glz16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT3_OT4_OT5_DpOT2_ENKUlTnmvE_clILm6EEEDav:
  484|  1.56k|            visit<N>([&]<size_t I>() { decode_index<Opts, T, I>(value, ctx, it, end, selected_index...); }, index);
_ZN3glz12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiELm6ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT2_OT4_OT5_OT6_DpOT3_:
  311|  1.56k|   {
  312|  1.56k|      static constexpr auto Key = get<I>(reflect<T>::keys);
  313|  1.56k|      static constexpr auto KeyWithEndQuote = join_v<Key, chars<"\"">>;
  314|  1.56k|      static constexpr auto Length = KeyWithEndQuote.size();
  315|       |
  316|  1.56k|      if (((it + Length) < end) && comparitor<KeyWithEndQuote>(it)) [[likely]] {
  ------------------
  |  Branch (316:11): [True: 1.56k, False: 3]
  |  Branch (316:36): [True: 1.55k, False: 6]
  ------------------
  317|  1.55k|         it += Length;
  318|  1.55k|         if constexpr (not Opts.null_terminated) {
  319|  1.55k|            if (it == end) [[unlikely]] {
  ------------------
  |  Branch (319:17): [True: 0, False: 1.55k]
  ------------------
  320|      0|               ctx.error = error_code::unexpected_end;
  321|      0|               return;
  322|      0|            }
  323|  1.55k|         }
  324|       |
  325|  1.55k|         if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (325:14): [True: 0, False: 1.55k]
  ------------------
  326|      0|            return;
  327|      0|         }
  328|  1.55k|         if (match_invalid_end<':', Opts>(ctx, it, end)) {
  ------------------
  |  Branch (328:14): [True: 27, False: 1.52k]
  ------------------
  329|     27|            return;
  330|     27|         }
  331|  1.52k|         if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (331:14): [True: 0, False: 1.52k]
  ------------------
  332|      0|            return;
  333|      0|         }
  334|       |
  335|       |         // The hash path has already consumed the whitespace before the value
  336|  1.52k|         decode_field_value<Opts, ws_handled<Opts>(), T, I>(value, ctx, it, end, selected_index...);
  337|  1.52k|      }
  338|      9|      else [[unlikely]] {
  339|      9|         decode_index_unknown_key<Opts, T>(value, ctx, it, end);
  340|      9|      }
  341|  1.56k|   }
_ZN3glz18decode_field_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnDaXtlS1_Lj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEEN12jsonrpc_fuzz8fuzz_apiELm6ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT1_E11reflectableISA_EEEvOT3_OT5_OT6_OT7_DpOT4_:
  245|  1.52k|   {
  246|       |      // Check for null value skipping on read
  247|       |      if constexpr (check_skip_null_members_on_read(Opts)) {
  248|       |         if (*it == 'n') {
  249|       |            ++it;
  250|       |            if constexpr (not Opts.null_terminated) {
  251|       |               if (it == end) [[unlikely]] {
  252|       |                  ctx.error = error_code::unexpected_end;
  253|       |                  return;
  254|       |               }
  255|       |            }
  256|       |            match<"ull", Opts>(ctx, it, end);
  257|       |            if (bool(ctx.error)) [[unlikely]]
  258|       |               return;
  259|       |            // Successfully matched "null", skip it
  260|       |            if constexpr (Opts.error_on_missing_keys || Opts.partial_read) {
  261|       |               ((selected_index = I), ...); // Mark as handled even if skipped
  262|       |            }
  263|       |            return;
  264|       |         }
  265|       |      }
  266|       |
  267|       |      if constexpr (skipped_by_meta<T, I, operation::parse>) {
  268|       |         skip_value<JSON>::op<Opts>(ctx, it, end);
  269|       |         if (bool(ctx.error)) [[unlikely]]
  270|       |            return; // Propagate error from skip_value
  271|       |      }
  272|  1.52k|      else {
  273|  1.52k|         using V = refl_t<T, I>;
  274|       |
  275|       |         if constexpr (const_value_v<V>) {
  276|       |            if constexpr (check_error_on_const_read(Opts)) {
  277|       |               ctx.error = error_code::attempt_const_read;
  278|       |            }
  279|       |            else {
  280|       |               // do not read anything into the const value
  281|       |               skip_value<JSON>::op<Opts>(ctx, it, end);
  282|       |            }
  283|       |         }
  284|       |         else if constexpr (is_function_ptr_or_ref<V>) {
  285|       |            // Function pointers cannot be deserialized from JSON.
  286|       |            // When write_function_pointers is enabled the writer emits a type-name string,
  287|       |            // but there is nothing meaningful to reconstruct on read — just skip the value.
  288|       |            // When write_function_pointers is off the key is never written, so this branch
  289|       |            // is unreachable in that case.
  290|       |            skip_value<JSON>::op<Opts>(ctx, it, end);
  291|       |         }
  292|       |         else if constexpr (glaze_object_t<T>) {
  293|       |            from<JSON, std::remove_cvref_t<V>>::template op<FieldOpts>(get_member(value, get<I>(reflect<T>::values)),
  294|       |                                                                       ctx, it, end);
  295|       |         }
  296|  1.52k|         else {
  297|  1.52k|            from<JSON, std::remove_cvref_t<V>>::template op<FieldOpts>(get_member(value, get<I>(to_tie(value))), ctx,
  298|  1.52k|                                                                       it, end);
  299|  1.52k|         }
  300|  1.52k|      }
  301|       |
  302|       |      // The key was present and handled, even when the value itself was skipped
  303|       |      if constexpr (Opts.error_on_missing_keys || Opts.partial_read) {
  304|       |         ((selected_index = I), ...);
  305|       |      }
  306|  1.52k|   }
_ZN3glz4fromILj10ENSt3__18optionalIdEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEERS3_TkNS_10is_contextERNS_7contextERPKcSB_EEvOT0_OT1_OT2_T3_:
 5088|  1.52k|      {
 5089|  1.52k|         constexpr auto Opts = ws_handled_off<Options>();
 5090|       |         if constexpr (!check_ws_handled(Options)) {
 5091|       |            if (skip_ws<Opts>(ctx, it, end)) {
 5092|       |               return;
 5093|       |            }
 5094|       |         }
 5095|       |
 5096|  1.52k|         if (*it == 'n') {
  ------------------
  |  Branch (5096:14): [True: 644, False: 884]
  ------------------
 5097|    644|            ++it;
 5098|    644|            if constexpr (not Opts.null_terminated) {
 5099|    644|               if (it == end) [[unlikely]] {
  ------------------
  |  Branch (5099:20): [True: 0, False: 644]
  ------------------
 5100|      0|                  ctx.error = error_code::unexpected_end;
 5101|      0|                  return;
 5102|      0|               }
 5103|    644|            }
 5104|    644|            match<"ull", Opts>(ctx, it, end);
 5105|    644|            if (bool(ctx.error)) [[unlikely]]
  ------------------
  |  Branch (5105:17): [True: 33, False: 611]
  ------------------
 5106|     33|               return;
 5107|    611|            if constexpr (requires { value.reset(); }) {
 5108|    611|               value.reset();
 5109|    611|            }
 5110|    611|         }
 5111|    884|         else {
 5112|    884|            if constexpr (nullable_value_t<T>) {
 5113|    884|               if (not value.has_value()) {
  ------------------
  |  Branch (5113:20): [True: 462, False: 422]
  ------------------
 5114|       |                  if constexpr (constructible<T>) {
 5115|       |                     value = meta_construct_v<T>();
 5116|       |                  }
 5117|    462|                  else if constexpr (requires { value.emplace(); }) {
 5118|    462|                     value.emplace();
 5119|       |                  }
 5120|       |                  else {
 5121|       |                     static_assert(false_v<T>,
 5122|       |                                   "Your nullable type must have `emplace()` or be glz::meta constructible, or "
 5123|       |                                   "create a custom glz::from specialization");
 5124|       |                  }
 5125|    462|               }
 5126|    884|               parse<JSON>::op<Opts>(value.value(), ctx, it, end);
 5127|       |            }
 5128|       |            else {
 5129|       |               if (!value) {
 5130|       |                  if (!nullable_emplace<Opts>(value, ctx)) {
 5131|       |                     return;
 5132|       |                  }
 5133|       |               }
 5134|       |               parse<JSON>::op<Opts>(*value, ctx, it, end);
 5135|       |            }
 5136|    884|         }
 5137|  1.52k|      }
_ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERdTkNS_10is_contextERNS_7contextERPKcS8_EEvOT0_OT1_OT2_T3_:
   49|  3.44k|      {
   50|       |         if constexpr (const_value_v<T>) {
   51|       |            if constexpr (check_error_on_const_read(Opts)) {
   52|       |               ctx.error = error_code::attempt_const_read;
   53|       |            }
   54|       |            else {
   55|       |               // do not read anything into the const value
   56|       |               skip_value<JSON>::op<Opts>(std::forward<Ctx>(ctx), std::forward<It0>(it), end);
   57|       |            }
   58|       |         }
   59|  3.44k|         else {
   60|  3.44k|            using V = std::remove_cvref_t<T>;
   61|  3.44k|            from<JSON, V>::template op<Opts>(std::forward<T>(value), std::forward<Ctx>(ctx), std::forward<It0>(it),
   62|  3.44k|                                             end);
   63|  3.44k|         }
   64|  3.44k|      }
_ZN3glz4fromILj10EdE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERPKcRdTkNS_10is_contextERNS_7contextES5_EEvOT1_OT2_OT0_T3_:
  767|  3.44k|      {
  768|       |         if constexpr (check_quoted_num(Opts)) {
  769|       |            if (skip_ws<Opts>(ctx, it, end)) {
  770|       |               return;
  771|       |            }
  772|       |            if (match_invalid_end<'"', Opts>(ctx, it, end)) {
  773|       |               return;
  774|       |            }
  775|       |         }
  776|       |
  777|  3.44k|         if constexpr (!check_ws_handled(Opts)) {
  778|  3.44k|            if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (778:17): [True: 0, False: 3.44k]
  ------------------
  779|      0|               return;
  780|      0|            }
  781|  3.44k|         }
  782|       |
  783|  3.44k|         using V = std::decay_t<decltype(value)>;
  784|       |         if constexpr (int_t<V>) {
  785|       |            static_assert(sizeof(*it) == sizeof(char));
  786|       |
  787|       |            if constexpr (Opts.null_terminated) {
  788|       |               if (not glz::atoi(value, it)) [[unlikely]] {
  789|       |                  ctx.error = error_code::parse_number_failure;
  790|       |                  return;
  791|       |               }
  792|       |            }
  793|       |            else {
  794|       |               if (not glz::atoi(value, it, end)) [[unlikely]] {
  795|       |                  ctx.error = error_code::parse_number_failure;
  796|       |                  return;
  797|       |               }
  798|       |            }
  799|       |         }
  800|  3.44k|         else {
  801|       |// float128_t requires std::from_chars for floating-point, unavailable on older Apple platforms (iOS < 16.3)
  802|  3.44k|#if !defined(_LIBCPP_VERSION) || defined(_LIBCPP_AVAILABILITY_HAS_TO_CHARS_FLOATING_POINT)
  803|       |            if constexpr (is_float128<V>) {
  804|       |               auto [ptr, ec] = std::from_chars(it, end, value);
  805|       |               if (ec != std::errc()) {
  806|       |                  ctx.error = error_code::parse_number_failure;
  807|       |                  return;
  808|       |               }
  809|       |               it = ptr;
  810|       |            }
  811|       |            else
  812|       |#endif
  813|  3.44k|            {
  814|       |               if constexpr (std::is_volatile_v<std::remove_reference_t<decltype(value)>>) {
  815|       |                  // Hardware may interact with value changes, so we parse into a temporary and assign in one
  816|       |                  // place
  817|       |                  V temp;
  818|       |                  if constexpr (is_size_optimized(Opts)) {
  819|       |                     auto [ptr, ec] = simple_float::from_chars<Opts.null_terminated>(it, end, temp);
  820|       |                     if (ec != std::errc{}) [[unlikely]] {
  821|       |                        ctx.error = error_code::parse_number_failure;
  822|       |                        return;
  823|       |                     }
  824|       |                     it = ptr;
  825|       |                  }
  826|       |                  else {
  827|       |                     auto [ptr, ec] = glz::from_chars<Opts.null_terminated>(it, end, temp);
  828|       |                     if (ec != std::errc()) [[unlikely]] {
  829|       |                        ctx.error = error_code::parse_number_failure;
  830|       |                        return;
  831|       |                     }
  832|       |                     it = ptr;
  833|       |                  }
  834|       |                  value = temp;
  835|       |               }
  836|  3.44k|               else {
  837|       |                  if constexpr (is_size_optimized(Opts)) {
  838|       |                     auto [ptr, ec] = simple_float::from_chars<Opts.null_terminated>(it, end, value);
  839|       |                     if (ec != std::errc{}) [[unlikely]] {
  840|       |                        ctx.error = error_code::parse_number_failure;
  841|       |                        return;
  842|       |                     }
  843|       |                     it = ptr;
  844|       |                  }
  845|  3.44k|                  else {
  846|  3.44k|                     auto [ptr, ec] = glz::from_chars<Opts.null_terminated>(it, end, value);
  847|  3.44k|                     if (ec != std::errc()) [[unlikely]] {
  ------------------
  |  Branch (847:26): [True: 540, False: 2.90k]
  ------------------
  848|    540|                        ctx.error = error_code::parse_number_failure;
  849|    540|                        return;
  850|    540|                     }
  851|  2.90k|                     it = ptr;
  852|  2.90k|                  }
  853|  3.44k|               }
  854|  3.44k|            }
  855|  3.44k|         }
  856|       |
  857|       |         if constexpr (check_quoted_num(Opts)) {
  858|       |            if constexpr (not Opts.null_terminated) {
  859|       |               if (it == end) [[unlikely]] {
  860|       |                  ctx.error = error_code::unexpected_end;
  861|       |                  return;
  862|       |               }
  863|       |            }
  864|       |            if (match<'"'>(ctx, it)) {
  865|       |               return;
  866|       |            }
  867|       |            if constexpr (not Opts.null_terminated) {
  868|       |               if (it == end) {
  869|       |                  ctx.error = error_code::end_reached;
  870|       |                  return;
  871|       |               }
  872|       |            }
  873|       |         }
  874|  3.44k|         else {
  875|  3.44k|            if constexpr (not Opts.null_terminated) {
  876|  3.44k|               if (it == end) {
  ------------------
  |  Branch (876:20): [True: 1.75k, False: 1.69k]
  ------------------
  877|  1.75k|                  ctx.error = error_code::end_reached;
  878|  1.75k|                  return;
  879|  1.75k|               }
  880|  3.44k|            }
  881|  3.44k|         }
  882|  3.44k|      }
_ZZN3glz16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT3_OT4_OT5_DpOT2_ENKUlTnmvE_clILm7EEEDav:
  484|    734|            visit<N>([&]<size_t I>() { decode_index<Opts, T, I>(value, ctx, it, end, selected_index...); }, index);
_ZN3glz12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiELm7ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT2_OT4_OT5_OT6_DpOT3_:
  311|    734|   {
  312|    734|      static constexpr auto Key = get<I>(reflect<T>::keys);
  313|    734|      static constexpr auto KeyWithEndQuote = join_v<Key, chars<"\"">>;
  314|    734|      static constexpr auto Length = KeyWithEndQuote.size();
  315|       |
  316|    734|      if (((it + Length) < end) && comparitor<KeyWithEndQuote>(it)) [[likely]] {
  ------------------
  |  Branch (316:11): [True: 729, False: 5]
  |  Branch (316:36): [True: 716, False: 13]
  ------------------
  317|    716|         it += Length;
  318|    716|         if constexpr (not Opts.null_terminated) {
  319|    716|            if (it == end) [[unlikely]] {
  ------------------
  |  Branch (319:17): [True: 0, False: 716]
  ------------------
  320|      0|               ctx.error = error_code::unexpected_end;
  321|      0|               return;
  322|      0|            }
  323|    716|         }
  324|       |
  325|    716|         if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (325:14): [True: 0, False: 716]
  ------------------
  326|      0|            return;
  327|      0|         }
  328|    716|         if (match_invalid_end<':', Opts>(ctx, it, end)) {
  ------------------
  |  Branch (328:14): [True: 20, False: 696]
  ------------------
  329|     20|            return;
  330|     20|         }
  331|    696|         if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (331:14): [True: 0, False: 696]
  ------------------
  332|      0|            return;
  333|      0|         }
  334|       |
  335|       |         // The hash path has already consumed the whitespace before the value
  336|    696|         decode_field_value<Opts, ws_handled<Opts>(), T, I>(value, ctx, it, end, selected_index...);
  337|    696|      }
  338|     18|      else [[unlikely]] {
  339|     18|         decode_index_unknown_key<Opts, T>(value, ctx, it, end);
  340|     18|      }
  341|    734|   }
_ZN3glz18decode_field_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnDaXtlS1_Lj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEEN12jsonrpc_fuzz8fuzz_apiELm7ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT1_E11reflectableISA_EEEvOT3_OT5_OT6_OT7_DpOT4_:
  245|    696|   {
  246|       |      // Check for null value skipping on read
  247|       |      if constexpr (check_skip_null_members_on_read(Opts)) {
  248|       |         if (*it == 'n') {
  249|       |            ++it;
  250|       |            if constexpr (not Opts.null_terminated) {
  251|       |               if (it == end) [[unlikely]] {
  252|       |                  ctx.error = error_code::unexpected_end;
  253|       |                  return;
  254|       |               }
  255|       |            }
  256|       |            match<"ull", Opts>(ctx, it, end);
  257|       |            if (bool(ctx.error)) [[unlikely]]
  258|       |               return;
  259|       |            // Successfully matched "null", skip it
  260|       |            if constexpr (Opts.error_on_missing_keys || Opts.partial_read) {
  261|       |               ((selected_index = I), ...); // Mark as handled even if skipped
  262|       |            }
  263|       |            return;
  264|       |         }
  265|       |      }
  266|       |
  267|       |      if constexpr (skipped_by_meta<T, I, operation::parse>) {
  268|       |         skip_value<JSON>::op<Opts>(ctx, it, end);
  269|       |         if (bool(ctx.error)) [[unlikely]]
  270|       |            return; // Propagate error from skip_value
  271|       |      }
  272|    696|      else {
  273|    696|         using V = refl_t<T, I>;
  274|       |
  275|       |         if constexpr (const_value_v<V>) {
  276|       |            if constexpr (check_error_on_const_read(Opts)) {
  277|       |               ctx.error = error_code::attempt_const_read;
  278|       |            }
  279|       |            else {
  280|       |               // do not read anything into the const value
  281|       |               skip_value<JSON>::op<Opts>(ctx, it, end);
  282|       |            }
  283|       |         }
  284|       |         else if constexpr (is_function_ptr_or_ref<V>) {
  285|       |            // Function pointers cannot be deserialized from JSON.
  286|       |            // When write_function_pointers is enabled the writer emits a type-name string,
  287|       |            // but there is nothing meaningful to reconstruct on read — just skip the value.
  288|       |            // When write_function_pointers is off the key is never written, so this branch
  289|       |            // is unreachable in that case.
  290|       |            skip_value<JSON>::op<Opts>(ctx, it, end);
  291|       |         }
  292|       |         else if constexpr (glaze_object_t<T>) {
  293|       |            from<JSON, std::remove_cvref_t<V>>::template op<FieldOpts>(get_member(value, get<I>(reflect<T>::values)),
  294|       |                                                                       ctx, it, end);
  295|       |         }
  296|    696|         else {
  297|    696|            from<JSON, std::remove_cvref_t<V>>::template op<FieldOpts>(get_member(value, get<I>(to_tie(value))), ctx,
  298|    696|                                                                       it, end);
  299|    696|         }
  300|    696|      }
  301|       |
  302|       |      // The key was present and handled, even when the value itself was skipped
  303|       |      if constexpr (Opts.error_on_missing_keys || Opts.partial_read) {
  304|       |         ((selected_index = I), ...);
  305|       |      }
  306|    696|   }
_ZN3glz4fromILj10ENSt3__17variantIJNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEN12jsonrpc_fuzz6amountEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEERSB_TkNS_10is_contextERNS_7contextERPKcSJ_EEvOT0_OT1_OT2_T3_:
 4065|    696|      {
 4066|       |         if constexpr (tagging == variant_tagging_kind::adjacent) {
 4067|       |            read_adjacent<Options>(value, ctx, it, end);
 4068|       |         }
 4069|    696|         else {
 4070|    696|            read_deduced<Options>(value, ctx, it, end);
 4071|    696|         }
 4072|    696|      }
_ZN3glz4fromILj10ENSt3__17variantIJNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEN12jsonrpc_fuzz6amountEEEEE12read_deducedITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEERSB_TkNS_10is_contextERNS_7contextERPKcSJ_EEvOT0_OT1_OT2_T3_:
 4076|    696|      {
 4077|    696|         constexpr auto Opts = ws_handled_off<Options>();
 4078|    696|         if constexpr (variant_is_auto_deducible<T>()) {
 4079|       |            if constexpr (not check_ws_handled(Options)) {
 4080|       |               if (skip_ws<Opts>(ctx, it, end)) {
 4081|       |                  return;
 4082|       |               }
 4083|       |            }
 4084|       |
 4085|    696|            switch (*it) {
 4086|      3|            case '\0':
  ------------------
  |  Branch (4086:13): [True: 3, False: 693]
  ------------------
 4087|      3|               ctx.error = error_code::unexpected_end;
 4088|      3|               return;
 4089|     35|            case '{': {
  ------------------
  |  Branch (4089:13): [True: 35, False: 661]
  ------------------
 4090|       |               // This branch consumes the brace itself and hands the object to a reader with
 4091|       |               // `opening_handled`, which therefore does not count the level -- but does release it at
 4092|       |               // the closing brace. So the level is taken here, in both buffer modes, and paid back by
 4093|       |               // the reader below.
 4094|     35|               if (enter_depth(ctx)) [[unlikely]] {
  ------------------
  |  Branch (4094:20): [True: 0, False: 35]
  ------------------
 4095|      0|                  return;
 4096|      0|               }
 4097|       |
 4098|     35|               ++it;
 4099|     35|               if constexpr (not Opts.null_terminated) {
 4100|     35|                  if (it == end) [[unlikely]] {
  ------------------
  |  Branch (4100:23): [True: 0, False: 35]
  ------------------
 4101|      0|                     ctx.error = error_code::unexpected_end;
 4102|      0|                     return;
 4103|      0|                  }
 4104|     35|               }
 4105|     35|               using type_counts = variant_type_count<T>;
 4106|     35|               constexpr auto n_object_candidates = variant_object_candidate_count_v<Opts, T>;
 4107|       |               if constexpr (n_object_candidates < 1) {
 4108|       |                  ctx.error = error_code::no_matching_variant_type;
 4109|       |                  return;
 4110|       |               }
 4111|     35|               else if constexpr (n_object_candidates == 1 && tag_v<T>.empty()) {
 4112|     35|                  constexpr auto first_idx = variant_first_object_candidate_v<Opts, T>;
 4113|     35|                  using V = std::variant_alternative_t<first_idx, T>;
 4114|     35|                  if (!std::holds_alternative<V>(value)) value = V{};
  ------------------
  |  Branch (4114:23): [True: 15, False: 20]
  ------------------
 4115|     35|                  parse<JSON>::op<opening_handled<Opts>()>(std::get<V>(value), ctx, it, end);
 4116|     35|                  return;
 4117|       |               }
 4118|       |               else {
 4119|       |                  auto possible_types = bit_array<std::variant_size_v<T>>{}.flip();
 4120|       |                  static constexpr auto& deduction_bits = variant_deduction_bits<T>;
 4121|       |                  static constexpr size_t deduction_key_count = variant_deduction_key_count<T>;
 4122|       |                  static constexpr auto tag_literal = string_literal_from_view<tag_v<T>.size()>(tag_v<T>);
 4123|       |
 4124|       |                  // Track if we've encountered a tag and what value it had
 4125|       |                  std::optional<size_t> tag_specified_index{};
 4126|       |
 4127|       |                  if (skip_ws<Opts>(ctx, it, end)) {
 4128|       |                     return;
 4129|       |                  }
 4130|       |                  // Once the reader knows which alternative this object holds it may have to read
 4131|       |                  // it again from here. Anchor the position rather than keep the pointer: the scan
 4132|       |                  // below skips values, and a streaming skip refills, which moves the window out
 4133|       |                  // from under a raw pointer (see rewind_anchor).
 4134|       |                  auto start = make_rewind_anchor(ctx, it);
 4135|       |                  bool first_key = true;
 4136|       |                  // Parse bifurcation for tagged variants:
 4137|       |                  //
 4138|       |                  // Without this optimization, tagged variant parsing always uses two passes:
 4139|       |                  //   1. Scan all keys to find the tag (e.g. "type"), skipping values
 4140|       |                  //   2. Reset `it = start` and re-parse the entire object into the resolved type
 4141|       |                  //
 4142|       |                  // When the tag is the first key, the second pass redundantly re-reads every
 4143|       |                  // field that follows it. This lambda avoids that: if the tag was the first key,
 4144|       |                  // it advances past the trailing comma so the object parser picks up at the
 4145|       |                  // second field. If the tag was found later, it falls back to the full re-parse.
 4146|       |                  //
 4147|       |                  // One exception: if the tag name is also a field on the resolved struct
 4148|       |                  // (contains_tag), we must re-parse regardless so the value is stored in
 4149|       |                  // the struct field. This override is applied inside each std::visit lambda.
 4150|       |                  //
 4151|       |                  // Either way the rewind can fail under a streaming read: the window only holds so
 4152|       |                  // much, and an object wider than it has no start left to return to.
 4153|       |                  auto position_after_tag = [&] {
 4154|       |                     if (first_key) {
 4155|       |                        if (*it == ',') ++it; // skip comma; handles tag-only objects where *it == '}'
 4156|       |                        return true;
 4157|       |                     }
 4158|       |                     return start.rewind(ctx, it, end); // tag came later, re-parse from the beginning
 4159|       |                  };
 4160|       |                  // `first_key` also answers "were we reset to the object start", which is what
 4161|       |                  // position_after_tag does for every key but the first.
 4162|       |                  for (; *it != '}'; first_key = false) {
 4163|       |                     if (!first_key) {
 4164|       |                        if (match_invalid_end<',', Opts>(ctx, it, end)) {
 4165|       |                           return;
 4166|       |                        }
 4167|       |                     }
 4168|       |
 4169|       |                     if (skip_ws<Opts>(ctx, it, end)) {
 4170|       |                        return;
 4171|       |                     }
 4172|       |                     if (match_invalid_end<'"', Opts>(ctx, it, end)) {
 4173|       |                        return;
 4174|       |                     }
 4175|       |
 4176|       |                     auto* key_start = it;
 4177|       |                     skip_string_view(ctx, it, end);
 4178|       |                     if (bool(ctx.error)) [[unlikely]]
 4179|       |                        return;
 4180|       |                     if (validate_utf8_span<Opts>(ctx, key_start, it)) [[unlikely]]
 4181|       |                        return;
 4182|       |                     const sv key = {key_start, size_t(it - key_start)};
 4183|       |
 4184|       |                     if (match_invalid_end<'"', Opts>(ctx, it, end)) {
 4185|       |                        return;
 4186|       |                     }
 4187|       |
 4188|       |                     if constexpr (deduction_key_count > 0) {
 4189|       |                        // We first check if a tag is defined and see if the key matches the tag
 4190|       |                        if constexpr (not tag_v<T>.empty()) {
 4191|       |                           if (key == tag_v<T>) {
 4192|       |                              if (parse_ws_colon<Opts>(ctx, it, end)) {
 4193|       |                                 return;
 4194|       |                              }
 4195|       |
 4196|       |                              using id_type = std::decay_t<decltype(ids_v<T>[0])>;
 4197|       |
 4198|       |                              std::conditional_t<std::integral<id_type>, id_type, sv> type_id{};
 4199|       |                              if constexpr (std::integral<id_type>) {
 4200|       |                                 from<JSON, id_type>::template op<ws_handled<Opts>()>(type_id, ctx, it, end);
 4201|       |                              }
 4202|       |                              else {
 4203|       |                                 // The id is turned into an index below and never leaves this
 4204|       |                                 // reader, so the view of the window it borrows cannot outlive it.
 4205|       |                                 parse_transient_string_view<ws_handled<Opts>()>(type_id, ctx, it, end);
 4206|       |                              }
 4207|       |                              if (bool(ctx.error)) [[unlikely]]
 4208|       |                                 return;
 4209|       |                              if (skip_ws<Opts>(ctx, it, end)) {
 4210|       |                                 return;
 4211|       |                              }
 4212|       |                              if (!(*it == ',' || *it == '}')) [[unlikely]] {
 4213|       |                                 ctx.error = error_code::syntax_error;
 4214|       |                                 return;
 4215|       |                              }
 4216|       |
 4217|       |                              size_t type_index;
 4218|       |                              if constexpr (std::integral<id_type>) {
 4219|       |                                 type_index = variant_id_to_index<T>::op(type_id);
 4220|       |                              }
 4221|       |                              else {
 4222|       |                                 type_index = variant_id_to_index<T>::op(
 4223|       |                                    type_id.data(), type_id.data() + type_id.size(), type_id.size());
 4224|       |                              }
 4225|       |                              if (type_index < ids_v<T>.size()) [[likely]] {
 4226|       |                                 // Check if the deduced types include the tag-specified type
 4227|       |                                 // If not, the tag doesn't match the fields
 4228|       |                                 // We're already inside if constexpr (deduction_registry.size()), so we know deduction
 4229|       |                                 // is happening. At this point, possible_types has been narrowed by field deduction.
 4230|       |                                 // Check if the tag-specified type is still possible
 4231|       |                                 const bool type_is_possible = possible_types[type_index];
 4232|       |                                 if (!type_is_possible) {
 4233|       |                                    // Tag specifies a type that doesn't match the fields seen so far
 4234|       |                                    ctx.error = error_code::no_matching_variant_type;
 4235|       |                                    return;
 4236|       |                                 }
 4237|       |
 4238|       |                                 if (!position_after_tag()) return;
 4239|       |                                 tag_specified_index = type_index; // Store the tag-specified type
 4240|       |                                 if (value.index() != type_index) emplace_runtime_variant(value, type_index);
 4241|       |                                 std::visit(
 4242|       |                                    [&](auto&& v) {
 4243|       |                                       using V = std::decay_t<decltype(v)>;
 4244|       |                                       constexpr bool is_object =
 4245|       |                                          (glaze_object_t<V> || reflectable<V>) && not custom_read<V>;
 4246|       |                                       if constexpr (variant_unit_alternative<V>) {
 4247|       |                                          // A unit alternative carries no data; its object holds only the
 4248|       |                                          // discriminator. Consume that body through an empty reflected object so
 4249|       |                                          // unknown-key policy and terminator handling match every other alternative.
 4250|       |                                          detail::variant_unit_body unit_body{};
 4251|       |                                          from<JSON, detail::variant_unit_body>::template op<opening_handled<Opts>(),
 4252|       |                                                                                             tag_literal>(unit_body,
 4253|       |                                                                                                          ctx, it, end);
 4254|       |                                       }
 4255|       |                                       else if constexpr (is_object) {
 4256|       |                                          if constexpr (contains_tag<V, tag_literal>()) {
 4257|       |                                             // tag is a struct field, must re-parse
 4258|       |                                             if (!start.rewind(ctx, it, end)) return;
 4259|       |                                          }
 4260|       |                                          from<JSON, V>::template op<opening_handled<Opts>(), tag_literal>(v, ctx, it,
 4261|       |                                                                                                           end);
 4262|       |                                       }
 4263|       |                                       else if constexpr (is_memory_object<V>) {
 4264|       |                                          if (!v) {
 4265|       |                                             if constexpr (is_specialization_v<V, std::optional>) {
 4266|       |                                                if constexpr (requires { v.emplace(); }) {
 4267|       |                                                   v.emplace();
 4268|       |                                                }
 4269|       |                                                else {
 4270|       |                                                   v = typename V::value_type{};
 4271|       |                                                }
 4272|       |                                             }
 4273|       |                                             else if constexpr (is_specialization_v<V, std::unique_ptr>)
 4274|       |                                                v = std::make_unique<typename V::element_type>();
 4275|       |                                             else if constexpr (is_specialization_v<V, std::shared_ptr>)
 4276|       |                                                v = std::make_shared<typename V::element_type>();
 4277|       |                                             else if constexpr (constructible<V>) {
 4278|       |                                                v = meta_construct_v<V>();
 4279|       |                                             }
 4280|       |                                             else if constexpr (std::is_pointer_v<V> &&
 4281|       |                                                                can_allocate_raw_pointer<Opts,
 4282|       |                                                                                         std::decay_t<decltype(ctx)>>) {
 4283|       |                                                if (!try_allocate_raw_pointer<Opts>(v, ctx)) {
 4284|       |                                                   return;
 4285|       |                                                }
 4286|       |                                             }
 4287|       |                                             else {
 4288|       |                                                ctx.error = error_code::invalid_nullable_read;
 4289|       |                                                return;
 4290|       |                                                // Cannot read into unset nullable that is not std::optional,
 4291|       |                                                // std::unique_ptr, or std::shared_ptr
 4292|       |                                             }
 4293|       |                                          }
 4294|       |                                          if constexpr (contains_tag<memory_type<V>, tag_literal>()) {
 4295|       |                                             // tag is a struct field, must re-parse
 4296|       |                                             if (!start.rewind(ctx, it, end)) return;
 4297|       |                                          }
 4298|       |                                          from<JSON, memory_type<V>>::template op<opening_handled<Opts>(), tag_literal>(
 4299|       |                                             *v, ctx, it, end);
 4300|       |                                       }
 4301|       |                                       else if constexpr (custom_read<V>) {
 4302|       |                                          // Custom handlers parse the remaining body themselves and do not
 4303|       |                                          // accept the tag template parameter; the tag was already consumed.
 4304|       |                                          // This only works when the tag was the first key. If it came later,
 4305|       |                                          // we were reset to the object start and the custom handler would
 4306|       |                                          // absorb the tag, so error rather than corrupt the value.
 4307|       |                                          if (!first_key) {
 4308|       |                                             ctx.error = error_code::feature_not_supported;
 4309|       |                                             ctx.custom_error_message =
 4310|       |                                                "the tag must be the first key for a custom variant alternative";
 4311|       |                                             return;
 4312|       |                                          }
 4313|       |                                          from<JSON, V>::template op<opening_handled<Opts>()>(v, ctx, it, end);
 4314|       |                                       }
 4315|       |                                    },
 4316|       |                                    value);
 4317|       |
 4318|       |                                 return; // we've decoded our target type
 4319|       |                              }
 4320|       |                              else [[unlikely]] {
 4321|       |                                 // Check if we have a default type (ids array shorter than variant)
 4322|       |                                 constexpr auto ids_size = ids_v<T>.size();
 4323|       |                                 constexpr auto variant_size = std::variant_size_v<T>;
 4324|       |                                 if constexpr (ids_size < variant_size) {
 4325|       |                                    // Use the first unlabeled type as the default
 4326|       |                                    const auto default_type_index = ids_size;
 4327|       |
 4328|       |                                    if (!position_after_tag()) return;
 4329|       |                                    tag_specified_index = default_type_index; // Store the default type index
 4330|       |                                    if (value.index() != default_type_index)
 4331|       |                                       emplace_runtime_variant(value, default_type_index);
 4332|       |                                    std::visit(
 4333|       |                                       [&](auto&& v) {
 4334|       |                                          using V = std::decay_t<decltype(v)>;
 4335|       |                                          constexpr bool is_object =
 4336|       |                                             (glaze_object_t<V> || reflectable<V>) && not custom_read<V>;
 4337|       |                                          if constexpr (variant_unit_alternative<V>) {
 4338|       |                                             // A unit alternative carries no data; its object holds only the
 4339|       |                                             // discriminator. Consume that body through an empty reflected object so
 4340|       |                                             // unknown-key policy and terminator handling match every other
 4341|       |                                             // alternative.
 4342|       |                                             detail::variant_unit_body unit_body{};
 4343|       |                                             from<JSON, detail::variant_unit_body>::template op<opening_handled<Opts>(),
 4344|       |                                                                                                tag_literal>(
 4345|       |                                                unit_body, ctx, it, end);
 4346|       |                                          }
 4347|       |                                          else if constexpr (is_object) {
 4348|       |                                             if constexpr (contains_tag<V, tag_literal>()) {
 4349|       |                                                // tag is a struct field, must re-parse
 4350|       |                                                if (!start.rewind(ctx, it, end)) return;
 4351|       |                                             }
 4352|       |                                             from<JSON, V>::template op<opening_handled<Opts>()>(v, ctx, it, end);
 4353|       |                                          }
 4354|       |                                          else if constexpr (is_memory_object<V>) {
 4355|       |                                             if (!v) {
 4356|       |                                                if constexpr (is_specialization_v<V, std::optional>) {
 4357|       |                                                   if constexpr (requires { v.emplace(); }) {
 4358|       |                                                      v.emplace();
 4359|       |                                                   }
 4360|       |                                                   else {
 4361|       |                                                      v = typename V::value_type{};
 4362|       |                                                   }
 4363|       |                                                }
 4364|       |                                                else if constexpr (is_specialization_v<V, std::unique_ptr>)
 4365|       |                                                   v = std::make_unique<typename V::element_type>();
 4366|       |                                                else if constexpr (is_specialization_v<V, std::shared_ptr>)
 4367|       |                                                   v = std::make_shared<typename V::element_type>();
 4368|       |                                                else if constexpr (constructible<V>) {
 4369|       |                                                   v = meta_construct_v<V>();
 4370|       |                                                }
 4371|       |                                                else if constexpr (std::is_pointer_v<V> &&
 4372|       |                                                                   can_allocate_raw_pointer<
 4373|       |                                                                      Opts, std::decay_t<decltype(ctx)>>) {
 4374|       |                                                   if (!try_allocate_raw_pointer<Opts>(v, ctx)) {
 4375|       |                                                      return;
 4376|       |                                                   }
 4377|       |                                                }
 4378|       |                                                else {
 4379|       |                                                   ctx.error = error_code::invalid_nullable_read;
 4380|       |                                                   return;
 4381|       |                                                }
 4382|       |                                             }
 4383|       |                                             if constexpr (contains_tag<memory_type<V>, tag_literal>()) {
 4384|       |                                                // tag is a struct field, must re-parse
 4385|       |                                                if (!start.rewind(ctx, it, end)) return;
 4386|       |                                             }
 4387|       |                                             from<JSON, memory_type<V>>::template op<opening_handled<Opts>()>(*v, ctx,
 4388|       |                                                                                                              it, end);
 4389|       |                                          }
 4390|       |                                          else if constexpr (custom_read<V>) {
 4391|       |                                             // Custom handlers parse the remaining body themselves; this only
 4392|       |                                             // works when the tag was the first key (see above). If it came
 4393|       |                                             // later we were reset to the object start, so error rather than
 4394|       |                                             // let the custom handler absorb the tag.
 4395|       |                                             if (!first_key) {
 4396|       |                                                ctx.error = error_code::feature_not_supported;
 4397|       |                                                ctx.custom_error_message =
 4398|       |                                                   "the tag must be the first key for a custom variant alternative";
 4399|       |                                                return;
 4400|       |                                             }
 4401|       |                                             from<JSON, V>::template op<opening_handled<Opts>()>(v, ctx, it, end);
 4402|       |                                          }
 4403|       |                                       },
 4404|       |                                       value);
 4405|       |
 4406|       |                                    return;
 4407|       |                                 }
 4408|       |                                 else {
 4409|       |                                    ctx.error = error_code::no_matching_variant_type;
 4410|       |                                    ctx.custom_error_message = variant_ids_string_v<T>;
 4411|       |                                    return;
 4412|       |                                 }
 4413|       |                              }
 4414|       |                           }
 4415|       |                        }
 4416|       |
 4417|       |                        // Inline decode_hash lookup for variant deduction
 4418|       |                        using deduction_keys_t = keys_wrapper<variant_deduction_keys<T>>;
 4419|       |                        constexpr auto& DeductionHashInfo = hash_info<deduction_keys_t>;
 4420|       |                        const auto deduction_index =
 4421|       |                           decode_hash_with_size<JSON, deduction_keys_t, DeductionHashInfo, DeductionHashInfo.type>::op(
 4422|       |                              key.data(), key.data() + key.size(), key.size());
 4423|       |                        if (deduction_index < deduction_key_count && variant_deduction_keys<T>[deduction_index] == key)
 4424|       |                           [[likely]] {
 4425|       |                           possible_types &= deduction_bits[deduction_index];
 4426|       |                        }
 4427|       |                        else if constexpr (Opts.error_on_unknown_keys) {
 4428|       |                           ctx.error = error_code::unknown_key;
 4429|       |                           return;
 4430|       |                        }
 4431|       |                     }
 4432|       |                     else if constexpr (not tag_v<T>.empty()) {
 4433|       |                        // empty object case for variant, if there are no normal elements
 4434|       |                        if (key == tag_v<T>) {
 4435|       |                           if (parse_ws_colon<Opts>(ctx, it, end)) {
 4436|       |                              return;
 4437|       |                           }
 4438|       |
 4439|       |                           // The id is turned into an index below and never leaves this reader,
 4440|       |                           // so the view of the window it borrows cannot outlive that window.
 4441|       |                           std::string_view type_id{};
 4442|       |                           parse_transient_string_view<ws_handled<Opts>()>(type_id, ctx, it, end);
 4443|       |                           if (bool(ctx.error)) [[unlikely]]
 4444|       |                              return;
 4445|       |                           if (skip_ws<Opts>(ctx, it, end)) {
 4446|       |                              return;
 4447|       |                           }
 4448|       |
 4449|       |                           const auto type_index = variant_id_to_index<T>::op(
 4450|       |                              type_id.data(), type_id.data() + type_id.size(), type_id.size());
 4451|       |                           if (type_index < ids_v<T>.size()) [[likely]] {
 4452|       |                              if (!position_after_tag()) return;
 4453|       |                              tag_specified_index = type_index; // Store the tag-specified type
 4454|       |                              if (value.index() != type_index) emplace_runtime_variant(value, type_index);
 4455|       |                           }
 4456|       |                           else {
 4457|       |                              // Check if we have a default type (ids array shorter than variant)
 4458|       |                              constexpr auto ids_size = ids_v<T>.size();
 4459|       |                              constexpr auto variant_size = std::variant_size_v<T>;
 4460|       |                              if constexpr (ids_size < variant_size) {
 4461|       |                                 // Use the first unlabeled type as the default
 4462|       |                                 if (!position_after_tag()) return;
 4463|       |                                 const auto default_index = ids_size;
 4464|       |                                 tag_specified_index = default_index; // Store the default type index
 4465|       |                                 if (value.index() != default_index) emplace_runtime_variant(value, default_index);
 4466|       |                              }
 4467|       |                              else {
 4468|       |                                 ctx.error = error_code::no_matching_variant_type;
 4469|       |                                 ctx.custom_error_message = variant_ids_string_v<T>;
 4470|       |                                 return;
 4471|       |                              }
 4472|       |                           }
 4473|       |                           // Parse the type (handles tag skipping and unknown keys)
 4474|       |                           std::visit(
 4475|       |                              [&](auto&& v) {
 4476|       |                                 using V = std::decay_t<decltype(v)>;
 4477|       |                                 if constexpr (custom_read<V>) {
 4478|       |                                    // Custom handlers parse the remaining object body themselves and do not
 4479|       |                                    // accept the tag template parameter that reflected objects use to skip an
 4480|       |                                    // interior tag key. That only works when the tag is the first key (it was
 4481|       |                                    // just consumed). If the tag came after other keys, position_after_tag()
 4482|       |                                    // reset us to the object start and the custom handler would absorb the tag
 4483|       |                                    // into its value, so error here rather than corrupt the result.
 4484|       |                                    if (!first_key) {
 4485|       |                                       ctx.error = error_code::feature_not_supported;
 4486|       |                                       ctx.custom_error_message =
 4487|       |                                          "the tag must be the first key for a custom variant alternative";
 4488|       |                                       return;
 4489|       |                                    }
 4490|       |                                    from<JSON, V>::template op<opening_handled<Opts>()>(v, ctx, it, end);
 4491|       |                                 }
 4492|       |                                 else {
 4493|       |                                    if constexpr (contains_tag<V, tag_literal>()) {
 4494|       |                                       // tag is a struct field, must re-parse
 4495|       |                                       if (!start.rewind(ctx, it, end)) return;
 4496|       |                                    }
 4497|       |                                    from<JSON, V>::template op<opening_handled<Opts>(), tag_literal>(v, ctx, it, end);
 4498|       |                                 }
 4499|       |                              },
 4500|       |                              value);
 4501|       |                           return;
 4502|       |                        }
 4503|       |                        else if constexpr (Opts.error_on_unknown_keys) {
 4504|       |                           ctx.error = error_code::unknown_key;
 4505|       |                           return;
 4506|       |                        }
 4507|       |                        else {
 4508|       |                           // Skip unknown key's value (non-tag key in empty variant)
 4509|       |                           if (parse_ws_colon<Opts>(ctx, it, end)) {
 4510|       |                              return;
 4511|       |                           }
 4512|       |                           skip_value<JSON>::op<Opts>(ctx, it, end);
 4513|       |                           if (bool(ctx.error)) [[unlikely]]
 4514|       |                              return;
 4515|       |                           resync_window_end(ctx, end); // a streaming skip refills
 4516|       |                           if (skip_ws<Opts>(ctx, it, end)) {
 4517|       |                              return;
 4518|       |                           }
 4519|       |                           continue; // Continue loop to find the tag
 4520|       |                        }
 4521|       |                     }
 4522|       |                     else if constexpr (Opts.error_on_unknown_keys) {
 4523|       |                        ctx.error = error_code::unknown_key;
 4524|       |                        return;
 4525|       |                     }
 4526|       |
 4527|       |                     auto matching_types = possible_types.popcount();
 4528|       |                     if (matching_types == 0) {
 4529|       |                        ctx.error = error_code::no_matching_variant_type;
 4530|       |                        return;
 4531|       |                     }
 4532|       |                     // Only short-circuit for variants without tags
 4533|       |                     else if constexpr (tag_v<T>.empty()) {
 4534|       |                        if (matching_types == 1) {
 4535|       |                           if (!start.rewind(ctx, it, end)) return;
 4536|       |                           const auto type_index = possible_types.countr_zero();
 4537|       |
 4538|       |                           if (value.index() != static_cast<size_t>(type_index))
 4539|       |                              emplace_runtime_variant(value, type_index);
 4540|       |                           std::visit(
 4541|       |                              [&](auto&& v) {
 4542|       |                                 using V = std::decay_t<decltype(v)>;
 4543|       |                                 constexpr bool is_object = (glaze_object_t<V> || reflectable<V>) && not custom_read<V>;
 4544|       |                                 if constexpr (variant_unit_alternative<V>) {
 4545|       |                                    // A unit alternative carries no data; its object holds only the discriminator.
 4546|       |                                    // Consume that body through an empty reflected object so unknown-key policy and
 4547|       |                                    // terminator handling match every other alternative.
 4548|       |                                    detail::variant_unit_body unit_body{};
 4549|       |                                    from<JSON, detail::variant_unit_body>::template op<opening_handled<Opts>(),
 4550|       |                                                                                       tag_literal>(unit_body, ctx, it,
 4551|       |                                                                                                    end);
 4552|       |                                 }
 4553|       |                                 else if constexpr (is_object) {
 4554|       |                                    from<JSON, V>::template op<opening_handled<Opts>(), tag_literal>(v, ctx, it, end);
 4555|       |                                 }
 4556|       |                                 else if constexpr (is_memory_object<V>) {
 4557|       |                                    if (!v) {
 4558|       |                                       if constexpr (is_specialization_v<V, std::optional>) {
 4559|       |                                          if constexpr (requires { v.emplace(); }) {
 4560|       |                                             v.emplace();
 4561|       |                                          }
 4562|       |                                          else {
 4563|       |                                             v = typename V::value_type{};
 4564|       |                                          }
 4565|       |                                       }
 4566|       |                                       else if constexpr (is_specialization_v<V, std::unique_ptr>)
 4567|       |                                          v = std::make_unique<typename V::element_type>();
 4568|       |                                       else if constexpr (is_specialization_v<V, std::shared_ptr>)
 4569|       |                                          v = std::make_shared<typename V::element_type>();
 4570|       |                                       else if constexpr (constructible<V>) {
 4571|       |                                          v = meta_construct_v<V>();
 4572|       |                                       }
 4573|       |                                       else if constexpr (std::is_pointer_v<V> &&
 4574|       |                                                          can_allocate_raw_pointer<Opts, std::decay_t<decltype(ctx)>>) {
 4575|       |                                          if (!try_allocate_raw_pointer<Opts>(v, ctx)) {
 4576|       |                                             return;
 4577|       |                                          }
 4578|       |                                       }
 4579|       |                                       else {
 4580|       |                                          ctx.error = error_code::invalid_nullable_read;
 4581|       |                                          return;
 4582|       |                                          // Cannot read into unset nullable that is not std::optional,
 4583|       |                                          // std::unique_ptr, or std::shared_ptr
 4584|       |                                       }
 4585|       |                                    }
 4586|       |                                    from<JSON, memory_type<V>>::template op<opening_handled<Opts>(), tag_literal>(
 4587|       |                                       *v, ctx, it, end);
 4588|       |                                 }
 4589|       |                                 else if constexpr (custom_read<V>) {
 4590|       |                                    // Custom handlers parse the remaining body themselves.
 4591|       |                                    from<JSON, V>::template op<opening_handled<Opts>()>(v, ctx, it, end);
 4592|       |                                 }
 4593|       |                              },
 4594|       |                              value);
 4595|       |
 4596|       |                           return; // we've decoded our target type
 4597|       |                        }
 4598|       |                     }
 4599|       |                     // For tagged variants, continue processing to validate tags
 4600|       |                     if (parse_ws_colon<Opts>(ctx, it, end)) {
 4601|       |                        return;
 4602|       |                     }
 4603|       |
 4604|       |                     skip_value<JSON>::op<Opts>(ctx, it, end);
 4605|       |                     if (bool(ctx.error)) [[unlikely]]
 4606|       |                        return;
 4607|       |                     resync_window_end(ctx, end); // a streaming skip refills
 4608|       |                     if (skip_ws<Opts>(ctx, it, end)) {
 4609|       |                        return;
 4610|       |                     }
 4611|       |                  }
 4612|       |                  // Only apply ambiguous variant resolution if we have multiple object types
 4613|       |                  if constexpr ((type_counts::n_object + type_counts::n_nullable_object) > 1) {
 4614|       |                     // After parsing all keys, check if we have multiple matching types
 4615|       |                     // If so, choose the one with the fewest fields
 4616|       |                     auto final_matching = possible_types.popcount();
 4617|       |                     if (final_matching == 0) {
 4618|       |                        ctx.error = error_code::no_matching_variant_type;
 4619|       |                     }
 4620|       |                     else if (final_matching == 1) {
 4621|       |                        // Single type remains after field deduction
 4622|       |                        const auto type_index = possible_types.countr_zero();
 4623|       |
 4624|       |                        // Validate against tag if one was specified
 4625|       |                        if (tag_specified_index.has_value() &&
 4626|       |                            tag_specified_index.value() != static_cast<size_t>(type_index)) {
 4627|       |                           ctx.error = error_code::no_matching_variant_type;
 4628|       |                           return;
 4629|       |                        }
 4630|       |
 4631|       |                        if (!start.rewind(ctx, it, end)) return;
 4632|       |                        if (value.index() != static_cast<size_t>(type_index))
 4633|       |                           emplace_runtime_variant(value, type_index);
 4634|       |                        std::visit(
 4635|       |                           [&](auto&& v) {
 4636|       |                              using V = std::decay_t<decltype(v)>;
 4637|       |                              constexpr bool is_object = (glaze_object_t<V> || reflectable<V>) && not custom_read<V>;
 4638|       |                              if constexpr (variant_unit_alternative<V>) {
 4639|       |                                 // A unit alternative carries no data; its object holds only the discriminator.
 4640|       |                                 // Consume that body through an empty reflected object so unknown-key policy and
 4641|       |                                 // terminator handling match every other alternative.
 4642|       |                                 detail::variant_unit_body unit_body{};
 4643|       |                                 from<JSON, detail::variant_unit_body>::template op<opening_handled<Opts>(),
 4644|       |                                                                                    tag_literal>(unit_body, ctx, it,
 4645|       |                                                                                                 end);
 4646|       |                              }
 4647|       |                              else if constexpr (is_object) {
 4648|       |                                 from<JSON, V>::template op<opening_handled<Opts>(), tag_literal>(v, ctx, it, end);
 4649|       |                              }
 4650|       |                              else if constexpr (is_memory_object<V>) {
 4651|       |                                 if (!v) {
 4652|       |                                    if constexpr (is_specialization_v<V, std::optional>) {
 4653|       |                                       if constexpr (requires { v.emplace(); }) {
 4654|       |                                          v.emplace();
 4655|       |                                       }
 4656|       |                                       else {
 4657|       |                                          v = typename V::value_type{};
 4658|       |                                       }
 4659|       |                                    }
 4660|       |                                    else if constexpr (is_specialization_v<V, std::unique_ptr>)
 4661|       |                                       v = std::make_unique<typename V::element_type>();
 4662|       |                                    else if constexpr (is_specialization_v<V, std::shared_ptr>)
 4663|       |                                       v = std::make_shared<typename V::element_type>();
 4664|       |                                    else if constexpr (constructible<V>) {
 4665|       |                                       v = meta_construct_v<V>();
 4666|       |                                    }
 4667|       |                                    else if constexpr (std::is_pointer_v<V> &&
 4668|       |                                                       can_allocate_raw_pointer<Opts, std::decay_t<decltype(ctx)>>) {
 4669|       |                                       if (!try_allocate_raw_pointer<Opts>(v, ctx)) {
 4670|       |                                          return;
 4671|       |                                       }
 4672|       |                                    }
 4673|       |                                    else {
 4674|       |                                       ctx.error = error_code::invalid_nullable_read;
 4675|       |                                       return;
 4676|       |                                    }
 4677|       |                                 }
 4678|       |                                 from<JSON, memory_type<V>>::template op<opening_handled<Opts>(), tag_literal>(*v, ctx,
 4679|       |                                                                                                               it, end);
 4680|       |                              }
 4681|       |                              else if constexpr (custom_read<V>) {
 4682|       |                                 // Custom handlers parse the remaining body themselves.
 4683|       |                                 from<JSON, V>::template op<opening_handled<Opts>()>(v, ctx, it, end);
 4684|       |                              }
 4685|       |                           },
 4686|       |                           value);
 4687|       |                     }
 4688|       |                     else if (final_matching > 1) {
 4689|       |                        constexpr auto N = std::variant_size_v<T>;
 4690|       |
 4691|       |                        // Compile-time array of field counts for each variant type
 4692|       |                        constexpr auto field_counts = []<size_t... I>(std::index_sequence<I...>) {
 4693|       |                           return std::array<size_t, N> {
 4694|       |                              ([]<size_t J = I>() -> size_t {
 4695|       |                                 using V = std::decay_t<std::variant_alternative_t<J, T>>;
 4696|       |                                 if constexpr (glaze_object_t<V> || reflectable<V>) {
 4697|       |                                    return reflect<V>::size;
 4698|       |                                 }
 4699|       |                                 else if constexpr (is_memory_object<V>) {
 4700|       |                                    using X = memory_type<V>;
 4701|       |                                    if constexpr (glaze_object_t<X> || reflectable<X>) {
 4702|       |                                       return reflect<X>::size;
 4703|       |                                    }
 4704|       |                                    else {
 4705|       |                                       return (std::numeric_limits<size_t>::max)();
 4706|       |                                    }
 4707|       |                                 }
 4708|       |                                 else {
 4709|       |                                    return (std::numeric_limits<size_t>::max)();
 4710|       |                                 }
 4711|       |                              }.template operator()<I>())...
 4712|       |                           };
 4713|       |                        }(std::make_index_sequence<N>{});
 4714|       |
 4715|       |                        // Find the type with minimum field count among the possible types
 4716|       |                        size_t min_fields = (std::numeric_limits<size_t>::max)();
 4717|       |                        size_t chosen_index = N; // Invalid index initially
 4718|       |
 4719|       |                        for (size_t i = 0; i < N; ++i) {
 4720|       |                           if (possible_types[i] && field_counts[i] < min_fields) {
 4721|       |                              min_fields = field_counts[i];
 4722|       |                              chosen_index = i;
 4723|       |                           }
 4724|       |                        }
 4725|       |
 4726|       |                        if (chosen_index < N) {
 4727|       |                           // Validate against tag if one was specified
 4728|       |                           if (tag_specified_index.has_value() && tag_specified_index.value() != chosen_index) {
 4729|       |                              ctx.error = error_code::no_matching_variant_type;
 4730|       |                              return;
 4731|       |                           }
 4732|       |
 4733|       |                           if (!start.rewind(ctx, it, end)) return;
 4734|       |                           if (value.index() != chosen_index) emplace_runtime_variant(value, chosen_index);
 4735|       |                           std::visit(
 4736|       |                              [&](auto&& v) {
 4737|       |                                 using V = std::decay_t<decltype(v)>;
 4738|       |                                 constexpr bool is_object = (glaze_object_t<V> || reflectable<V>) && not custom_read<V>;
 4739|       |                                 if constexpr (variant_unit_alternative<V>) {
 4740|       |                                    // A unit alternative carries no data; its object holds only the discriminator.
 4741|       |                                    // Consume that body through an empty reflected object so unknown-key policy and
 4742|       |                                    // terminator handling match every other alternative.
 4743|       |                                    detail::variant_unit_body unit_body{};
 4744|       |                                    from<JSON, detail::variant_unit_body>::template op<opening_handled<Opts>(),
 4745|       |                                                                                       tag_literal>(unit_body, ctx, it,
 4746|       |                                                                                                    end);
 4747|       |                                 }
 4748|       |                                 else if constexpr (is_object) {
 4749|       |                                    from<JSON, V>::template op<opening_handled<Opts>(), tag_literal>(v, ctx, it, end);
 4750|       |                                 }
 4751|       |                                 else if constexpr (is_memory_object<V>) {
 4752|       |                                    if (!v) {
 4753|       |                                       if constexpr (is_specialization_v<V, std::optional>) {
 4754|       |                                          if constexpr (requires { v.emplace(); }) {
 4755|       |                                             v.emplace();
 4756|       |                                          }
 4757|       |                                          else {
 4758|       |                                             v = typename V::value_type{};
 4759|       |                                          }
 4760|       |                                       }
 4761|       |                                       else if constexpr (is_specialization_v<V, std::unique_ptr>)
 4762|       |                                          v = std::make_unique<typename V::element_type>();
 4763|       |                                       else if constexpr (is_specialization_v<V, std::shared_ptr>)
 4764|       |                                          v = std::make_shared<typename V::element_type>();
 4765|       |                                       else if constexpr (constructible<V>) {
 4766|       |                                          v = meta_construct_v<V>();
 4767|       |                                       }
 4768|       |                                       else if constexpr (std::is_pointer_v<V> &&
 4769|       |                                                          can_allocate_raw_pointer<Opts, std::decay_t<decltype(ctx)>>) {
 4770|       |                                          if (!try_allocate_raw_pointer<Opts>(v, ctx)) {
 4771|       |                                             return;
 4772|       |                                          }
 4773|       |                                       }
 4774|       |                                       else {
 4775|       |                                          ctx.error = error_code::invalid_nullable_read;
 4776|       |                                          return;
 4777|       |                                       }
 4778|       |                                    }
 4779|       |                                    from<JSON, memory_type<V>>::template op<opening_handled<Opts>(), tag_literal>(
 4780|       |                                       *v, ctx, it, end);
 4781|       |                                 }
 4782|       |                                 else if constexpr (custom_read<V>) {
 4783|       |                                    // Custom handlers parse the remaining body themselves.
 4784|       |                                    from<JSON, V>::template op<opening_handled<Opts>()>(v, ctx, it, end);
 4785|       |                                 }
 4786|       |                              },
 4787|       |                              value);
 4788|       |                        }
 4789|       |                        else {
 4790|       |                           ctx.error = error_code::no_matching_variant_type;
 4791|       |                        }
 4792|       |                     }
 4793|       |                  }
 4794|       |                  else {
 4795|       |                     // For variants with 0 or 1 object types, use the original error handling
 4796|       |                     ctx.error = error_code::no_matching_variant_type;
 4797|       |                  }
 4798|       |               }
 4799|      0|               break;
 4800|     35|            }
 4801|      3|            case '[':
  ------------------
  |  Branch (4801:13): [True: 3, False: 693]
  ------------------
 4802|       |               // As with '{' above: the array reader each alternative goes through counts the level.
 4803|      3|               process_variant_alternatives<T, is_variant_array>::template op<Opts>(value, ctx, it, end);
 4804|      3|               break;
 4805|    626|            case '"': {
  ------------------
  |  Branch (4805:13): [True: 626, False: 70]
  ------------------
 4806|    626|               process_variant_alternatives<T, is_variant_str>::template op<Opts>(value, ctx, it, end);
 4807|    626|               break;
 4808|     35|            }
 4809|      3|            case 't':
  ------------------
  |  Branch (4809:13): [True: 3, False: 693]
  ------------------
 4810|      6|            case 'f': {
  ------------------
  |  Branch (4810:13): [True: 3, False: 693]
  ------------------
 4811|      6|               process_variant_alternatives<T, is_variant_bool>::template op<Opts>(value, ctx, it, end);
 4812|      6|               break;
 4813|      3|            }
 4814|      3|            case 'n':
  ------------------
  |  Branch (4814:13): [True: 3, False: 693]
  ------------------
 4815|      3|               if constexpr (variant_count_v<T, is_variant_null> == 0) {
 4816|      3|                  ctx.error = error_code::no_matching_variant_type;
 4817|       |               }
 4818|       |               else {
 4819|       |                  constexpr auto first_idx = variant_first_index_v<T, is_variant_null>;
 4820|       |                  using V = std::variant_alternative_t<first_idx, T>;
 4821|       |                  if (!std::holds_alternative<V>(value)) value = V{};
 4822|       |                  match<"null", Opts>(ctx, it, end);
 4823|       |               }
 4824|      3|               break;
 4825|     20|            default: {
  ------------------
  |  Branch (4825:13): [True: 20, False: 676]
  ------------------
 4826|       |               // Not bool, string, object, or array so must be number or null
 4827|     20|               process_variant_alternatives<T, is_variant_num>::template op<Opts>(value, ctx, it, end);
 4828|     20|            }
 4829|    696|            }
 4830|       |         }
 4831|       |         else {
 4832|       |            // For non-auto-deducible variants, try each type until one succeeds
 4833|       |            constexpr auto N = std::variant_size_v<T>;
 4834|       |            bool parsed = false;
 4835|       |            bool exhausted = false; // speculation budget spent; see charge_speculation
 4836|       |
 4837|       |            for_each<N>([&]<size_t I>() {
 4838|       |               if (parsed || exhausted || variant_alternative_exhausted(ctx)) return;
 4839|       |
 4840|       |               auto copy_it = it;
 4841|       |               // A rejected alternative may have bailed out inside a container, which leaves its
 4842|       |               // nesting level counted (see enter_depth), so the depth rewinds with the iterator.
 4843|       |               const auto copy_depth = ctx.depth;
 4844|       |
 4845|       |               // Try parsing as this type
 4846|       |               if (value.index() != I) {
 4847|       |                  emplace_runtime_variant(value, I);
 4848|       |               }
 4849|       |
 4850|       |               std::visit([&](auto&& v) { parse<JSON>::op<Options>(v, ctx, it, end); }, value);
 4851|       |               if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) {
 4852|       |                  exhausted = true; // only rejected attempts are charged; see charge_speculation
 4853|       |               }
 4854|       |
 4855|       |               if (!bool(ctx.error)) {
 4856|       |                  parsed = true;
 4857|       |               }
 4858|       |               else if constexpr (not Options.null_terminated) {
 4859|       |                  // In non-null-terminated mode, if we hit end_reached after advancing the iterator,
 4860|       |                  // it means we successfully parsed the value but couldn't skip trailing whitespace
 4861|       |                  if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) {
 4862|       |                     // We advanced the iterator, so we did parse something -- unless what advanced it
 4863|       |                     // was an abandoned attempt, which is what a spent speculation budget means.
 4864|       |                     parsed = true;
 4865|       |                     ctx.error = error_code::none;
 4866|       |                  }
 4867|       |                  else {
 4868|       |                     // Reset for next attempt (unless this is the last type)
 4869|       |                     it = copy_it;
 4870|       |                     rewind_depth<Options>(ctx, copy_depth);
 4871|       |                     if constexpr (I + 1 < N) {
 4872|       |                        if (not exhausted && not variant_alternative_exhausted(ctx)) {
 4873|       |                           ctx.error = error_code::none; // Clear error for next attempt
 4874|       |                        }
 4875|       |                     }
 4876|       |                  }
 4877|       |               }
 4878|       |               else {
 4879|       |                  // Reset for next attempt (unless this is the last type)
 4880|       |                  it = copy_it;
 4881|       |                  rewind_depth<Options>(ctx, copy_depth);
 4882|       |                  if constexpr (I + 1 < N) {
 4883|       |                     if (not exhausted && not variant_alternative_exhausted(ctx)) {
 4884|       |                        ctx.error = error_code::none; // Clear error for next attempt
 4885|       |                     }
 4886|       |                  }
 4887|       |               }
 4888|       |            });
 4889|       |         }
 4890|    696|      }
_ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj1EEERN12jsonrpc_fuzz6amountETkNS_10is_contextERNS_7contextERPKcSA_EEvOT0_OT1_OT2_T3_:
   49|    272|      {
   50|       |         if constexpr (const_value_v<T>) {
   51|       |            if constexpr (check_error_on_const_read(Opts)) {
   52|       |               ctx.error = error_code::attempt_const_read;
   53|       |            }
   54|       |            else {
   55|       |               // do not read anything into the const value
   56|       |               skip_value<JSON>::op<Opts>(std::forward<Ctx>(ctx), std::forward<It0>(it), end);
   57|       |            }
   58|       |         }
   59|    272|         else {
   60|    272|            using V = std::remove_cvref_t<T>;
   61|    272|            from<JSON, V>::template op<Opts>(std::forward<T>(value), std::forward<Ctx>(ctx), std::forward<It0>(it),
   62|    272|                                             end);
   63|    272|         }
   64|    272|      }
_ZN3glz4fromILj10EN12jsonrpc_fuzz6amountEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj1EEETnNS_14string_literalEXtlNS6_ILm1EEEEERS2_TkNS_10is_contextERNS_7contextERPKcSC_EEvOT1_OT2_OT3_T4_:
 3044|    272|      {
 3045|    272|         static constexpr auto num_members = reflect<T>::size;
 3046|       |
 3047|    272|         static constexpr auto Opts = opening_handled_off<ws_handled_off<Options>()>();
 3048|       |         if constexpr (!check_opening_handled(Options)) {
 3049|       |            if constexpr (!check_ws_handled(Options)) {
 3050|       |               if (skip_ws<Opts>(ctx, it, end)) {
 3051|       |                  return;
 3052|       |               }
 3053|       |            }
 3054|       |            if (match_invalid_end<'{', Opts>(ctx, it, end)) {
 3055|       |               return;
 3056|       |            }
 3057|       |            if constexpr (not Opts.null_terminated) {
 3058|       |               if (it == end) [[unlikely]] {
 3059|       |                  ctx.error = error_code::unexpected_end;
 3060|       |                  return;
 3061|       |               }
 3062|       |            }
 3063|       |            // one nesting level (see enter_depth): counted in both modes so the limit binds,
 3064|       |            // released at each syntactic close below
 3065|       |            if (enter_depth(ctx)) [[unlikely]] {
 3066|       |               return;
 3067|       |            }
 3068|       |         }
 3069|    272|         const auto ws_start = it;
 3070|    272|         if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (3070:14): [True: 0, False: 272]
  ------------------
 3071|      0|            return;
 3072|      0|         }
 3073|    272|         const size_t ws_size = size_t(it - ws_start);
 3074|       |
 3075|       |         if constexpr ((glaze_object_t<T> || reflectable<T>) && num_members == 0 && Opts.error_on_unknown_keys) {
 3076|       |            if constexpr (not tag.sv().empty()) {
 3077|       |               if (*it == '"') {
 3078|       |                  ++it;
 3079|       |                  if constexpr (not Opts.null_terminated) {
 3080|       |                     if (it == end) [[unlikely]] {
 3081|       |                        ctx.error = error_code::unexpected_end;
 3082|       |                        return;
 3083|       |                     }
 3084|       |                  }
 3085|       |
 3086|       |                  const auto start = it;
 3087|       |                  skip_string_view(ctx, it, end);
 3088|       |                  if (bool(ctx.error)) [[unlikely]]
 3089|       |                     return;
 3090|       |                  if (validate_utf8_span<Opts>(ctx, start, it)) [[unlikely]]
 3091|       |                     return;
 3092|       |                  const sv key{start, size_t(it - start)};
 3093|       |                  ++it;
 3094|       |                  if constexpr (not Opts.null_terminated) {
 3095|       |                     if (it == end) [[unlikely]] {
 3096|       |                        ctx.error = error_code::unexpected_end;
 3097|       |                        return;
 3098|       |                     }
 3099|       |                  }
 3100|       |
 3101|       |                  if (key == tag.sv()) {
 3102|       |                     if (parse_ws_colon<Opts>(ctx, it, end)) {
 3103|       |                        return;
 3104|       |                     }
 3105|       |
 3106|       |                     parse<JSON>::handle_unknown<Opts>(key, value, ctx, it, end);
 3107|       |                     if (bool(ctx.error)) [[unlikely]]
 3108|       |                        return;
 3109|       |
 3110|       |                     if (skip_ws<Opts>(ctx, it, end)) {
 3111|       |                        return;
 3112|       |                     }
 3113|       |                  }
 3114|       |                  else {
 3115|       |                     ctx.error = error_code::unknown_key;
 3116|       |                     return;
 3117|       |                  }
 3118|       |               }
 3119|       |            }
 3120|       |
 3121|       |            if (*it == '}') [[likely]] {
 3122|       |               --ctx.depth;
 3123|       |               if constexpr (glaze_object_t<T> || reflectable<T>) {
 3124|       |                  if constexpr (has_self_constraint_v<T> && !check_skip_self_constraint(Opts)) {
 3125|       |                     auto wrapper = self_constraint_v<T>(value);
 3126|       |                     from<JSON, decltype(wrapper)>::template op<ws_handled<Opts>()>(wrapper, ctx, it, end);
 3127|       |                     if (bool(ctx.error)) {
 3128|       |                        return;
 3129|       |                     }
 3130|       |                  }
 3131|       |               }
 3132|       |               ++it;
 3133|       |               if constexpr (not Opts.null_terminated) {
 3134|       |                  if (it == end) {
 3135|       |                     ctx.error = error_code::end_reached;
 3136|       |                     return;
 3137|       |                  }
 3138|       |               }
 3139|       |               if constexpr (Opts.partial_read) {
 3140|       |                  ctx.error = error_code::partial_read_complete;
 3141|       |               }
 3142|       |               return;
 3143|       |            }
 3144|       |            ctx.error = error_code::unknown_key;
 3145|       |            return;
 3146|       |         }
 3147|    272|         else {
 3148|    272|            decltype(auto) fields = [&]() -> decltype(auto) {
 3149|    272|               if constexpr ((glaze_object_t<T> || reflectable<T>) &&
 3150|    272|                             (Opts.error_on_missing_keys || Opts.partial_read)) {
 3151|    272|                  return bit_array<num_members>{};
 3152|    272|               }
 3153|    272|               else {
 3154|    272|                  return nullptr;
 3155|    272|               }
 3156|    272|            }();
 3157|       |
 3158|    272|            size_t read_count{}; // for partial_read
 3159|       |
 3160|    272|            bool first = true;
 3161|    722|            while (true) {
  ------------------
  |  Branch (3161:20): [True: 551, Folded]
  ------------------
 3162|       |               if constexpr ((glaze_object_t<T> || reflectable<T>) && Opts.partial_read) {
 3163|       |                  static constexpr bit_array<num_members> all_fields = [] {
 3164|       |                     bit_array<num_members> arr{};
 3165|       |                     for (size_t i = 0; i < num_members; ++i) {
 3166|       |                        arr[i] = true;
 3167|       |                     }
 3168|       |                     return arr;
 3169|       |                  }();
 3170|       |
 3171|       |                  if ((all_fields & fields) == all_fields) {
 3172|       |                     ctx.error = error_code::partial_read_complete;
 3173|       |                     --ctx.depth; // as above: an early success still closes this level
 3174|       |                     return;
 3175|       |                  }
 3176|       |               }
 3177|       |
 3178|       |               // Streaming refill point: at start of each iteration, ensure buffer has data
 3179|       |               if constexpr (has_streaming_state<decltype(ctx)>) {
 3180|       |                  if (ctx.stream.enabled()) {
 3181|       |                     const size_t consumed = static_cast<size_t>(it - ctx.stream.data());
 3182|       |                     const size_t remaining = ctx.stream.size() - consumed;
 3183|       |                     // Refill when less than half of buffer remains to ensure space for next key-value pair
 3184|       |                     if (remaining <= ctx.stream.size() / 2 || it >= end) {
 3185|       |                        const char* new_it;
 3186|       |                        const char* new_end;
 3187|       |                        ctx.stream.consume_and_refill(consumed, new_it, new_end);
 3188|       |                        it = new_it;
 3189|       |                        end = new_end;
 3190|       |                        if (it >= end && ctx.stream.at_eof()) {
 3191|       |                           ctx.error = error_code::unexpected_end;
 3192|       |                           return;
 3193|       |                        }
 3194|       |                     }
 3195|       |                  }
 3196|       |               }
 3197|       |
 3198|    551|               if (*it == '}') {
  ------------------
  |  Branch (3198:20): [True: 84, False: 467]
  ------------------
 3199|     84|                  --ctx.depth;
 3200|       |                  if constexpr ((glaze_object_t<T> || reflectable<T>) && Opts.error_on_missing_keys) {
 3201|       |                     constexpr auto req_fields = required_fields<T, Opts>();
 3202|       |                     if ((req_fields & fields) != req_fields) {
 3203|       |                        for (size_t i = 0; i < num_members; ++i) {
 3204|       |                           if (not fields[i] && req_fields[i]) {
 3205|       |                              ctx.custom_error_message = reflect<T>::keys[i];
 3206|       |                              // We just return the first missing key in order to avoid heap allocations
 3207|       |                              break;
 3208|       |                           }
 3209|       |                        }
 3210|       |
 3211|       |                        ctx.error = error_code::missing_key;
 3212|       |                        return;
 3213|       |                     }
 3214|       |                  }
 3215|     84|                  if constexpr (glaze_object_t<T> || reflectable<T>) {
 3216|       |                     if constexpr (has_self_constraint_v<T> && !check_skip_self_constraint(Opts)) {
 3217|       |                        auto wrapper = self_constraint_v<T>(value);
 3218|       |                        from<JSON, decltype(wrapper)>::template op<ws_handled<Opts>()>(wrapper, ctx, it, end);
 3219|       |                        if (bool(ctx.error)) {
 3220|       |                           return;
 3221|       |                        }
 3222|       |                     }
 3223|     84|                  }
 3224|     84|                  ++it; // Increment after checking for missing keys so errors are within buffer bounds
 3225|     84|                  if constexpr (not Opts.null_terminated) {
 3226|     84|                     if (it == end) {
  ------------------
  |  Branch (3226:26): [True: 51, False: 33]
  ------------------
 3227|     51|                        ctx.error = error_code::end_reached;
 3228|     51|                        return;
 3229|     51|                     }
 3230|     84|                  }
 3231|     33|                  return;
 3232|     84|               }
 3233|    467|               else if (first) {
  ------------------
  |  Branch (3233:25): [True: 213, False: 254]
  ------------------
 3234|    213|                  first = false;
 3235|    213|               }
 3236|    254|               else {
 3237|    254|                  if (match_invalid_end<',', Opts>(ctx, it, end)) {
  ------------------
  |  Branch (3237:23): [True: 17, False: 237]
  ------------------
 3238|     17|                     return;
 3239|     17|                  }
 3240|    237|                  if constexpr (not Opts.null_terminated) {
 3241|    237|                     if (it == end) [[unlikely]] {
  ------------------
  |  Branch (3241:26): [True: 0, False: 237]
  ------------------
 3242|      0|                        ctx.error = error_code::unexpected_end;
 3243|      0|                        return;
 3244|      0|                     }
 3245|    237|                  }
 3246|       |
 3247|       |                  if constexpr ((not Opts.minified) && (num_members > 1 || not Opts.error_on_unknown_keys) &&
 3248|       |                                (!Opts.comments)) {
 3249|       |                     if (ws_size && ws_size < size_t(end - it)) {
 3250|       |                        skip_matching_ws(ws_start, it, ws_size);
 3251|       |                     }
 3252|       |                  }
 3253|       |
 3254|    237|                  if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (3254:23): [True: 0, False: 237]
  ------------------
 3255|      0|                     return;
 3256|      0|                  }
 3257|    237|               }
 3258|       |
 3259|    450|               constexpr auto reflection_type = glaze_object_t<T> || reflectable<T>;
  ------------------
  |  Branch (3259:49): [Folded, False: 0]
  |  Branch (3259:70): [True: 0, Folded]
  ------------------
 3260|       |
 3261|       |               if constexpr (reflection_type && (num_members == 0)) {
 3262|       |                  if constexpr (Opts.error_on_unknown_keys) {
 3263|       |                     static_assert(false_v<T>, "This should be unreachable");
 3264|       |                  }
 3265|       |                  else {
 3266|       |                     if (match_invalid_end<'"', Opts>(ctx, it, end)) {
 3267|       |                        return;
 3268|       |                     }
 3269|       |
 3270|       |                     // parsing to an empty object, but at this point the JSON presents keys
 3271|       |
 3272|       |                     // Unknown key handler does not unescape keys. Unknown escaped keys are
 3273|       |                     // handled by the user.
 3274|       |
 3275|       |                     const auto start = it;
 3276|       |                     skip_string_view(ctx, it, end);
 3277|       |                     if (bool(ctx.error)) [[unlikely]]
 3278|       |                        return;
 3279|       |                     if (validate_utf8_span<Opts>(ctx, start, it)) [[unlikely]]
 3280|       |                        return;
 3281|       |                     const sv key{start, size_t(it - start)};
 3282|       |                     ++it;
 3283|       |                     if constexpr (not Opts.null_terminated) {
 3284|       |                        if (it == end) [[unlikely]] {
 3285|       |                           ctx.error = error_code::unexpected_end;
 3286|       |                           return;
 3287|       |                        }
 3288|       |                     }
 3289|       |
 3290|       |                     if (parse_ws_colon<Opts>(ctx, it, end)) {
 3291|       |                        return;
 3292|       |                     }
 3293|       |
 3294|       |                     // Check if this key is the variant tag that should be skipped
 3295|       |                     if constexpr (not tag.sv().empty()) {
 3296|       |                        if (key == tag.sv()) {
 3297|       |                           // Skip the tag value
 3298|       |                           skip_value<JSON>::op<Opts>(ctx, it, end);
 3299|       |                           if (bool(ctx.error)) [[unlikely]]
 3300|       |                              return;
 3301|       |                           resync_window_end(ctx, end); // a streaming skip refills
 3302|       |                           if (skip_ws<Opts>(ctx, it, end)) {
 3303|       |                              return;
 3304|       |                           }
 3305|       |                           continue;
 3306|       |                        }
 3307|       |                     }
 3308|       |
 3309|       |                     parse<JSON>::handle_unknown<Opts>(key, value, ctx, it, end);
 3310|       |                     if (bool(ctx.error)) [[unlikely]]
 3311|       |                        return;
 3312|       |                     if constexpr (not Opts.null_terminated) {
 3313|       |                        if (it == end) [[unlikely]] {
 3314|       |                           ctx.error = error_code::unexpected_end;
 3315|       |                           return;
 3316|       |                        }
 3317|       |                     }
 3318|       |                     if (skip_ws<Opts>(ctx, it, end)) {
 3319|       |                        return;
 3320|       |                     }
 3321|       |                  }
 3322|       |               }
 3323|    450|               else if constexpr (reflection_type) {
 3324|    450|                  static_assert(bool(hash_info<T>.type));
 3325|       |
 3326|    450|                  if (*it != '"') [[unlikely]] {
  ------------------
  |  Branch (3326:23): [True: 70, False: 380]
  ------------------
 3327|     70|                     ctx.error = error_code::expected_quote;
 3328|     70|                     return;
 3329|     70|                  }
 3330|    380|                  ++it;
 3331|    380|                  if constexpr (not Opts.null_terminated) {
 3332|    380|                     if (it == end) [[unlikely]] {
  ------------------
  |  Branch (3332:26): [True: 0, False: 380]
  ------------------
 3333|      0|                        ctx.error = error_code::unexpected_end;
 3334|      0|                        return;
 3335|      0|                     }
 3336|    380|                  }
 3337|       |
 3338|       |                  if constexpr (not tag.sv().empty() && not contains_tag<T, tag>()) {
 3339|       |                     // For tagged variants we first check to see if the key matches the tag
 3340|       |                     // We only need to do this if the tag is not part of the keys
 3341|       |
 3342|       |                     const auto start = it;
 3343|       |                     skip_string_view(ctx, it, end);
 3344|       |                     if (bool(ctx.error)) [[unlikely]]
 3345|       |                        return;
 3346|       |                     if (validate_utf8_span<Opts>(ctx, start, it)) [[unlikely]]
 3347|       |                        return;
 3348|       |                     const sv key{start, size_t(it - start)};
 3349|       |                     ++it;
 3350|       |                     if constexpr (not Opts.null_terminated) {
 3351|       |                        if (it == end) [[unlikely]] {
 3352|       |                           ctx.error = error_code::unexpected_end;
 3353|       |                           return;
 3354|       |                        }
 3355|       |                     }
 3356|       |
 3357|       |                     if (key == tag.sv()) {
 3358|       |                        if (parse_ws_colon<Opts>(ctx, it, end)) {
 3359|       |                           return;
 3360|       |                        }
 3361|       |
 3362|       |                        parse<JSON>::handle_unknown<Opts>(key, value, ctx, it, end);
 3363|       |                        if (bool(ctx.error)) [[unlikely]]
 3364|       |                           return;
 3365|       |
 3366|       |                        if (skip_ws<Opts>(ctx, it, end)) {
 3367|       |                           return;
 3368|       |                        }
 3369|       |                        continue;
 3370|       |                     }
 3371|       |                     else {
 3372|       |                        it = start; // reset the iterator
 3373|       |                     }
 3374|       |                  }
 3375|       |
 3376|       |                  if constexpr (Opts.error_on_missing_keys || Opts.partial_read) {
 3377|       |                     size_t index = num_members;
 3378|       |                     parse_and_invoke<Opts, T>(value, ctx, it, end, index);
 3379|       |                     if (bool(ctx.error)) [[unlikely]]
 3380|       |                        return;
 3381|       |                     if (index < num_members) {
 3382|       |                        fields[index] = true;
 3383|       |                     }
 3384|       |                  }
 3385|    380|                  else {
 3386|    380|                     parse_and_invoke<Opts, T>(value, ctx, it, end);
 3387|    380|                     if (bool(ctx.error)) [[unlikely]]
  ------------------
  |  Branch (3387:26): [True: 101, False: 279]
  ------------------
 3388|    101|                        return;
 3389|    380|                  }
 3390|       |               }
 3391|       |               else {
 3392|       |                  // For types like std::map, std::unordered_map
 3393|       |
 3394|       |                  auto reading = [&](auto&& key) {
 3395|       |                     if constexpr (Opts.partial_read) {
 3396|       |                        if (auto element = value.find(key); element != value.end()) {
 3397|       |                           ++read_count;
 3398|       |                           parse<JSON>::op<ws_handled<Opts>()>(element->second, ctx, it, end);
 3399|       |                        }
 3400|       |                        else {
 3401|       |                           skip_value<JSON>::op<Opts>(ctx, it, end);
 3402|       |                        }
 3403|       |                     }
 3404|       |                     else {
 3405|       |                        parse<JSON>::op<ws_handled<Opts>()>(value[key], ctx, it, end);
 3406|       |                     }
 3407|       |                  };
 3408|       |
 3409|       |                  // using Key = std::conditional_t<heterogeneous_map<T>, sv, typename T::key_type>;
 3410|       |                  using Key = typename T::key_type;
 3411|       |                  if constexpr (std::is_same_v<Key, std::string>) {
 3412|       |                     ctx.scratch.clear();
 3413|       |                     parse<JSON>::op<Opts>(ctx.scratch, ctx, it, end);
 3414|       |                     if (bool(ctx.error)) [[unlikely]]
 3415|       |                        return;
 3416|       |
 3417|       |                     if (parse_ws_colon<Opts>(ctx, it, end)) {
 3418|       |                        return;
 3419|       |                     }
 3420|       |
 3421|       |                     reading(ctx.scratch);
 3422|       |                     if constexpr (Opts.partial_read) {
 3423|       |                        if (read_count == value.size()) {
 3424|       |                           return;
 3425|       |                        }
 3426|       |                     }
 3427|       |                     if (bool(ctx.error)) [[unlikely]]
 3428|       |                        return;
 3429|       |                  }
 3430|       |                  else if constexpr (str_t<Key>) {
 3431|       |                     Key key;
 3432|       |                     parse<JSON>::op<Opts>(key, ctx, it, end);
 3433|       |                     if (bool(ctx.error)) [[unlikely]]
 3434|       |                        return;
 3435|       |
 3436|       |                     if (parse_ws_colon<Opts>(ctx, it, end)) {
 3437|       |                        return;
 3438|       |                     }
 3439|       |
 3440|       |                     reading(key);
 3441|       |                     if constexpr (Opts.partial_read) {
 3442|       |                        if (read_count == value.size()) {
 3443|       |                           return;
 3444|       |                        }
 3445|       |                     }
 3446|       |                     if (bool(ctx.error)) [[unlikely]]
 3447|       |                        return;
 3448|       |                  }
 3449|       |                  else {
 3450|       |                     Key key_value{};
 3451|       |                     if constexpr (is_named_enum<Key> || mimics_str_t<Key>) {
 3452|       |                        parse<JSON>::op<Opts>(key_value, ctx, it, end);
 3453|       |                     }
 3454|       |                     else if constexpr (std::is_arithmetic_v<Key>) {
 3455|       |                        // prefer over quoted_t below to avoid double parsing of quoted_t
 3456|       |                        parse<JSON>::op<opt_true<Opts, quoted_num_opt_tag{}>>(key_value, ctx, it, end);
 3457|       |                     }
 3458|       |                     else {
 3459|       |                        parse<JSON>::op<opt_false<Opts, raw_string_opt_tag{}>>(quoted_t<Key>{key_value}, ctx, it, end);
 3460|       |                     }
 3461|       |                     if (bool(ctx.error)) [[unlikely]]
 3462|       |                        return;
 3463|       |
 3464|       |                     if (parse_ws_colon<Opts>(ctx, it, end)) {
 3465|       |                        return;
 3466|       |                     }
 3467|       |
 3468|       |                     reading(key_value);
 3469|       |                     if constexpr (Opts.partial_read) {
 3470|       |                        if (read_count == value.size()) {
 3471|       |                           return;
 3472|       |                        }
 3473|       |                     }
 3474|       |                     if (bool(ctx.error)) [[unlikely]]
 3475|       |                        return;
 3476|       |                  }
 3477|       |               }
 3478|       |
 3479|       |               // Streaming refill point: after parsing each key-value pair, refill if buffer is low
 3480|       |               if constexpr (has_streaming_state<decltype(ctx)>) {
 3481|       |                  if (ctx.stream.enabled()) {
 3482|       |                     const size_t consumed = static_cast<size_t>(it - ctx.stream.data());
 3483|       |                     // Refill when less than 25% of buffer remains to ensure enough space for next element
 3484|       |                     if (ctx.stream.size() - consumed <= ctx.stream.size() / 4 || it >= end) {
 3485|       |                        const char* new_it;
 3486|       |                        const char* new_end;
 3487|       |                        ctx.stream.consume_and_refill(consumed, new_it, new_end);
 3488|       |                        it = new_it;
 3489|       |                        end = new_end;
 3490|       |                        if (it >= end && ctx.stream.at_eof()) {
 3491|       |                           ctx.error = error_code::unexpected_end;
 3492|       |                           return;
 3493|       |                        }
 3494|       |                     }
 3495|       |                  }
 3496|       |               }
 3497|       |
 3498|    450|               if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (3498:20): [True: 0, False: 450]
  ------------------
 3499|      0|                  return;
 3500|      0|               }
 3501|    450|            }
 3502|    272|         }
 3503|    272|      }
_ZZN3glz4fromILj10EN12jsonrpc_fuzz6amountEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj1EEETnNS_14string_literalEXtlNS6_ILm1EEEEERS2_TkNS_10is_contextERNS_7contextERPKcSC_EEvOT1_OT2_OT3_T4_ENKUlvE_clEv:
 3148|    272|            decltype(auto) fields = [&]() -> decltype(auto) {
 3149|       |               if constexpr ((glaze_object_t<T> || reflectable<T>) &&
 3150|       |                             (Opts.error_on_missing_keys || Opts.partial_read)) {
 3151|       |                  return bit_array<num_members>{};
 3152|       |               }
 3153|    272|               else {
 3154|    272|                  return nullptr;
 3155|    272|               }
 3156|    272|            }();
_ZN3glz16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz6amountERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT3_OT4_OT5_DpOT2_:
  376|    380|   {
  377|    380|      constexpr auto N = reflect<T>::size;
  378|       |
  379|    380|      if constexpr (N == 1) {
  380|    380|         decode_index<Opts, T, 0>(value, ctx, it, end, selected_index...);
  381|       |      }
  382|       |      else if constexpr (check_linear_search(Opts)) {
  383|       |         // Linear search path
  384|       |         auto key_start = it;
  385|       |         const auto index = decode_linear<T>(ctx, it, end);
  386|       |         if (bool(ctx.error)) [[unlikely]]
  387|       |            return;
  388|       |
  389|       |         if (index >= N) [[unlikely]] {
  390|       |            if constexpr (Opts.error_on_unknown_keys) {
  391|       |               ctx.error = error_code::unknown_key;
  392|       |               return;
  393|       |            }
  394|       |            else {
  395|       |               // it sits one past the closing quote, so the raw key spans [key_start, it - 1)
  396|       |               if (validate_utf8_span<Opts>(ctx, key_start, it - 1)) [[unlikely]] {
  397|       |                  return;
  398|       |               }
  399|       |               const sv key{key_start, size_t(it - key_start - 1)};
  400|       |               if constexpr (not Opts.null_terminated) {
  401|       |                  if (it == end) [[unlikely]] {
  402|       |                     ctx.error = error_code::unexpected_end;
  403|       |                     return;
  404|       |                  }
  405|       |               }
  406|       |               if (parse_ws_colon<Opts>(ctx, it, end)) {
  407|       |                  return;
  408|       |               }
  409|       |               parse<JSON>::handle_unknown<Opts>(key, value, ctx, it, end);
  410|       |               return;
  411|       |            }
  412|       |         }
  413|       |
  414|       |         if constexpr (not Opts.null_terminated) {
  415|       |            if (it == end) [[unlikely]] {
  416|       |               ctx.error = error_code::unexpected_end;
  417|       |               return;
  418|       |            }
  419|       |         }
  420|       |         if (skip_ws<Opts>(ctx, it, end)) {
  421|       |            return;
  422|       |         }
  423|       |         if (match_invalid_end<':', Opts>(ctx, it, end)) {
  424|       |            return;
  425|       |         }
  426|       |         if (skip_ws<Opts>(ctx, it, end)) {
  427|       |            return;
  428|       |         }
  429|       |
  430|       |         // Fold expression dispatch - avoids jump table overhead for smaller binary size.
  431|       |         // For linear_search, pass Opts through to the field parser to avoid duplicate template
  432|       |         // instantiations; the whitespace before the value has already been skipped either way.
  433|       |         [&]<size_t... Is>(std::index_sequence<Is...>) {
  434|       |            (void)(((index == Is ? (decode_field_value<Opts, Opts, T, Is>(value, ctx, it, end, selected_index...), true)
  435|       |                                 : false) ||
  436|       |                    ...));
  437|       |         }(std::make_index_sequence<N>{});
  438|       |      }
  439|       |      else {
  440|       |         // Hash-based lookup
  441|       |         constexpr auto& HashInfo = hash_info<T>;
  442|       |         constexpr auto type = HashInfo.type;
  443|       |         static_assert(bool(type), "invalid hash algorithm");
  444|       |
  445|       |         const auto index = decode_hash<JSON, T, HashInfo, HashInfo.type>::op(it, end);
  446|       |
  447|       |         if (index >= N) [[unlikely]] {
  448|       |            if constexpr (Opts.error_on_unknown_keys) {
  449|       |               ctx.error = error_code::unknown_key;
  450|       |               return;
  451|       |            }
  452|       |            else {
  453|       |               auto start = it;
  454|       |               skip_string_view(ctx, it, end);
  455|       |               if (bool(ctx.error)) [[unlikely]]
  456|       |                  return;
  457|       |               if (validate_utf8_span<Opts>(ctx, start, it)) [[unlikely]]
  458|       |                  return;
  459|       |               const sv key = {start, size_t(it - start)};
  460|       |               ++it; // skip the quote
  461|       |               if constexpr (not Opts.null_terminated) {
  462|       |                  if (it == end) [[unlikely]] {
  463|       |                     ctx.error = error_code::unexpected_end;
  464|       |                     return;
  465|       |                  }
  466|       |               }
  467|       |               if (parse_ws_colon<Opts>(ctx, it, end)) {
  468|       |                  return;
  469|       |               }
  470|       |               parse<JSON>::handle_unknown<Opts>(key, value, ctx, it, end);
  471|       |               return;
  472|       |            }
  473|       |         }
  474|       |
  475|       |         if constexpr (N == 2) {
  476|       |            if (index == 0) {
  477|       |               decode_index<Opts, T, 0>(value, ctx, it, end, selected_index...);
  478|       |            }
  479|       |            else {
  480|       |               decode_index<Opts, T, 1>(value, ctx, it, end, selected_index...);
  481|       |            }
  482|       |         }
  483|       |         else {
  484|       |            visit<N>([&]<size_t I>() { decode_index<Opts, T, I>(value, ctx, it, end, selected_index...); }, index);
  485|       |         }
  486|       |      }
  487|    380|   }
_ZN3glz12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz6amountELm0ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT2_OT4_OT5_OT6_DpOT3_:
  311|    380|   {
  312|    380|      static constexpr auto Key = get<I>(reflect<T>::keys);
  313|    380|      static constexpr auto KeyWithEndQuote = join_v<Key, chars<"\"">>;
  314|    380|      static constexpr auto Length = KeyWithEndQuote.size();
  315|       |
  316|    380|      if (((it + Length) < end) && comparitor<KeyWithEndQuote>(it)) [[likely]] {
  ------------------
  |  Branch (316:11): [True: 366, False: 14]
  |  Branch (316:36): [True: 327, False: 39]
  ------------------
  317|    327|         it += Length;
  318|    327|         if constexpr (not Opts.null_terminated) {
  319|    327|            if (it == end) [[unlikely]] {
  ------------------
  |  Branch (319:17): [True: 0, False: 327]
  ------------------
  320|      0|               ctx.error = error_code::unexpected_end;
  321|      0|               return;
  322|      0|            }
  323|    327|         }
  324|       |
  325|    327|         if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (325:14): [True: 0, False: 327]
  ------------------
  326|      0|            return;
  327|      0|         }
  328|    327|         if (match_invalid_end<':', Opts>(ctx, it, end)) {
  ------------------
  |  Branch (328:14): [True: 24, False: 303]
  ------------------
  329|     24|            return;
  330|     24|         }
  331|    303|         if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (331:14): [True: 0, False: 303]
  ------------------
  332|      0|            return;
  333|      0|         }
  334|       |
  335|       |         // The hash path has already consumed the whitespace before the value
  336|    303|         decode_field_value<Opts, ws_handled<Opts>(), T, I>(value, ctx, it, end, selected_index...);
  337|    303|      }
  338|     53|      else [[unlikely]] {
  339|     53|         decode_index_unknown_key<Opts, T>(value, ctx, it, end);
  340|     53|      }
  341|    380|   }
_ZN3glz18decode_field_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnDaXtlS1_Lj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEEN12jsonrpc_fuzz6amountELm0ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT1_E11reflectableISA_EEEvOT3_OT5_OT6_OT7_DpOT4_:
  245|    303|   {
  246|       |      // Check for null value skipping on read
  247|       |      if constexpr (check_skip_null_members_on_read(Opts)) {
  248|       |         if (*it == 'n') {
  249|       |            ++it;
  250|       |            if constexpr (not Opts.null_terminated) {
  251|       |               if (it == end) [[unlikely]] {
  252|       |                  ctx.error = error_code::unexpected_end;
  253|       |                  return;
  254|       |               }
  255|       |            }
  256|       |            match<"ull", Opts>(ctx, it, end);
  257|       |            if (bool(ctx.error)) [[unlikely]]
  258|       |               return;
  259|       |            // Successfully matched "null", skip it
  260|       |            if constexpr (Opts.error_on_missing_keys || Opts.partial_read) {
  261|       |               ((selected_index = I), ...); // Mark as handled even if skipped
  262|       |            }
  263|       |            return;
  264|       |         }
  265|       |      }
  266|       |
  267|       |      if constexpr (skipped_by_meta<T, I, operation::parse>) {
  268|       |         skip_value<JSON>::op<Opts>(ctx, it, end);
  269|       |         if (bool(ctx.error)) [[unlikely]]
  270|       |            return; // Propagate error from skip_value
  271|       |      }
  272|    303|      else {
  273|    303|         using V = refl_t<T, I>;
  274|       |
  275|       |         if constexpr (const_value_v<V>) {
  276|       |            if constexpr (check_error_on_const_read(Opts)) {
  277|       |               ctx.error = error_code::attempt_const_read;
  278|       |            }
  279|       |            else {
  280|       |               // do not read anything into the const value
  281|       |               skip_value<JSON>::op<Opts>(ctx, it, end);
  282|       |            }
  283|       |         }
  284|       |         else if constexpr (is_function_ptr_or_ref<V>) {
  285|       |            // Function pointers cannot be deserialized from JSON.
  286|       |            // When write_function_pointers is enabled the writer emits a type-name string,
  287|       |            // but there is nothing meaningful to reconstruct on read — just skip the value.
  288|       |            // When write_function_pointers is off the key is never written, so this branch
  289|       |            // is unreachable in that case.
  290|       |            skip_value<JSON>::op<Opts>(ctx, it, end);
  291|       |         }
  292|       |         else if constexpr (glaze_object_t<T>) {
  293|       |            from<JSON, std::remove_cvref_t<V>>::template op<FieldOpts>(get_member(value, get<I>(reflect<T>::values)),
  294|       |                                                                       ctx, it, end);
  295|       |         }
  296|    303|         else {
  297|    303|            from<JSON, std::remove_cvref_t<V>>::template op<FieldOpts>(get_member(value, get<I>(to_tie(value))), ctx,
  298|    303|                                                                       it, end);
  299|    303|         }
  300|    303|      }
  301|       |
  302|       |      // The key was present and handled, even when the value itself was skipped
  303|       |      if constexpr (Opts.error_on_missing_keys || Opts.partial_read) {
  304|       |         ((selected_index = I), ...);
  305|       |      }
  306|    303|   }
_ZN3glz24decode_index_unknown_keyITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz6amountERS3_TkNS_10is_contextERNS_7contextERPKcS8_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT2_OT3_T4_:
  177|     53|   {
  178|     53|      if constexpr (Opts.error_on_unknown_keys) {
  179|     53|         ctx.error = error_code::unknown_key;
  180|       |      }
  181|       |      else {
  182|       |         auto* start = it;
  183|       |         skip_string_view(ctx, it, end);
  184|       |         if (bool(ctx.error)) [[unlikely]]
  185|       |            return;
  186|       |         if (validate_utf8_span<Opts>(ctx, start, it)) [[unlikely]]
  187|       |            return;
  188|       |         const sv key = {start, size_t(it - start)};
  189|       |         ++it;
  190|       |         if constexpr (not Opts.null_terminated) {
  191|       |            if (it == end) [[unlikely]] {
  192|       |               ctx.error = error_code::unexpected_end;
  193|       |               return;
  194|       |            }
  195|       |         }
  196|       |
  197|       |         if (parse_ws_colon<Opts>(ctx, it, end)) {
  198|       |            return;
  199|       |         }
  200|       |
  201|       |         parse<JSON>::handle_unknown<Opts>(key, value, ctx, it, end);
  202|       |      }
  203|     53|   }
_ZN3glz28process_variant_alternativesINSt3__17variantIJNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEN12jsonrpc_fuzz6amountEEEENS_16is_variant_arrayEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSB_TkNS_10is_contextERNS_7contextERPKcSK_EEvOT0_OT1_OT2_T3_:
 3725|     17|      {
 3726|     17|         constexpr auto category_count = variant_count_v<Variant, Trait>;
 3727|       |
 3728|     17|         if constexpr (category_count == 0) {
 3729|     17|            ctx.error = error_code::no_matching_variant_type;
 3730|       |         }
 3731|       |         else {
 3732|       |            constexpr auto N = std::variant_size_v<Variant>;
 3733|       |            constexpr auto const_count = variant_filtered_count_v<Variant, Trait, true>;
 3734|       |            constexpr auto non_const_count = variant_filtered_count_v<Variant, Trait, false>;
 3735|       |
 3736|       |            bool found_match{};
 3737|       |            // Set when the speculative parsing budget runs out; see charge_speculation. An ambiguous
 3738|       |            // nest re-parses the same subtree per alternative at every level, which is exponential,
 3739|       |            // so the budget stops it and the failure already in hand is reported.
 3740|       |            bool exhausted{};
 3741|       |
 3742|       |            // First pass: const glaze types in this category
 3743|       |            if constexpr (const_count > 0) {
 3744|       |               for_each<N>([&]<size_t I>() {
 3745|       |                  if (found_match || exhausted || variant_alternative_exhausted(ctx)) {
 3746|       |                     return;
 3747|       |                  }
 3748|       |                  using V = std::variant_alternative_t<I, Variant>;
 3749|       |                  if constexpr (Trait<V>::value && glaze_const_value_t<V>) {
 3750|       |                     // run time substitute to compare to const value
 3751|       |                     std::remove_const_t<std::remove_pointer_t<std::remove_const_t<meta_wrapper_t<V>>>> substitute{};
 3752|       |                     auto copy_it{it};
 3753|       |                     // A rejected alternative may have bailed out inside a container, which leaves its
 3754|       |                     // nesting level counted (see enter_depth). Rewind the depth with the iterator so
 3755|       |                     // trying N alternatives cannot spend N levels of the recursion budget.
 3756|       |                     const auto copy_depth{ctx.depth};
 3757|       |                     parse<JSON>::op<ws_handled<Options>()>(substitute, ctx, it, end);
 3758|       |                     static constexpr auto const_value{*meta_wrapper_v<V>};
 3759|       |                     if (substitute == const_value) {
 3760|       |                        found_match = true;
 3761|       |                        if (!std::holds_alternative<V>(value)) {
 3762|       |                           value = V{};
 3763|       |                        }
 3764|       |                     }
 3765|       |                     else {
 3766|       |                        // Rejected: charge the bytes it parsed before we rewind. See charge_speculation.
 3767|       |                        if (!charge_speculation(ctx, size_t(it - copy_it))) {
 3768|       |                           exhausted = true;
 3769|       |                        }
 3770|       |                        if constexpr (not Options.null_terminated) {
 3771|       |                           if (ctx.error == error_code::end_reached && not exhausted) {
 3772|       |                              ctx.error = error_code::none;
 3773|       |                           }
 3774|       |                        }
 3775|       |                        it = copy_it;
 3776|       |                        rewind_depth<Options>(ctx, copy_depth);
 3777|       |                     }
 3778|       |                  }
 3779|       |               });
 3780|       |               if (found_match) {
 3781|       |                  return;
 3782|       |               }
 3783|       |            }
 3784|       |
 3785|       |            // Second pass: non-const types in this category
 3786|       |            if constexpr (non_const_count > 0) {
 3787|       |               // Track position within matching types for "is last" check.
 3788|       |               // We iterate over all variant indices but only process matching types,
 3789|       |               // so we need runtime tracking (vs the old tuple-based approach where
 3790|       |               // the loop index directly corresponded to position in filtered set).
 3791|       |               // This has negligible cost: one increment per matching type.
 3792|       |               size_t non_const_idx = 0;
 3793|       |
 3794|       |               for_each<N>([&]<size_t I>() {
 3795|       |                  if (found_match || exhausted || variant_alternative_exhausted(ctx)) {
 3796|       |                     return;
 3797|       |                  }
 3798|       |                  using V = std::variant_alternative_t<I, Variant>;
 3799|       |                  if constexpr (Trait<V>::value && !glaze_const_value_t<V>) {
 3800|       |                     auto copy_it{it};
 3801|       |                     const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above
 3802|       |                     if (!std::holds_alternative<V>(value)) {
 3803|       |                        value = V{};
 3804|       |                     }
 3805|       |                     parse<JSON>::op<ws_handled<Options>()>(std::get<V>(value), ctx, it, end);
 3806|       |                     if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) {
 3807|       |                        exhausted = true; // only rejected attempts are charged; see charge_speculation
 3808|       |                     }
 3809|       |                     if (!bool(ctx.error)) {
 3810|       |                        found_match = true;
 3811|       |                     }
 3812|       |                     else if constexpr (not Options.null_terminated) {
 3813|       |                        constexpr bool is_complete_type =
 3814|       |                           num_t<V> || bool_t<V> || string_t<V> || std::is_enum_v<V> || tuple_t<V> || is_std_tuple<V>;
 3815|       |
 3816|       |                        if constexpr (is_complete_type) {
 3817|       |                           if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) {
 3818|       |                              found_match = true;
 3819|       |                              ctx.error = error_code::none;
 3820|       |                           }
 3821|       |                           else {
 3822|       |                              it = copy_it;
 3823|       |                              rewind_depth<Options>(ctx, copy_depth);
 3824|       |                              if (non_const_idx + 1 < non_const_count && not exhausted &&
 3825|       |                                  not variant_alternative_exhausted(ctx)) {
 3826|       |                                 ctx.error = error_code::none;
 3827|       |                              }
 3828|       |                           }
 3829|       |                        }
 3830|       |                        else {
 3831|       |                           it = copy_it;
 3832|       |                           rewind_depth<Options>(ctx, copy_depth);
 3833|       |                           if (non_const_idx + 1 < non_const_count && not exhausted &&
 3834|       |                               not variant_alternative_exhausted(ctx)) {
 3835|       |                              ctx.error = error_code::none;
 3836|       |                           }
 3837|       |                        }
 3838|       |                     }
 3839|       |                     else {
 3840|       |                        it = copy_it;
 3841|       |                        rewind_depth<Options>(ctx, copy_depth);
 3842|       |                        if (non_const_idx + 1 < non_const_count && not exhausted &&
 3843|       |                            not variant_alternative_exhausted(ctx)) {
 3844|       |                           ctx.error = error_code::none;
 3845|       |                        }
 3846|       |                     }
 3847|       |                     ++non_const_idx;
 3848|       |                  }
 3849|       |               });
 3850|       |               if (!found_match) {
 3851|       |                  if constexpr (non_const_count == 1) {
 3852|       |                     // Keep the specific error from the single type we tried
 3853|       |                  }
 3854|       |                  else if (not exhausted && not variant_alternative_exhausted(ctx)) {
 3855|       |                     // Over-nested input is not a failure of the alternative set; keep saying so.
 3856|       |                     ctx.error = error_code::no_matching_variant_type;
 3857|       |                  }
 3858|       |               }
 3859|       |            }
 3860|       |            else {
 3861|       |               ctx.error = error_code::no_matching_variant_type;
 3862|       |            }
 3863|       |         }
 3864|     17|      }
_ZN3glz28process_variant_alternativesINSt3__17variantIJNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEN12jsonrpc_fuzz6amountEEEENS_14is_variant_strEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSB_TkNS_10is_contextERNS_7contextERPKcSK_EEvOT0_OT1_OT2_T3_:
 3725|  1.26k|      {
 3726|  1.26k|         constexpr auto category_count = variant_count_v<Variant, Trait>;
 3727|       |
 3728|       |         if constexpr (category_count == 0) {
 3729|       |            ctx.error = error_code::no_matching_variant_type;
 3730|       |         }
 3731|  1.26k|         else {
 3732|  1.26k|            constexpr auto N = std::variant_size_v<Variant>;
 3733|  1.26k|            constexpr auto const_count = variant_filtered_count_v<Variant, Trait, true>;
 3734|  1.26k|            constexpr auto non_const_count = variant_filtered_count_v<Variant, Trait, false>;
 3735|       |
 3736|  1.26k|            bool found_match{};
 3737|       |            // Set when the speculative parsing budget runs out; see charge_speculation. An ambiguous
 3738|       |            // nest re-parses the same subtree per alternative at every level, which is exponential,
 3739|       |            // so the budget stops it and the failure already in hand is reported.
 3740|  1.26k|            bool exhausted{};
 3741|       |
 3742|       |            // First pass: const glaze types in this category
 3743|       |            if constexpr (const_count > 0) {
 3744|       |               for_each<N>([&]<size_t I>() {
 3745|       |                  if (found_match || exhausted || variant_alternative_exhausted(ctx)) {
 3746|       |                     return;
 3747|       |                  }
 3748|       |                  using V = std::variant_alternative_t<I, Variant>;
 3749|       |                  if constexpr (Trait<V>::value && glaze_const_value_t<V>) {
 3750|       |                     // run time substitute to compare to const value
 3751|       |                     std::remove_const_t<std::remove_pointer_t<std::remove_const_t<meta_wrapper_t<V>>>> substitute{};
 3752|       |                     auto copy_it{it};
 3753|       |                     // A rejected alternative may have bailed out inside a container, which leaves its
 3754|       |                     // nesting level counted (see enter_depth). Rewind the depth with the iterator so
 3755|       |                     // trying N alternatives cannot spend N levels of the recursion budget.
 3756|       |                     const auto copy_depth{ctx.depth};
 3757|       |                     parse<JSON>::op<ws_handled<Options>()>(substitute, ctx, it, end);
 3758|       |                     static constexpr auto const_value{*meta_wrapper_v<V>};
 3759|       |                     if (substitute == const_value) {
 3760|       |                        found_match = true;
 3761|       |                        if (!std::holds_alternative<V>(value)) {
 3762|       |                           value = V{};
 3763|       |                        }
 3764|       |                     }
 3765|       |                     else {
 3766|       |                        // Rejected: charge the bytes it parsed before we rewind. See charge_speculation.
 3767|       |                        if (!charge_speculation(ctx, size_t(it - copy_it))) {
 3768|       |                           exhausted = true;
 3769|       |                        }
 3770|       |                        if constexpr (not Options.null_terminated) {
 3771|       |                           if (ctx.error == error_code::end_reached && not exhausted) {
 3772|       |                              ctx.error = error_code::none;
 3773|       |                           }
 3774|       |                        }
 3775|       |                        it = copy_it;
 3776|       |                        rewind_depth<Options>(ctx, copy_depth);
 3777|       |                     }
 3778|       |                  }
 3779|       |               });
 3780|       |               if (found_match) {
 3781|       |                  return;
 3782|       |               }
 3783|       |            }
 3784|       |
 3785|       |            // Second pass: non-const types in this category
 3786|  1.26k|            if constexpr (non_const_count > 0) {
 3787|       |               // Track position within matching types for "is last" check.
 3788|       |               // We iterate over all variant indices but only process matching types,
 3789|       |               // so we need runtime tracking (vs the old tuple-based approach where
 3790|       |               // the loop index directly corresponded to position in filtered set).
 3791|       |               // This has negligible cost: one increment per matching type.
 3792|  1.26k|               size_t non_const_idx = 0;
 3793|       |
 3794|  1.26k|               for_each<N>([&]<size_t I>() {
 3795|  1.26k|                  if (found_match || exhausted || variant_alternative_exhausted(ctx)) {
 3796|  1.26k|                     return;
 3797|  1.26k|                  }
 3798|  1.26k|                  using V = std::variant_alternative_t<I, Variant>;
 3799|  1.26k|                  if constexpr (Trait<V>::value && !glaze_const_value_t<V>) {
 3800|  1.26k|                     auto copy_it{it};
 3801|  1.26k|                     const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above
 3802|  1.26k|                     if (!std::holds_alternative<V>(value)) {
 3803|  1.26k|                        value = V{};
 3804|  1.26k|                     }
 3805|  1.26k|                     parse<JSON>::op<ws_handled<Options>()>(std::get<V>(value), ctx, it, end);
 3806|  1.26k|                     if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) {
 3807|  1.26k|                        exhausted = true; // only rejected attempts are charged; see charge_speculation
 3808|  1.26k|                     }
 3809|  1.26k|                     if (!bool(ctx.error)) {
 3810|  1.26k|                        found_match = true;
 3811|  1.26k|                     }
 3812|  1.26k|                     else if constexpr (not Options.null_terminated) {
 3813|  1.26k|                        constexpr bool is_complete_type =
 3814|  1.26k|                           num_t<V> || bool_t<V> || string_t<V> || std::is_enum_v<V> || tuple_t<V> || is_std_tuple<V>;
 3815|       |
 3816|  1.26k|                        if constexpr (is_complete_type) {
 3817|  1.26k|                           if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) {
 3818|  1.26k|                              found_match = true;
 3819|  1.26k|                              ctx.error = error_code::none;
 3820|  1.26k|                           }
 3821|  1.26k|                           else {
 3822|  1.26k|                              it = copy_it;
 3823|  1.26k|                              rewind_depth<Options>(ctx, copy_depth);
 3824|  1.26k|                              if (non_const_idx + 1 < non_const_count && not exhausted &&
 3825|  1.26k|                                  not variant_alternative_exhausted(ctx)) {
 3826|  1.26k|                                 ctx.error = error_code::none;
 3827|  1.26k|                              }
 3828|  1.26k|                           }
 3829|  1.26k|                        }
 3830|  1.26k|                        else {
 3831|  1.26k|                           it = copy_it;
 3832|  1.26k|                           rewind_depth<Options>(ctx, copy_depth);
 3833|  1.26k|                           if (non_const_idx + 1 < non_const_count && not exhausted &&
 3834|  1.26k|                               not variant_alternative_exhausted(ctx)) {
 3835|  1.26k|                              ctx.error = error_code::none;
 3836|  1.26k|                           }
 3837|  1.26k|                        }
 3838|  1.26k|                     }
 3839|  1.26k|                     else {
 3840|  1.26k|                        it = copy_it;
 3841|  1.26k|                        rewind_depth<Options>(ctx, copy_depth);
 3842|  1.26k|                        if (non_const_idx + 1 < non_const_count && not exhausted &&
 3843|  1.26k|                            not variant_alternative_exhausted(ctx)) {
 3844|  1.26k|                           ctx.error = error_code::none;
 3845|  1.26k|                        }
 3846|  1.26k|                     }
 3847|  1.26k|                     ++non_const_idx;
 3848|  1.26k|                  }
 3849|  1.26k|               });
 3850|  1.26k|               if (!found_match) {
  ------------------
  |  Branch (3850:20): [True: 344, False: 923]
  ------------------
 3851|    344|                  if constexpr (non_const_count == 1) {
 3852|       |                     // Keep the specific error from the single type we tried
 3853|       |                  }
 3854|       |                  else if (not exhausted && not variant_alternative_exhausted(ctx)) {
 3855|       |                     // Over-nested input is not a failure of the alternative set; keep saying so.
 3856|       |                     ctx.error = error_code::no_matching_variant_type;
 3857|       |                  }
 3858|    344|               }
 3859|       |            }
 3860|       |            else {
 3861|       |               ctx.error = error_code::no_matching_variant_type;
 3862|       |            }
 3863|  1.26k|         }
 3864|  1.26k|      }
_ZZN3glz28process_variant_alternativesINSt3__17variantIJNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEN12jsonrpc_fuzz6amountEEEENS_14is_variant_strEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSB_TkNS_10is_contextERNS_7contextERPKcSK_EEvOT0_OT1_OT2_T3_ENKUlTnmvE_clILm0EEEDav:
 3794|  1.26k|               for_each<N>([&]<size_t I>() {
 3795|  1.26k|                  if (found_match || exhausted || variant_alternative_exhausted(ctx)) {
  ------------------
  |  Branch (3795:23): [True: 0, False: 1.26k]
  |  Branch (3795:38): [True: 0, False: 1.26k]
  |  Branch (3795:51): [True: 0, False: 1.26k]
  ------------------
 3796|      0|                     return;
 3797|      0|                  }
 3798|  1.26k|                  using V = std::variant_alternative_t<I, Variant>;
 3799|  1.26k|                  if constexpr (Trait<V>::value && !glaze_const_value_t<V>) {
 3800|  1.26k|                     auto copy_it{it};
 3801|  1.26k|                     const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above
 3802|  1.26k|                     if (!std::holds_alternative<V>(value)) {
  ------------------
  |  Branch (3802:26): [True: 3, False: 1.26k]
  ------------------
 3803|      3|                        value = V{};
 3804|      3|                     }
 3805|  1.26k|                     parse<JSON>::op<ws_handled<Options>()>(std::get<V>(value), ctx, it, end);
 3806|  1.26k|                     if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) {
  ------------------
  |  Branch (3806:26): [True: 524, False: 743]
  |  Branch (3806:45): [True: 0, False: 524]
  ------------------
 3807|      0|                        exhausted = true; // only rejected attempts are charged; see charge_speculation
 3808|      0|                     }
 3809|  1.26k|                     if (!bool(ctx.error)) {
  ------------------
  |  Branch (3809:26): [True: 743, False: 524]
  ------------------
 3810|    743|                        found_match = true;
 3811|    743|                     }
 3812|    524|                     else if constexpr (not Options.null_terminated) {
 3813|    524|                        constexpr bool is_complete_type =
 3814|    524|                           num_t<V> || bool_t<V> || string_t<V> || std::is_enum_v<V> || tuple_t<V> || is_std_tuple<V>;
  ------------------
  |  Branch (3814:28): [Folded, False: 0]
  |  Branch (3814:40): [Folded, False: 0]
  |  Branch (3814:53): [True: 0, Folded]
  |  Branch (3814:68): [Folded, False: 0]
  |  Branch (3814:89): [Folded, False: 0]
  |  Branch (3814:103): [Folded, False: 0]
  ------------------
 3815|       |
 3816|    524|                        if constexpr (is_complete_type) {
 3817|    524|                           if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) {
  ------------------
  |  Branch (3817:32): [True: 180, False: 344]
  |  Branch (3817:72): [True: 180, False: 0]
  |  Branch (3817:88): [True: 180, False: 0]
  ------------------
 3818|    180|                              found_match = true;
 3819|    180|                              ctx.error = error_code::none;
 3820|    180|                           }
 3821|    344|                           else {
 3822|    344|                              it = copy_it;
 3823|    344|                              rewind_depth<Options>(ctx, copy_depth);
 3824|    344|                              if (non_const_idx + 1 < non_const_count && not exhausted &&
  ------------------
  |  Branch (3824:35): [True: 0, False: 344]
  |  Branch (3824:74): [True: 0, False: 0]
  ------------------
 3825|      0|                                  not variant_alternative_exhausted(ctx)) {
  ------------------
  |  Branch (3825:35): [True: 0, False: 0]
  ------------------
 3826|      0|                                 ctx.error = error_code::none;
 3827|      0|                              }
 3828|    344|                           }
 3829|       |                        }
 3830|       |                        else {
 3831|       |                           it = copy_it;
 3832|       |                           rewind_depth<Options>(ctx, copy_depth);
 3833|       |                           if (non_const_idx + 1 < non_const_count && not exhausted &&
 3834|       |                               not variant_alternative_exhausted(ctx)) {
 3835|       |                              ctx.error = error_code::none;
 3836|       |                           }
 3837|       |                        }
 3838|       |                     }
 3839|       |                     else {
 3840|       |                        it = copy_it;
 3841|       |                        rewind_depth<Options>(ctx, copy_depth);
 3842|       |                        if (non_const_idx + 1 < non_const_count && not exhausted &&
 3843|       |                            not variant_alternative_exhausted(ctx)) {
 3844|       |                           ctx.error = error_code::none;
 3845|       |                        }
 3846|       |                     }
 3847|  1.26k|                     ++non_const_idx;
 3848|  1.26k|                  }
 3849|  1.26k|               });
_ZN3glz29variant_alternative_exhaustedITkNS_10is_contextENS_7contextEEEbRT_:
 3714|  3.25M|   {
 3715|  3.25M|      return ctx.error == error_code::exceeded_max_recursive_depth;
 3716|  3.25M|   }
_ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEERNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEETkNS_10is_contextERNS_7contextERPKcSF_EEvOT0_OT1_OT2_T3_:
   49|   760k|      {
   50|       |         if constexpr (const_value_v<T>) {
   51|       |            if constexpr (check_error_on_const_read(Opts)) {
   52|       |               ctx.error = error_code::attempt_const_read;
   53|       |            }
   54|       |            else {
   55|       |               // do not read anything into the const value
   56|       |               skip_value<JSON>::op<Opts>(std::forward<Ctx>(ctx), std::forward<It0>(it), end);
   57|       |            }
   58|       |         }
   59|   760k|         else {
   60|   760k|            using V = std::remove_cvref_t<T>;
   61|   760k|            from<JSON, V>::template op<Opts>(std::forward<T>(value), std::forward<Ctx>(ctx), std::forward<It0>(it),
   62|   760k|                                             end);
   63|   760k|         }
   64|   760k|      }
_ZN3glz12rewind_depthITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETkNS_10is_contextENS_7contextEEEvRT0_j:
 3697|  60.4k|   {
 3698|  60.4k|      if (ctx.error == error_code::exceeded_max_recursive_depth) [[unlikely]] {
  ------------------
  |  Branch (3698:11): [True: 0, False: 60.4k]
  ------------------
 3699|      0|         return;
 3700|      0|      }
 3701|       |      if constexpr (Opts.null_terminated) {
 3702|       |         ctx.depth = depth;
 3703|       |      }
 3704|  60.4k|      else {
 3705|  60.4k|         if (ctx.error != error_code::end_reached && ctx.error != error_code::unexpected_end) {
  ------------------
  |  Branch (3705:14): [True: 59.4k, False: 964]
  |  Branch (3705:54): [True: 59.4k, False: 1]
  ------------------
 3706|  59.4k|            ctx.depth = depth;
 3707|  59.4k|         }
 3708|  60.4k|      }
 3709|  60.4k|   }
_ZZN3glz28process_variant_alternativesINSt3__17variantIJNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEN12jsonrpc_fuzz6amountEEEENS_14is_variant_strEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSB_TkNS_10is_contextERNS_7contextERPKcSK_EEvOT0_OT1_OT2_T3_ENKUlTnmvE_clILm1EEEDav:
 3794|  1.26k|               for_each<N>([&]<size_t I>() {
 3795|  1.26k|                  if (found_match || exhausted || variant_alternative_exhausted(ctx)) {
  ------------------
  |  Branch (3795:23): [True: 923, False: 344]
  |  Branch (3795:38): [True: 0, False: 344]
  |  Branch (3795:51): [True: 0, False: 344]
  ------------------
 3796|    923|                     return;
 3797|    923|                  }
 3798|    344|                  using V = std::variant_alternative_t<I, Variant>;
 3799|       |                  if constexpr (Trait<V>::value && !glaze_const_value_t<V>) {
 3800|       |                     auto copy_it{it};
 3801|       |                     const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above
 3802|       |                     if (!std::holds_alternative<V>(value)) {
 3803|       |                        value = V{};
 3804|       |                     }
 3805|       |                     parse<JSON>::op<ws_handled<Options>()>(std::get<V>(value), ctx, it, end);
 3806|       |                     if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) {
 3807|       |                        exhausted = true; // only rejected attempts are charged; see charge_speculation
 3808|       |                     }
 3809|       |                     if (!bool(ctx.error)) {
 3810|       |                        found_match = true;
 3811|       |                     }
 3812|       |                     else if constexpr (not Options.null_terminated) {
 3813|       |                        constexpr bool is_complete_type =
 3814|       |                           num_t<V> || bool_t<V> || string_t<V> || std::is_enum_v<V> || tuple_t<V> || is_std_tuple<V>;
 3815|       |
 3816|       |                        if constexpr (is_complete_type) {
 3817|       |                           if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) {
 3818|       |                              found_match = true;
 3819|       |                              ctx.error = error_code::none;
 3820|       |                           }
 3821|       |                           else {
 3822|       |                              it = copy_it;
 3823|       |                              rewind_depth<Options>(ctx, copy_depth);
 3824|       |                              if (non_const_idx + 1 < non_const_count && not exhausted &&
 3825|       |                                  not variant_alternative_exhausted(ctx)) {
 3826|       |                                 ctx.error = error_code::none;
 3827|       |                              }
 3828|       |                           }
 3829|       |                        }
 3830|       |                        else {
 3831|       |                           it = copy_it;
 3832|       |                           rewind_depth<Options>(ctx, copy_depth);
 3833|       |                           if (non_const_idx + 1 < non_const_count && not exhausted &&
 3834|       |                               not variant_alternative_exhausted(ctx)) {
 3835|       |                              ctx.error = error_code::none;
 3836|       |                           }
 3837|       |                        }
 3838|       |                     }
 3839|       |                     else {
 3840|       |                        it = copy_it;
 3841|       |                        rewind_depth<Options>(ctx, copy_depth);
 3842|       |                        if (non_const_idx + 1 < non_const_count && not exhausted &&
 3843|       |                            not variant_alternative_exhausted(ctx)) {
 3844|       |                           ctx.error = error_code::none;
 3845|       |                        }
 3846|       |                     }
 3847|       |                     ++non_const_idx;
 3848|       |                  }
 3849|    344|               });
_ZN3glz28process_variant_alternativesINSt3__17variantIJNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEN12jsonrpc_fuzz6amountEEEENS_15is_variant_boolEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSB_TkNS_10is_contextERNS_7contextERPKcSK_EEvOT0_OT1_OT2_T3_:
 3725|     12|      {
 3726|     12|         constexpr auto category_count = variant_count_v<Variant, Trait>;
 3727|       |
 3728|     12|         if constexpr (category_count == 0) {
 3729|     12|            ctx.error = error_code::no_matching_variant_type;
 3730|       |         }
 3731|       |         else {
 3732|       |            constexpr auto N = std::variant_size_v<Variant>;
 3733|       |            constexpr auto const_count = variant_filtered_count_v<Variant, Trait, true>;
 3734|       |            constexpr auto non_const_count = variant_filtered_count_v<Variant, Trait, false>;
 3735|       |
 3736|       |            bool found_match{};
 3737|       |            // Set when the speculative parsing budget runs out; see charge_speculation. An ambiguous
 3738|       |            // nest re-parses the same subtree per alternative at every level, which is exponential,
 3739|       |            // so the budget stops it and the failure already in hand is reported.
 3740|       |            bool exhausted{};
 3741|       |
 3742|       |            // First pass: const glaze types in this category
 3743|       |            if constexpr (const_count > 0) {
 3744|       |               for_each<N>([&]<size_t I>() {
 3745|       |                  if (found_match || exhausted || variant_alternative_exhausted(ctx)) {
 3746|       |                     return;
 3747|       |                  }
 3748|       |                  using V = std::variant_alternative_t<I, Variant>;
 3749|       |                  if constexpr (Trait<V>::value && glaze_const_value_t<V>) {
 3750|       |                     // run time substitute to compare to const value
 3751|       |                     std::remove_const_t<std::remove_pointer_t<std::remove_const_t<meta_wrapper_t<V>>>> substitute{};
 3752|       |                     auto copy_it{it};
 3753|       |                     // A rejected alternative may have bailed out inside a container, which leaves its
 3754|       |                     // nesting level counted (see enter_depth). Rewind the depth with the iterator so
 3755|       |                     // trying N alternatives cannot spend N levels of the recursion budget.
 3756|       |                     const auto copy_depth{ctx.depth};
 3757|       |                     parse<JSON>::op<ws_handled<Options>()>(substitute, ctx, it, end);
 3758|       |                     static constexpr auto const_value{*meta_wrapper_v<V>};
 3759|       |                     if (substitute == const_value) {
 3760|       |                        found_match = true;
 3761|       |                        if (!std::holds_alternative<V>(value)) {
 3762|       |                           value = V{};
 3763|       |                        }
 3764|       |                     }
 3765|       |                     else {
 3766|       |                        // Rejected: charge the bytes it parsed before we rewind. See charge_speculation.
 3767|       |                        if (!charge_speculation(ctx, size_t(it - copy_it))) {
 3768|       |                           exhausted = true;
 3769|       |                        }
 3770|       |                        if constexpr (not Options.null_terminated) {
 3771|       |                           if (ctx.error == error_code::end_reached && not exhausted) {
 3772|       |                              ctx.error = error_code::none;
 3773|       |                           }
 3774|       |                        }
 3775|       |                        it = copy_it;
 3776|       |                        rewind_depth<Options>(ctx, copy_depth);
 3777|       |                     }
 3778|       |                  }
 3779|       |               });
 3780|       |               if (found_match) {
 3781|       |                  return;
 3782|       |               }
 3783|       |            }
 3784|       |
 3785|       |            // Second pass: non-const types in this category
 3786|       |            if constexpr (non_const_count > 0) {
 3787|       |               // Track position within matching types for "is last" check.
 3788|       |               // We iterate over all variant indices but only process matching types,
 3789|       |               // so we need runtime tracking (vs the old tuple-based approach where
 3790|       |               // the loop index directly corresponded to position in filtered set).
 3791|       |               // This has negligible cost: one increment per matching type.
 3792|       |               size_t non_const_idx = 0;
 3793|       |
 3794|       |               for_each<N>([&]<size_t I>() {
 3795|       |                  if (found_match || exhausted || variant_alternative_exhausted(ctx)) {
 3796|       |                     return;
 3797|       |                  }
 3798|       |                  using V = std::variant_alternative_t<I, Variant>;
 3799|       |                  if constexpr (Trait<V>::value && !glaze_const_value_t<V>) {
 3800|       |                     auto copy_it{it};
 3801|       |                     const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above
 3802|       |                     if (!std::holds_alternative<V>(value)) {
 3803|       |                        value = V{};
 3804|       |                     }
 3805|       |                     parse<JSON>::op<ws_handled<Options>()>(std::get<V>(value), ctx, it, end);
 3806|       |                     if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) {
 3807|       |                        exhausted = true; // only rejected attempts are charged; see charge_speculation
 3808|       |                     }
 3809|       |                     if (!bool(ctx.error)) {
 3810|       |                        found_match = true;
 3811|       |                     }
 3812|       |                     else if constexpr (not Options.null_terminated) {
 3813|       |                        constexpr bool is_complete_type =
 3814|       |                           num_t<V> || bool_t<V> || string_t<V> || std::is_enum_v<V> || tuple_t<V> || is_std_tuple<V>;
 3815|       |
 3816|       |                        if constexpr (is_complete_type) {
 3817|       |                           if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) {
 3818|       |                              found_match = true;
 3819|       |                              ctx.error = error_code::none;
 3820|       |                           }
 3821|       |                           else {
 3822|       |                              it = copy_it;
 3823|       |                              rewind_depth<Options>(ctx, copy_depth);
 3824|       |                              if (non_const_idx + 1 < non_const_count && not exhausted &&
 3825|       |                                  not variant_alternative_exhausted(ctx)) {
 3826|       |                                 ctx.error = error_code::none;
 3827|       |                              }
 3828|       |                           }
 3829|       |                        }
 3830|       |                        else {
 3831|       |                           it = copy_it;
 3832|       |                           rewind_depth<Options>(ctx, copy_depth);
 3833|       |                           if (non_const_idx + 1 < non_const_count && not exhausted &&
 3834|       |                               not variant_alternative_exhausted(ctx)) {
 3835|       |                              ctx.error = error_code::none;
 3836|       |                           }
 3837|       |                        }
 3838|       |                     }
 3839|       |                     else {
 3840|       |                        it = copy_it;
 3841|       |                        rewind_depth<Options>(ctx, copy_depth);
 3842|       |                        if (non_const_idx + 1 < non_const_count && not exhausted &&
 3843|       |                            not variant_alternative_exhausted(ctx)) {
 3844|       |                           ctx.error = error_code::none;
 3845|       |                        }
 3846|       |                     }
 3847|       |                     ++non_const_idx;
 3848|       |                  }
 3849|       |               });
 3850|       |               if (!found_match) {
 3851|       |                  if constexpr (non_const_count == 1) {
 3852|       |                     // Keep the specific error from the single type we tried
 3853|       |                  }
 3854|       |                  else if (not exhausted && not variant_alternative_exhausted(ctx)) {
 3855|       |                     // Over-nested input is not a failure of the alternative set; keep saying so.
 3856|       |                     ctx.error = error_code::no_matching_variant_type;
 3857|       |                  }
 3858|       |               }
 3859|       |            }
 3860|       |            else {
 3861|       |               ctx.error = error_code::no_matching_variant_type;
 3862|       |            }
 3863|       |         }
 3864|     12|      }
_ZN3glz28process_variant_alternativesINSt3__17variantIJNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEN12jsonrpc_fuzz6amountEEEENS_14is_variant_numEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSB_TkNS_10is_contextERNS_7contextERPKcSK_EEvOT0_OT1_OT2_T3_:
 3725|    217|      {
 3726|    217|         constexpr auto category_count = variant_count_v<Variant, Trait>;
 3727|       |
 3728|    217|         if constexpr (category_count == 0) {
 3729|    217|            ctx.error = error_code::no_matching_variant_type;
 3730|       |         }
 3731|       |         else {
 3732|       |            constexpr auto N = std::variant_size_v<Variant>;
 3733|       |            constexpr auto const_count = variant_filtered_count_v<Variant, Trait, true>;
 3734|       |            constexpr auto non_const_count = variant_filtered_count_v<Variant, Trait, false>;
 3735|       |
 3736|       |            bool found_match{};
 3737|       |            // Set when the speculative parsing budget runs out; see charge_speculation. An ambiguous
 3738|       |            // nest re-parses the same subtree per alternative at every level, which is exponential,
 3739|       |            // so the budget stops it and the failure already in hand is reported.
 3740|       |            bool exhausted{};
 3741|       |
 3742|       |            // First pass: const glaze types in this category
 3743|       |            if constexpr (const_count > 0) {
 3744|       |               for_each<N>([&]<size_t I>() {
 3745|       |                  if (found_match || exhausted || variant_alternative_exhausted(ctx)) {
 3746|       |                     return;
 3747|       |                  }
 3748|       |                  using V = std::variant_alternative_t<I, Variant>;
 3749|       |                  if constexpr (Trait<V>::value && glaze_const_value_t<V>) {
 3750|       |                     // run time substitute to compare to const value
 3751|       |                     std::remove_const_t<std::remove_pointer_t<std::remove_const_t<meta_wrapper_t<V>>>> substitute{};
 3752|       |                     auto copy_it{it};
 3753|       |                     // A rejected alternative may have bailed out inside a container, which leaves its
 3754|       |                     // nesting level counted (see enter_depth). Rewind the depth with the iterator so
 3755|       |                     // trying N alternatives cannot spend N levels of the recursion budget.
 3756|       |                     const auto copy_depth{ctx.depth};
 3757|       |                     parse<JSON>::op<ws_handled<Options>()>(substitute, ctx, it, end);
 3758|       |                     static constexpr auto const_value{*meta_wrapper_v<V>};
 3759|       |                     if (substitute == const_value) {
 3760|       |                        found_match = true;
 3761|       |                        if (!std::holds_alternative<V>(value)) {
 3762|       |                           value = V{};
 3763|       |                        }
 3764|       |                     }
 3765|       |                     else {
 3766|       |                        // Rejected: charge the bytes it parsed before we rewind. See charge_speculation.
 3767|       |                        if (!charge_speculation(ctx, size_t(it - copy_it))) {
 3768|       |                           exhausted = true;
 3769|       |                        }
 3770|       |                        if constexpr (not Options.null_terminated) {
 3771|       |                           if (ctx.error == error_code::end_reached && not exhausted) {
 3772|       |                              ctx.error = error_code::none;
 3773|       |                           }
 3774|       |                        }
 3775|       |                        it = copy_it;
 3776|       |                        rewind_depth<Options>(ctx, copy_depth);
 3777|       |                     }
 3778|       |                  }
 3779|       |               });
 3780|       |               if (found_match) {
 3781|       |                  return;
 3782|       |               }
 3783|       |            }
 3784|       |
 3785|       |            // Second pass: non-const types in this category
 3786|       |            if constexpr (non_const_count > 0) {
 3787|       |               // Track position within matching types for "is last" check.
 3788|       |               // We iterate over all variant indices but only process matching types,
 3789|       |               // so we need runtime tracking (vs the old tuple-based approach where
 3790|       |               // the loop index directly corresponded to position in filtered set).
 3791|       |               // This has negligible cost: one increment per matching type.
 3792|       |               size_t non_const_idx = 0;
 3793|       |
 3794|       |               for_each<N>([&]<size_t I>() {
 3795|       |                  if (found_match || exhausted || variant_alternative_exhausted(ctx)) {
 3796|       |                     return;
 3797|       |                  }
 3798|       |                  using V = std::variant_alternative_t<I, Variant>;
 3799|       |                  if constexpr (Trait<V>::value && !glaze_const_value_t<V>) {
 3800|       |                     auto copy_it{it};
 3801|       |                     const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above
 3802|       |                     if (!std::holds_alternative<V>(value)) {
 3803|       |                        value = V{};
 3804|       |                     }
 3805|       |                     parse<JSON>::op<ws_handled<Options>()>(std::get<V>(value), ctx, it, end);
 3806|       |                     if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) {
 3807|       |                        exhausted = true; // only rejected attempts are charged; see charge_speculation
 3808|       |                     }
 3809|       |                     if (!bool(ctx.error)) {
 3810|       |                        found_match = true;
 3811|       |                     }
 3812|       |                     else if constexpr (not Options.null_terminated) {
 3813|       |                        constexpr bool is_complete_type =
 3814|       |                           num_t<V> || bool_t<V> || string_t<V> || std::is_enum_v<V> || tuple_t<V> || is_std_tuple<V>;
 3815|       |
 3816|       |                        if constexpr (is_complete_type) {
 3817|       |                           if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) {
 3818|       |                              found_match = true;
 3819|       |                              ctx.error = error_code::none;
 3820|       |                           }
 3821|       |                           else {
 3822|       |                              it = copy_it;
 3823|       |                              rewind_depth<Options>(ctx, copy_depth);
 3824|       |                              if (non_const_idx + 1 < non_const_count && not exhausted &&
 3825|       |                                  not variant_alternative_exhausted(ctx)) {
 3826|       |                                 ctx.error = error_code::none;
 3827|       |                              }
 3828|       |                           }
 3829|       |                        }
 3830|       |                        else {
 3831|       |                           it = copy_it;
 3832|       |                           rewind_depth<Options>(ctx, copy_depth);
 3833|       |                           if (non_const_idx + 1 < non_const_count && not exhausted &&
 3834|       |                               not variant_alternative_exhausted(ctx)) {
 3835|       |                              ctx.error = error_code::none;
 3836|       |                           }
 3837|       |                        }
 3838|       |                     }
 3839|       |                     else {
 3840|       |                        it = copy_it;
 3841|       |                        rewind_depth<Options>(ctx, copy_depth);
 3842|       |                        if (non_const_idx + 1 < non_const_count && not exhausted &&
 3843|       |                            not variant_alternative_exhausted(ctx)) {
 3844|       |                           ctx.error = error_code::none;
 3845|       |                        }
 3846|       |                     }
 3847|       |                     ++non_const_idx;
 3848|       |                  }
 3849|       |               });
 3850|       |               if (!found_match) {
 3851|       |                  if constexpr (non_const_count == 1) {
 3852|       |                     // Keep the specific error from the single type we tried
 3853|       |                  }
 3854|       |                  else if (not exhausted && not variant_alternative_exhausted(ctx)) {
 3855|       |                     // Over-nested input is not a failure of the alternative set; keep saying so.
 3856|       |                     ctx.error = error_code::no_matching_variant_type;
 3857|       |                  }
 3858|       |               }
 3859|       |            }
 3860|       |            else {
 3861|       |               ctx.error = error_code::no_matching_variant_type;
 3862|       |            }
 3863|       |         }
 3864|    217|      }
_ZZN3glz16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT3_OT4_OT5_DpOT2_ENKUlTnmvE_clILm8EEEDav:
  484|    414|            visit<N>([&]<size_t I>() { decode_index<Opts, T, I>(value, ctx, it, end, selected_index...); }, index);
_ZN3glz12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiELm8ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT2_OT4_OT5_OT6_DpOT3_:
  311|    414|   {
  312|    414|      static constexpr auto Key = get<I>(reflect<T>::keys);
  313|    414|      static constexpr auto KeyWithEndQuote = join_v<Key, chars<"\"">>;
  314|    414|      static constexpr auto Length = KeyWithEndQuote.size();
  315|       |
  316|    414|      if (((it + Length) < end) && comparitor<KeyWithEndQuote>(it)) [[likely]] {
  ------------------
  |  Branch (316:11): [True: 411, False: 3]
  |  Branch (316:36): [True: 261, False: 150]
  ------------------
  317|    261|         it += Length;
  318|    261|         if constexpr (not Opts.null_terminated) {
  319|    261|            if (it == end) [[unlikely]] {
  ------------------
  |  Branch (319:17): [True: 0, False: 261]
  ------------------
  320|      0|               ctx.error = error_code::unexpected_end;
  321|      0|               return;
  322|      0|            }
  323|    261|         }
  324|       |
  325|    261|         if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (325:14): [True: 0, False: 261]
  ------------------
  326|      0|            return;
  327|      0|         }
  328|    261|         if (match_invalid_end<':', Opts>(ctx, it, end)) {
  ------------------
  |  Branch (328:14): [True: 22, False: 239]
  ------------------
  329|     22|            return;
  330|     22|         }
  331|    239|         if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (331:14): [True: 0, False: 239]
  ------------------
  332|      0|            return;
  333|      0|         }
  334|       |
  335|       |         // The hash path has already consumed the whitespace before the value
  336|    239|         decode_field_value<Opts, ws_handled<Opts>(), T, I>(value, ctx, it, end, selected_index...);
  337|    239|      }
  338|    153|      else [[unlikely]] {
  339|    153|         decode_index_unknown_key<Opts, T>(value, ctx, it, end);
  340|    153|      }
  341|    414|   }
_ZN3glz18decode_field_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnDaXtlS1_Lj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEEN12jsonrpc_fuzz8fuzz_apiELm8ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT1_E11reflectableISA_EEEvOT3_OT5_OT6_OT7_DpOT4_:
  245|    239|   {
  246|       |      // Check for null value skipping on read
  247|       |      if constexpr (check_skip_null_members_on_read(Opts)) {
  248|       |         if (*it == 'n') {
  249|       |            ++it;
  250|       |            if constexpr (not Opts.null_terminated) {
  251|       |               if (it == end) [[unlikely]] {
  252|       |                  ctx.error = error_code::unexpected_end;
  253|       |                  return;
  254|       |               }
  255|       |            }
  256|       |            match<"ull", Opts>(ctx, it, end);
  257|       |            if (bool(ctx.error)) [[unlikely]]
  258|       |               return;
  259|       |            // Successfully matched "null", skip it
  260|       |            if constexpr (Opts.error_on_missing_keys || Opts.partial_read) {
  261|       |               ((selected_index = I), ...); // Mark as handled even if skipped
  262|       |            }
  263|       |            return;
  264|       |         }
  265|       |      }
  266|       |
  267|       |      if constexpr (skipped_by_meta<T, I, operation::parse>) {
  268|       |         skip_value<JSON>::op<Opts>(ctx, it, end);
  269|       |         if (bool(ctx.error)) [[unlikely]]
  270|       |            return; // Propagate error from skip_value
  271|       |      }
  272|    239|      else {
  273|    239|         using V = refl_t<T, I>;
  274|       |
  275|       |         if constexpr (const_value_v<V>) {
  276|       |            if constexpr (check_error_on_const_read(Opts)) {
  277|       |               ctx.error = error_code::attempt_const_read;
  278|       |            }
  279|       |            else {
  280|       |               // do not read anything into the const value
  281|       |               skip_value<JSON>::op<Opts>(ctx, it, end);
  282|       |            }
  283|       |         }
  284|       |         else if constexpr (is_function_ptr_or_ref<V>) {
  285|       |            // Function pointers cannot be deserialized from JSON.
  286|       |            // When write_function_pointers is enabled the writer emits a type-name string,
  287|       |            // but there is nothing meaningful to reconstruct on read — just skip the value.
  288|       |            // When write_function_pointers is off the key is never written, so this branch
  289|       |            // is unreachable in that case.
  290|       |            skip_value<JSON>::op<Opts>(ctx, it, end);
  291|       |         }
  292|       |         else if constexpr (glaze_object_t<T>) {
  293|       |            from<JSON, std::remove_cvref_t<V>>::template op<FieldOpts>(get_member(value, get<I>(reflect<T>::values)),
  294|       |                                                                       ctx, it, end);
  295|       |         }
  296|    239|         else {
  297|    239|            from<JSON, std::remove_cvref_t<V>>::template op<FieldOpts>(get_member(value, get<I>(to_tie(value))), ctx,
  298|    239|                                                                       it, end);
  299|    239|         }
  300|    239|      }
  301|       |
  302|       |      // The key was present and handled, even when the value itself was skipped
  303|       |      if constexpr (Opts.error_on_missing_keys || Opts.partial_read) {
  304|       |         ((selected_index = I), ...);
  305|       |      }
  306|    239|   }
_ZN3glz4fromILj10ENSt3__18functionIFiiEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEES4_TkNS_10is_contextERNS_7contextERPKcSB_EEvRT0_OT1_OT2_T3_:
 2179|    239|      {
 2180|       |         if constexpr (!check_ws_handled(Opts)) {
 2181|       |            if (skip_ws<Opts>(ctx, it, end)) {
 2182|       |               return;
 2183|       |            }
 2184|       |         }
 2185|    239|         if (match_invalid_end<'"', Opts>(ctx, it, end)) {
  ------------------
  |  Branch (2185:14): [True: 20, False: 219]
  ------------------
 2186|     20|            return;
 2187|     20|         }
 2188|    219|         skip_string_view(ctx, it, end);
 2189|    219|         if (bool(ctx.error)) [[unlikely]]
  ------------------
  |  Branch (2189:14): [True: 0, False: 219]
  ------------------
 2190|      0|            return;
 2191|    219|         if (match<'"'>(ctx, it)) {
  ------------------
  |  Branch (2191:14): [True: 0, False: 219]
  ------------------
 2192|      0|            return;
 2193|      0|         }
 2194|    219|         if constexpr (not Opts.null_terminated) {
 2195|    219|            if (it == end) {
  ------------------
  |  Branch (2195:17): [True: 0, False: 219]
  ------------------
 2196|      0|               ctx.error = error_code::end_reached;
 2197|      0|               return;
 2198|      0|            }
 2199|    219|         }
 2200|    219|      }
_ZZN3glz16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT3_OT4_OT5_DpOT2_ENKUlTnmvE_clILm9EEEDav:
  484|  8.22k|            visit<N>([&]<size_t I>() { decode_index<Opts, T, I>(value, ctx, it, end, selected_index...); }, index);
_ZN3glz12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiELm9ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT2_OT4_OT5_OT6_DpOT3_:
  311|  8.22k|   {
  312|  8.22k|      static constexpr auto Key = get<I>(reflect<T>::keys);
  313|  8.22k|      static constexpr auto KeyWithEndQuote = join_v<Key, chars<"\"">>;
  314|  8.22k|      static constexpr auto Length = KeyWithEndQuote.size();
  315|       |
  316|  8.22k|      if (((it + Length) < end) && comparitor<KeyWithEndQuote>(it)) [[likely]] {
  ------------------
  |  Branch (316:11): [True: 8.22k, False: 3]
  |  Branch (316:36): [True: 8.21k, False: 4]
  ------------------
  317|  8.21k|         it += Length;
  318|  8.21k|         if constexpr (not Opts.null_terminated) {
  319|  8.21k|            if (it == end) [[unlikely]] {
  ------------------
  |  Branch (319:17): [True: 0, False: 8.21k]
  ------------------
  320|      0|               ctx.error = error_code::unexpected_end;
  321|      0|               return;
  322|      0|            }
  323|  8.21k|         }
  324|       |
  325|  8.21k|         if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (325:14): [True: 0, False: 8.21k]
  ------------------
  326|      0|            return;
  327|      0|         }
  328|  8.21k|         if (match_invalid_end<':', Opts>(ctx, it, end)) {
  ------------------
  |  Branch (328:14): [True: 34, False: 8.18k]
  ------------------
  329|     34|            return;
  330|     34|         }
  331|  8.18k|         if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (331:14): [True: 0, False: 8.18k]
  ------------------
  332|      0|            return;
  333|      0|         }
  334|       |
  335|       |         // The hash path has already consumed the whitespace before the value
  336|  8.18k|         decode_field_value<Opts, ws_handled<Opts>(), T, I>(value, ctx, it, end, selected_index...);
  337|  8.18k|      }
  338|      7|      else [[unlikely]] {
  339|      7|         decode_index_unknown_key<Opts, T>(value, ctx, it, end);
  340|      7|      }
  341|  8.22k|   }
_ZN3glz18decode_field_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnDaXtlS1_Lj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEEN12jsonrpc_fuzz8fuzz_apiELm9ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT1_E11reflectableISA_EEEvOT3_OT5_OT6_OT7_DpOT4_:
  245|  8.18k|   {
  246|       |      // Check for null value skipping on read
  247|       |      if constexpr (check_skip_null_members_on_read(Opts)) {
  248|       |         if (*it == 'n') {
  249|       |            ++it;
  250|       |            if constexpr (not Opts.null_terminated) {
  251|       |               if (it == end) [[unlikely]] {
  252|       |                  ctx.error = error_code::unexpected_end;
  253|       |                  return;
  254|       |               }
  255|       |            }
  256|       |            match<"ull", Opts>(ctx, it, end);
  257|       |            if (bool(ctx.error)) [[unlikely]]
  258|       |               return;
  259|       |            // Successfully matched "null", skip it
  260|       |            if constexpr (Opts.error_on_missing_keys || Opts.partial_read) {
  261|       |               ((selected_index = I), ...); // Mark as handled even if skipped
  262|       |            }
  263|       |            return;
  264|       |         }
  265|       |      }
  266|       |
  267|       |      if constexpr (skipped_by_meta<T, I, operation::parse>) {
  268|       |         skip_value<JSON>::op<Opts>(ctx, it, end);
  269|       |         if (bool(ctx.error)) [[unlikely]]
  270|       |            return; // Propagate error from skip_value
  271|       |      }
  272|  8.18k|      else {
  273|  8.18k|         using V = refl_t<T, I>;
  274|       |
  275|       |         if constexpr (const_value_v<V>) {
  276|       |            if constexpr (check_error_on_const_read(Opts)) {
  277|       |               ctx.error = error_code::attempt_const_read;
  278|       |            }
  279|       |            else {
  280|       |               // do not read anything into the const value
  281|       |               skip_value<JSON>::op<Opts>(ctx, it, end);
  282|       |            }
  283|       |         }
  284|       |         else if constexpr (is_function_ptr_or_ref<V>) {
  285|       |            // Function pointers cannot be deserialized from JSON.
  286|       |            // When write_function_pointers is enabled the writer emits a type-name string,
  287|       |            // but there is nothing meaningful to reconstruct on read — just skip the value.
  288|       |            // When write_function_pointers is off the key is never written, so this branch
  289|       |            // is unreachable in that case.
  290|       |            skip_value<JSON>::op<Opts>(ctx, it, end);
  291|       |         }
  292|       |         else if constexpr (glaze_object_t<T>) {
  293|       |            from<JSON, std::remove_cvref_t<V>>::template op<FieldOpts>(get_member(value, get<I>(reflect<T>::values)),
  294|       |                                                                       ctx, it, end);
  295|       |         }
  296|  8.18k|         else {
  297|  8.18k|            from<JSON, std::remove_cvref_t<V>>::template op<FieldOpts>(get_member(value, get<I>(to_tie(value))), ctx,
  298|  8.18k|                                                                       it, end);
  299|  8.18k|         }
  300|  8.18k|      }
  301|       |
  302|       |      // The key was present and handled, even when the value itself was skipped
  303|       |      if constexpr (Opts.error_on_missing_keys || Opts.partial_read) {
  304|       |         ((selected_index = I), ...);
  305|       |      }
  306|  8.18k|   }
_ZN3glz4fromILj10ENSt3__18functionIFNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERKS8_EEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEESC_TkNS_10is_contextERNS_7contextERPKcSJ_EEvRT0_OT1_OT2_T3_:
 2179|  8.18k|      {
 2180|       |         if constexpr (!check_ws_handled(Opts)) {
 2181|       |            if (skip_ws<Opts>(ctx, it, end)) {
 2182|       |               return;
 2183|       |            }
 2184|       |         }
 2185|  8.18k|         if (match_invalid_end<'"', Opts>(ctx, it, end)) {
  ------------------
  |  Branch (2185:14): [True: 20, False: 8.16k]
  ------------------
 2186|     20|            return;
 2187|     20|         }
 2188|  8.16k|         skip_string_view(ctx, it, end);
 2189|  8.16k|         if (bool(ctx.error)) [[unlikely]]
  ------------------
  |  Branch (2189:14): [True: 0, False: 8.16k]
  ------------------
 2190|      0|            return;
 2191|  8.16k|         if (match<'"'>(ctx, it)) {
  ------------------
  |  Branch (2191:14): [True: 0, False: 8.16k]
  ------------------
 2192|      0|            return;
 2193|      0|         }
 2194|  8.16k|         if constexpr (not Opts.null_terminated) {
 2195|  8.16k|            if (it == end) {
  ------------------
  |  Branch (2195:17): [True: 0, False: 8.16k]
  ------------------
 2196|      0|               ctx.error = error_code::end_reached;
 2197|      0|               return;
 2198|      0|            }
 2199|  8.16k|         }
 2200|  8.16k|      }
_ZZN3glz16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT3_OT4_OT5_DpOT2_ENKUlTnmvE_clILm10EEEDav:
  484|    102|            visit<N>([&]<size_t I>() { decode_index<Opts, T, I>(value, ctx, it, end, selected_index...); }, index);
_ZN3glz12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiELm10ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT2_OT4_OT5_OT6_DpOT3_:
  311|    102|   {
  312|    102|      static constexpr auto Key = get<I>(reflect<T>::keys);
  313|    102|      static constexpr auto KeyWithEndQuote = join_v<Key, chars<"\"">>;
  314|    102|      static constexpr auto Length = KeyWithEndQuote.size();
  315|       |
  316|    102|      if (((it + Length) < end) && comparitor<KeyWithEndQuote>(it)) [[likely]] {
  ------------------
  |  Branch (316:11): [True: 97, False: 5]
  |  Branch (316:36): [True: 72, False: 25]
  ------------------
  317|     72|         it += Length;
  318|     72|         if constexpr (not Opts.null_terminated) {
  319|     72|            if (it == end) [[unlikely]] {
  ------------------
  |  Branch (319:17): [True: 0, False: 72]
  ------------------
  320|      0|               ctx.error = error_code::unexpected_end;
  321|      0|               return;
  322|      0|            }
  323|     72|         }
  324|       |
  325|     72|         if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (325:14): [True: 0, False: 72]
  ------------------
  326|      0|            return;
  327|      0|         }
  328|     72|         if (match_invalid_end<':', Opts>(ctx, it, end)) {
  ------------------
  |  Branch (328:14): [True: 22, False: 50]
  ------------------
  329|     22|            return;
  330|     22|         }
  331|     50|         if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (331:14): [True: 0, False: 50]
  ------------------
  332|      0|            return;
  333|      0|         }
  334|       |
  335|       |         // The hash path has already consumed the whitespace before the value
  336|     50|         decode_field_value<Opts, ws_handled<Opts>(), T, I>(value, ctx, it, end, selected_index...);
  337|     50|      }
  338|     30|      else [[unlikely]] {
  339|     30|         decode_index_unknown_key<Opts, T>(value, ctx, it, end);
  340|     30|      }
  341|    102|   }
_ZN3glz18decode_field_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnDaXtlS1_Lj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEEN12jsonrpc_fuzz8fuzz_apiELm10ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT1_E11reflectableISA_EEEvOT3_OT5_OT6_OT7_DpOT4_:
  245|     50|   {
  246|       |      // Check for null value skipping on read
  247|       |      if constexpr (check_skip_null_members_on_read(Opts)) {
  248|       |         if (*it == 'n') {
  249|       |            ++it;
  250|       |            if constexpr (not Opts.null_terminated) {
  251|       |               if (it == end) [[unlikely]] {
  252|       |                  ctx.error = error_code::unexpected_end;
  253|       |                  return;
  254|       |               }
  255|       |            }
  256|       |            match<"ull", Opts>(ctx, it, end);
  257|       |            if (bool(ctx.error)) [[unlikely]]
  258|       |               return;
  259|       |            // Successfully matched "null", skip it
  260|       |            if constexpr (Opts.error_on_missing_keys || Opts.partial_read) {
  261|       |               ((selected_index = I), ...); // Mark as handled even if skipped
  262|       |            }
  263|       |            return;
  264|       |         }
  265|       |      }
  266|       |
  267|       |      if constexpr (skipped_by_meta<T, I, operation::parse>) {
  268|       |         skip_value<JSON>::op<Opts>(ctx, it, end);
  269|       |         if (bool(ctx.error)) [[unlikely]]
  270|       |            return; // Propagate error from skip_value
  271|       |      }
  272|     50|      else {
  273|     50|         using V = refl_t<T, I>;
  274|       |
  275|       |         if constexpr (const_value_v<V>) {
  276|       |            if constexpr (check_error_on_const_read(Opts)) {
  277|       |               ctx.error = error_code::attempt_const_read;
  278|       |            }
  279|       |            else {
  280|       |               // do not read anything into the const value
  281|       |               skip_value<JSON>::op<Opts>(ctx, it, end);
  282|       |            }
  283|       |         }
  284|       |         else if constexpr (is_function_ptr_or_ref<V>) {
  285|       |            // Function pointers cannot be deserialized from JSON.
  286|       |            // When write_function_pointers is enabled the writer emits a type-name string,
  287|       |            // but there is nothing meaningful to reconstruct on read — just skip the value.
  288|       |            // When write_function_pointers is off the key is never written, so this branch
  289|       |            // is unreachable in that case.
  290|       |            skip_value<JSON>::op<Opts>(ctx, it, end);
  291|       |         }
  292|       |         else if constexpr (glaze_object_t<T>) {
  293|       |            from<JSON, std::remove_cvref_t<V>>::template op<FieldOpts>(get_member(value, get<I>(reflect<T>::values)),
  294|       |                                                                       ctx, it, end);
  295|       |         }
  296|     50|         else {
  297|     50|            from<JSON, std::remove_cvref_t<V>>::template op<FieldOpts>(get_member(value, get<I>(to_tie(value))), ctx,
  298|     50|                                                                       it, end);
  299|     50|         }
  300|     50|      }
  301|       |
  302|       |      // The key was present and handled, even when the value itself was skipped
  303|       |      if constexpr (Opts.error_on_missing_keys || Opts.partial_read) {
  304|       |         ((selected_index = I), ...);
  305|       |      }
  306|     50|   }
_ZN3glz4fromILj10ENSt3__18functionIFN12jsonrpc_fuzz5pointERKS4_EEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEES8_TkNS_10is_contextERNS_7contextERPKcSF_EEvRT0_OT1_OT2_T3_:
 2179|     50|      {
 2180|       |         if constexpr (!check_ws_handled(Opts)) {
 2181|       |            if (skip_ws<Opts>(ctx, it, end)) {
 2182|       |               return;
 2183|       |            }
 2184|       |         }
 2185|     50|         if (match_invalid_end<'"', Opts>(ctx, it, end)) {
  ------------------
  |  Branch (2185:14): [True: 24, False: 26]
  ------------------
 2186|     24|            return;
 2187|     24|         }
 2188|     26|         skip_string_view(ctx, it, end);
 2189|     26|         if (bool(ctx.error)) [[unlikely]]
  ------------------
  |  Branch (2189:14): [True: 0, False: 26]
  ------------------
 2190|      0|            return;
 2191|     26|         if (match<'"'>(ctx, it)) {
  ------------------
  |  Branch (2191:14): [True: 0, False: 26]
  ------------------
 2192|      0|            return;
 2193|      0|         }
 2194|     26|         if constexpr (not Opts.null_terminated) {
 2195|     26|            if (it == end) {
  ------------------
  |  Branch (2195:17): [True: 0, False: 26]
  ------------------
 2196|      0|               ctx.error = error_code::end_reached;
 2197|      0|               return;
 2198|      0|            }
 2199|     26|         }
 2200|     26|      }
_ZZN3glz16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT3_OT4_OT5_DpOT2_ENKUlTnmvE_clILm11EEEDav:
  484|     64|            visit<N>([&]<size_t I>() { decode_index<Opts, T, I>(value, ctx, it, end, selected_index...); }, index);
_ZN3glz12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiELm11ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT2_OT4_OT5_OT6_DpOT3_:
  311|     64|   {
  312|     64|      static constexpr auto Key = get<I>(reflect<T>::keys);
  313|     64|      static constexpr auto KeyWithEndQuote = join_v<Key, chars<"\"">>;
  314|     64|      static constexpr auto Length = KeyWithEndQuote.size();
  315|       |
  316|     64|      if (((it + Length) < end) && comparitor<KeyWithEndQuote>(it)) [[likely]] {
  ------------------
  |  Branch (316:11): [True: 60, False: 4]
  |  Branch (316:36): [True: 57, False: 3]
  ------------------
  317|     57|         it += Length;
  318|     57|         if constexpr (not Opts.null_terminated) {
  319|     57|            if (it == end) [[unlikely]] {
  ------------------
  |  Branch (319:17): [True: 0, False: 57]
  ------------------
  320|      0|               ctx.error = error_code::unexpected_end;
  321|      0|               return;
  322|      0|            }
  323|     57|         }
  324|       |
  325|     57|         if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (325:14): [True: 0, False: 57]
  ------------------
  326|      0|            return;
  327|      0|         }
  328|     57|         if (match_invalid_end<':', Opts>(ctx, it, end)) {
  ------------------
  |  Branch (328:14): [True: 19, False: 38]
  ------------------
  329|     19|            return;
  330|     19|         }
  331|     38|         if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (331:14): [True: 0, False: 38]
  ------------------
  332|      0|            return;
  333|      0|         }
  334|       |
  335|       |         // The hash path has already consumed the whitespace before the value
  336|     38|         decode_field_value<Opts, ws_handled<Opts>(), T, I>(value, ctx, it, end, selected_index...);
  337|     38|      }
  338|      7|      else [[unlikely]] {
  339|      7|         decode_index_unknown_key<Opts, T>(value, ctx, it, end);
  340|      7|      }
  341|     64|   }
_ZN3glz18decode_field_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnDaXtlS1_Lj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEEN12jsonrpc_fuzz8fuzz_apiELm11ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT1_E11reflectableISA_EEEvOT3_OT5_OT6_OT7_DpOT4_:
  245|     38|   {
  246|       |      // Check for null value skipping on read
  247|       |      if constexpr (check_skip_null_members_on_read(Opts)) {
  248|       |         if (*it == 'n') {
  249|       |            ++it;
  250|       |            if constexpr (not Opts.null_terminated) {
  251|       |               if (it == end) [[unlikely]] {
  252|       |                  ctx.error = error_code::unexpected_end;
  253|       |                  return;
  254|       |               }
  255|       |            }
  256|       |            match<"ull", Opts>(ctx, it, end);
  257|       |            if (bool(ctx.error)) [[unlikely]]
  258|       |               return;
  259|       |            // Successfully matched "null", skip it
  260|       |            if constexpr (Opts.error_on_missing_keys || Opts.partial_read) {
  261|       |               ((selected_index = I), ...); // Mark as handled even if skipped
  262|       |            }
  263|       |            return;
  264|       |         }
  265|       |      }
  266|       |
  267|       |      if constexpr (skipped_by_meta<T, I, operation::parse>) {
  268|       |         skip_value<JSON>::op<Opts>(ctx, it, end);
  269|       |         if (bool(ctx.error)) [[unlikely]]
  270|       |            return; // Propagate error from skip_value
  271|       |      }
  272|     38|      else {
  273|     38|         using V = refl_t<T, I>;
  274|       |
  275|       |         if constexpr (const_value_v<V>) {
  276|       |            if constexpr (check_error_on_const_read(Opts)) {
  277|       |               ctx.error = error_code::attempt_const_read;
  278|       |            }
  279|       |            else {
  280|       |               // do not read anything into the const value
  281|       |               skip_value<JSON>::op<Opts>(ctx, it, end);
  282|       |            }
  283|       |         }
  284|       |         else if constexpr (is_function_ptr_or_ref<V>) {
  285|       |            // Function pointers cannot be deserialized from JSON.
  286|       |            // When write_function_pointers is enabled the writer emits a type-name string,
  287|       |            // but there is nothing meaningful to reconstruct on read — just skip the value.
  288|       |            // When write_function_pointers is off the key is never written, so this branch
  289|       |            // is unreachable in that case.
  290|       |            skip_value<JSON>::op<Opts>(ctx, it, end);
  291|       |         }
  292|       |         else if constexpr (glaze_object_t<T>) {
  293|       |            from<JSON, std::remove_cvref_t<V>>::template op<FieldOpts>(get_member(value, get<I>(reflect<T>::values)),
  294|       |                                                                       ctx, it, end);
  295|       |         }
  296|     38|         else {
  297|     38|            from<JSON, std::remove_cvref_t<V>>::template op<FieldOpts>(get_member(value, get<I>(to_tie(value))), ctx,
  298|     38|                                                                       it, end);
  299|     38|         }
  300|     38|      }
  301|       |
  302|       |      // The key was present and handled, even when the value itself was skipped
  303|       |      if constexpr (Opts.error_on_missing_keys || Opts.partial_read) {
  304|       |         ((selected_index = I), ...);
  305|       |      }
  306|     38|   }
_ZN3glz4fromILj10ENSt3__18functionIFdRNS1_6vectorIdNS1_9allocatorIdEEEEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEES9_TkNS_10is_contextERNS_7contextERPKcSG_EEvRT0_OT1_OT2_T3_:
 2179|     38|      {
 2180|       |         if constexpr (!check_ws_handled(Opts)) {
 2181|       |            if (skip_ws<Opts>(ctx, it, end)) {
 2182|       |               return;
 2183|       |            }
 2184|       |         }
 2185|     38|         if (match_invalid_end<'"', Opts>(ctx, it, end)) {
  ------------------
  |  Branch (2185:14): [True: 18, False: 20]
  ------------------
 2186|     18|            return;
 2187|     18|         }
 2188|     20|         skip_string_view(ctx, it, end);
 2189|     20|         if (bool(ctx.error)) [[unlikely]]
  ------------------
  |  Branch (2189:14): [True: 0, False: 20]
  ------------------
 2190|      0|            return;
 2191|     20|         if (match<'"'>(ctx, it)) {
  ------------------
  |  Branch (2191:14): [True: 0, False: 20]
  ------------------
 2192|      0|            return;
 2193|      0|         }
 2194|     20|         if constexpr (not Opts.null_terminated) {
 2195|     20|            if (it == end) {
  ------------------
  |  Branch (2195:17): [True: 0, False: 20]
  ------------------
 2196|      0|               ctx.error = error_code::end_reached;
 2197|      0|               return;
 2198|      0|            }
 2199|     20|         }
 2200|     20|      }
_ZZN3glz16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT3_OT4_OT5_DpOT2_ENKUlTnmvE_clILm12EEEDav:
  484|    163|            visit<N>([&]<size_t I>() { decode_index<Opts, T, I>(value, ctx, it, end, selected_index...); }, index);
_ZN3glz12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiELm12ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT2_OT4_OT5_OT6_DpOT3_:
  311|    163|   {
  312|    163|      static constexpr auto Key = get<I>(reflect<T>::keys);
  313|    163|      static constexpr auto KeyWithEndQuote = join_v<Key, chars<"\"">>;
  314|    163|      static constexpr auto Length = KeyWithEndQuote.size();
  315|       |
  316|    163|      if (((it + Length) < end) && comparitor<KeyWithEndQuote>(it)) [[likely]] {
  ------------------
  |  Branch (316:11): [True: 160, False: 3]
  |  Branch (316:36): [True: 157, False: 3]
  ------------------
  317|    157|         it += Length;
  318|    157|         if constexpr (not Opts.null_terminated) {
  319|    157|            if (it == end) [[unlikely]] {
  ------------------
  |  Branch (319:17): [True: 0, False: 157]
  ------------------
  320|      0|               ctx.error = error_code::unexpected_end;
  321|      0|               return;
  322|      0|            }
  323|    157|         }
  324|       |
  325|    157|         if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (325:14): [True: 0, False: 157]
  ------------------
  326|      0|            return;
  327|      0|         }
  328|    157|         if (match_invalid_end<':', Opts>(ctx, it, end)) {
  ------------------
  |  Branch (328:14): [True: 35, False: 122]
  ------------------
  329|     35|            return;
  330|     35|         }
  331|    122|         if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (331:14): [True: 0, False: 122]
  ------------------
  332|      0|            return;
  333|      0|         }
  334|       |
  335|       |         // The hash path has already consumed the whitespace before the value
  336|    122|         decode_field_value<Opts, ws_handled<Opts>(), T, I>(value, ctx, it, end, selected_index...);
  337|    122|      }
  338|      6|      else [[unlikely]] {
  339|      6|         decode_index_unknown_key<Opts, T>(value, ctx, it, end);
  340|      6|      }
  341|    163|   }
_ZN3glz18decode_field_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnDaXtlS1_Lj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEEN12jsonrpc_fuzz8fuzz_apiELm12ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT1_E11reflectableISA_EEEvOT3_OT5_OT6_OT7_DpOT4_:
  245|    122|   {
  246|       |      // Check for null value skipping on read
  247|       |      if constexpr (check_skip_null_members_on_read(Opts)) {
  248|       |         if (*it == 'n') {
  249|       |            ++it;
  250|       |            if constexpr (not Opts.null_terminated) {
  251|       |               if (it == end) [[unlikely]] {
  252|       |                  ctx.error = error_code::unexpected_end;
  253|       |                  return;
  254|       |               }
  255|       |            }
  256|       |            match<"ull", Opts>(ctx, it, end);
  257|       |            if (bool(ctx.error)) [[unlikely]]
  258|       |               return;
  259|       |            // Successfully matched "null", skip it
  260|       |            if constexpr (Opts.error_on_missing_keys || Opts.partial_read) {
  261|       |               ((selected_index = I), ...); // Mark as handled even if skipped
  262|       |            }
  263|       |            return;
  264|       |         }
  265|       |      }
  266|       |
  267|       |      if constexpr (skipped_by_meta<T, I, operation::parse>) {
  268|       |         skip_value<JSON>::op<Opts>(ctx, it, end);
  269|       |         if (bool(ctx.error)) [[unlikely]]
  270|       |            return; // Propagate error from skip_value
  271|       |      }
  272|    122|      else {
  273|    122|         using V = refl_t<T, I>;
  274|       |
  275|       |         if constexpr (const_value_v<V>) {
  276|       |            if constexpr (check_error_on_const_read(Opts)) {
  277|       |               ctx.error = error_code::attempt_const_read;
  278|       |            }
  279|       |            else {
  280|       |               // do not read anything into the const value
  281|       |               skip_value<JSON>::op<Opts>(ctx, it, end);
  282|       |            }
  283|       |         }
  284|       |         else if constexpr (is_function_ptr_or_ref<V>) {
  285|       |            // Function pointers cannot be deserialized from JSON.
  286|       |            // When write_function_pointers is enabled the writer emits a type-name string,
  287|       |            // but there is nothing meaningful to reconstruct on read — just skip the value.
  288|       |            // When write_function_pointers is off the key is never written, so this branch
  289|       |            // is unreachable in that case.
  290|       |            skip_value<JSON>::op<Opts>(ctx, it, end);
  291|       |         }
  292|       |         else if constexpr (glaze_object_t<T>) {
  293|       |            from<JSON, std::remove_cvref_t<V>>::template op<FieldOpts>(get_member(value, get<I>(reflect<T>::values)),
  294|       |                                                                       ctx, it, end);
  295|       |         }
  296|    122|         else {
  297|    122|            from<JSON, std::remove_cvref_t<V>>::template op<FieldOpts>(get_member(value, get<I>(to_tie(value))), ctx,
  298|    122|                                                                       it, end);
  299|    122|         }
  300|    122|      }
  301|       |
  302|       |      // The key was present and handled, even when the value itself was skipped
  303|       |      if constexpr (Opts.error_on_missing_keys || Opts.partial_read) {
  304|       |         ((selected_index = I), ...);
  305|       |      }
  306|    122|   }
_ZN3glz4fromILj10ENSt3__18functionIFvvEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEES4_TkNS_10is_contextERNS_7contextERPKcSB_EEvRT0_OT1_OT2_T3_:
 2179|    122|      {
 2180|       |         if constexpr (!check_ws_handled(Opts)) {
 2181|       |            if (skip_ws<Opts>(ctx, it, end)) {
 2182|       |               return;
 2183|       |            }
 2184|       |         }
 2185|    122|         if (match_invalid_end<'"', Opts>(ctx, it, end)) {
  ------------------
  |  Branch (2185:14): [True: 24, False: 98]
  ------------------
 2186|     24|            return;
 2187|     24|         }
 2188|     98|         skip_string_view(ctx, it, end);
 2189|     98|         if (bool(ctx.error)) [[unlikely]]
  ------------------
  |  Branch (2189:14): [True: 0, False: 98]
  ------------------
 2190|      0|            return;
 2191|     98|         if (match<'"'>(ctx, it)) {
  ------------------
  |  Branch (2191:14): [True: 0, False: 98]
  ------------------
 2192|      0|            return;
 2193|      0|         }
 2194|     98|         if constexpr (not Opts.null_terminated) {
 2195|     98|            if (it == end) {
  ------------------
  |  Branch (2195:17): [True: 0, False: 98]
  ------------------
 2196|      0|               ctx.error = error_code::end_reached;
 2197|      0|               return;
 2198|      0|            }
 2199|     98|         }
 2200|     98|      }
_ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERN12jsonrpc_fuzz6nestedETkNS_10is_contextERNS_7contextERPKcSA_EEvOT0_OT1_OT2_T3_:
   49|  1.56k|      {
   50|       |         if constexpr (const_value_v<T>) {
   51|       |            if constexpr (check_error_on_const_read(Opts)) {
   52|       |               ctx.error = error_code::attempt_const_read;
   53|       |            }
   54|       |            else {
   55|       |               // do not read anything into the const value
   56|       |               skip_value<JSON>::op<Opts>(std::forward<Ctx>(ctx), std::forward<It0>(it), end);
   57|       |            }
   58|       |         }
   59|  1.56k|         else {
   60|  1.56k|            using V = std::remove_cvref_t<T>;
   61|  1.56k|            from<JSON, V>::template op<Opts>(std::forward<T>(value), std::forward<Ctx>(ctx), std::forward<It0>(it),
   62|  1.56k|                                             end);
   63|  1.56k|         }
   64|  1.56k|      }
_ZN3glz4fromILj10EN12jsonrpc_fuzz6nestedEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnNS_14string_literalEXtlNS6_ILm1EEEEERS2_TkNS_10is_contextERNS_7contextERPKcSC_EEvOT1_OT2_OT3_T4_:
 3044|  1.56k|      {
 3045|  1.56k|         static constexpr auto num_members = reflect<T>::size;
 3046|       |
 3047|  1.56k|         static constexpr auto Opts = opening_handled_off<ws_handled_off<Options>()>();
 3048|  1.56k|         if constexpr (!check_opening_handled(Options)) {
 3049|  1.56k|            if constexpr (!check_ws_handled(Options)) {
 3050|  1.56k|               if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (3050:20): [True: 0, False: 1.56k]
  ------------------
 3051|      0|                  return;
 3052|      0|               }
 3053|  1.56k|            }
 3054|  1.56k|            if (match_invalid_end<'{', Opts>(ctx, it, end)) {
  ------------------
  |  Branch (3054:17): [True: 92, False: 1.46k]
  ------------------
 3055|     92|               return;
 3056|     92|            }
 3057|  1.46k|            if constexpr (not Opts.null_terminated) {
 3058|  1.46k|               if (it == end) [[unlikely]] {
  ------------------
  |  Branch (3058:20): [True: 0, False: 1.46k]
  ------------------
 3059|      0|                  ctx.error = error_code::unexpected_end;
 3060|      0|                  return;
 3061|      0|               }
 3062|  1.46k|            }
 3063|       |            // one nesting level (see enter_depth): counted in both modes so the limit binds,
 3064|       |            // released at each syntactic close below
 3065|  1.46k|            if (enter_depth(ctx)) [[unlikely]] {
  ------------------
  |  Branch (3065:17): [True: 0, False: 1.46k]
  ------------------
 3066|      0|               return;
 3067|      0|            }
 3068|  1.46k|         }
 3069|  1.46k|         const auto ws_start = it;
 3070|  1.56k|         if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (3070:14): [True: 0, False: 1.56k]
  ------------------
 3071|      0|            return;
 3072|      0|         }
 3073|  1.56k|         const size_t ws_size = size_t(it - ws_start);
 3074|       |
 3075|       |         if constexpr ((glaze_object_t<T> || reflectable<T>) && num_members == 0 && Opts.error_on_unknown_keys) {
 3076|       |            if constexpr (not tag.sv().empty()) {
 3077|       |               if (*it == '"') {
 3078|       |                  ++it;
 3079|       |                  if constexpr (not Opts.null_terminated) {
 3080|       |                     if (it == end) [[unlikely]] {
 3081|       |                        ctx.error = error_code::unexpected_end;
 3082|       |                        return;
 3083|       |                     }
 3084|       |                  }
 3085|       |
 3086|       |                  const auto start = it;
 3087|       |                  skip_string_view(ctx, it, end);
 3088|       |                  if (bool(ctx.error)) [[unlikely]]
 3089|       |                     return;
 3090|       |                  if (validate_utf8_span<Opts>(ctx, start, it)) [[unlikely]]
 3091|       |                     return;
 3092|       |                  const sv key{start, size_t(it - start)};
 3093|       |                  ++it;
 3094|       |                  if constexpr (not Opts.null_terminated) {
 3095|       |                     if (it == end) [[unlikely]] {
 3096|       |                        ctx.error = error_code::unexpected_end;
 3097|       |                        return;
 3098|       |                     }
 3099|       |                  }
 3100|       |
 3101|       |                  if (key == tag.sv()) {
 3102|       |                     if (parse_ws_colon<Opts>(ctx, it, end)) {
 3103|       |                        return;
 3104|       |                     }
 3105|       |
 3106|       |                     parse<JSON>::handle_unknown<Opts>(key, value, ctx, it, end);
 3107|       |                     if (bool(ctx.error)) [[unlikely]]
 3108|       |                        return;
 3109|       |
 3110|       |                     if (skip_ws<Opts>(ctx, it, end)) {
 3111|       |                        return;
 3112|       |                     }
 3113|       |                  }
 3114|       |                  else {
 3115|       |                     ctx.error = error_code::unknown_key;
 3116|       |                     return;
 3117|       |                  }
 3118|       |               }
 3119|       |            }
 3120|       |
 3121|       |            if (*it == '}') [[likely]] {
 3122|       |               --ctx.depth;
 3123|       |               if constexpr (glaze_object_t<T> || reflectable<T>) {
 3124|       |                  if constexpr (has_self_constraint_v<T> && !check_skip_self_constraint(Opts)) {
 3125|       |                     auto wrapper = self_constraint_v<T>(value);
 3126|       |                     from<JSON, decltype(wrapper)>::template op<ws_handled<Opts>()>(wrapper, ctx, it, end);
 3127|       |                     if (bool(ctx.error)) {
 3128|       |                        return;
 3129|       |                     }
 3130|       |                  }
 3131|       |               }
 3132|       |               ++it;
 3133|       |               if constexpr (not Opts.null_terminated) {
 3134|       |                  if (it == end) {
 3135|       |                     ctx.error = error_code::end_reached;
 3136|       |                     return;
 3137|       |                  }
 3138|       |               }
 3139|       |               if constexpr (Opts.partial_read) {
 3140|       |                  ctx.error = error_code::partial_read_complete;
 3141|       |               }
 3142|       |               return;
 3143|       |            }
 3144|       |            ctx.error = error_code::unknown_key;
 3145|       |            return;
 3146|       |         }
 3147|  1.56k|         else {
 3148|  1.56k|            decltype(auto) fields = [&]() -> decltype(auto) {
 3149|  1.56k|               if constexpr ((glaze_object_t<T> || reflectable<T>) &&
 3150|  1.56k|                             (Opts.error_on_missing_keys || Opts.partial_read)) {
 3151|  1.56k|                  return bit_array<num_members>{};
 3152|  1.56k|               }
 3153|  1.56k|               else {
 3154|  1.56k|                  return nullptr;
 3155|  1.56k|               }
 3156|  1.56k|            }();
 3157|       |
 3158|  1.56k|            size_t read_count{}; // for partial_read
 3159|       |
 3160|  1.56k|            bool first = true;
 3161|  12.1k|            while (true) {
  ------------------
  |  Branch (3161:20): [True: 10.8k, Folded]
  ------------------
 3162|       |               if constexpr ((glaze_object_t<T> || reflectable<T>) && Opts.partial_read) {
 3163|       |                  static constexpr bit_array<num_members> all_fields = [] {
 3164|       |                     bit_array<num_members> arr{};
 3165|       |                     for (size_t i = 0; i < num_members; ++i) {
 3166|       |                        arr[i] = true;
 3167|       |                     }
 3168|       |                     return arr;
 3169|       |                  }();
 3170|       |
 3171|       |                  if ((all_fields & fields) == all_fields) {
 3172|       |                     ctx.error = error_code::partial_read_complete;
 3173|       |                     --ctx.depth; // as above: an early success still closes this level
 3174|       |                     return;
 3175|       |                  }
 3176|       |               }
 3177|       |
 3178|       |               // Streaming refill point: at start of each iteration, ensure buffer has data
 3179|       |               if constexpr (has_streaming_state<decltype(ctx)>) {
 3180|       |                  if (ctx.stream.enabled()) {
 3181|       |                     const size_t consumed = static_cast<size_t>(it - ctx.stream.data());
 3182|       |                     const size_t remaining = ctx.stream.size() - consumed;
 3183|       |                     // Refill when less than half of buffer remains to ensure space for next key-value pair
 3184|       |                     if (remaining <= ctx.stream.size() / 2 || it >= end) {
 3185|       |                        const char* new_it;
 3186|       |                        const char* new_end;
 3187|       |                        ctx.stream.consume_and_refill(consumed, new_it, new_end);
 3188|       |                        it = new_it;
 3189|       |                        end = new_end;
 3190|       |                        if (it >= end && ctx.stream.at_eof()) {
 3191|       |                           ctx.error = error_code::unexpected_end;
 3192|       |                           return;
 3193|       |                        }
 3194|       |                     }
 3195|       |                  }
 3196|       |               }
 3197|       |
 3198|  10.8k|               if (*it == '}') {
  ------------------
  |  Branch (3198:20): [True: 200, False: 10.6k]
  ------------------
 3199|    200|                  --ctx.depth;
 3200|       |                  if constexpr ((glaze_object_t<T> || reflectable<T>) && Opts.error_on_missing_keys) {
 3201|       |                     constexpr auto req_fields = required_fields<T, Opts>();
 3202|       |                     if ((req_fields & fields) != req_fields) {
 3203|       |                        for (size_t i = 0; i < num_members; ++i) {
 3204|       |                           if (not fields[i] && req_fields[i]) {
 3205|       |                              ctx.custom_error_message = reflect<T>::keys[i];
 3206|       |                              // We just return the first missing key in order to avoid heap allocations
 3207|       |                              break;
 3208|       |                           }
 3209|       |                        }
 3210|       |
 3211|       |                        ctx.error = error_code::missing_key;
 3212|       |                        return;
 3213|       |                     }
 3214|       |                  }
 3215|    200|                  if constexpr (glaze_object_t<T> || reflectable<T>) {
 3216|       |                     if constexpr (has_self_constraint_v<T> && !check_skip_self_constraint(Opts)) {
 3217|       |                        auto wrapper = self_constraint_v<T>(value);
 3218|       |                        from<JSON, decltype(wrapper)>::template op<ws_handled<Opts>()>(wrapper, ctx, it, end);
 3219|       |                        if (bool(ctx.error)) {
 3220|       |                           return;
 3221|       |                        }
 3222|       |                     }
 3223|    200|                  }
 3224|    200|                  ++it; // Increment after checking for missing keys so errors are within buffer bounds
 3225|    200|                  if constexpr (not Opts.null_terminated) {
 3226|    200|                     if (it == end) {
  ------------------
  |  Branch (3226:26): [True: 200, False: 0]
  ------------------
 3227|    200|                        ctx.error = error_code::end_reached;
 3228|    200|                        return;
 3229|    200|                     }
 3230|    200|                  }
 3231|      0|                  return;
 3232|    200|               }
 3233|  10.6k|               else if (first) {
  ------------------
  |  Branch (3233:25): [True: 1.43k, False: 9.26k]
  ------------------
 3234|  1.43k|                  first = false;
 3235|  1.43k|               }
 3236|  9.26k|               else {
 3237|  9.26k|                  if (match_invalid_end<',', Opts>(ctx, it, end)) {
  ------------------
  |  Branch (3237:23): [True: 133, False: 9.12k]
  ------------------
 3238|    133|                     return;
 3239|    133|                  }
 3240|  9.12k|                  if constexpr (not Opts.null_terminated) {
 3241|  9.12k|                     if (it == end) [[unlikely]] {
  ------------------
  |  Branch (3241:26): [True: 0, False: 9.12k]
  ------------------
 3242|      0|                        ctx.error = error_code::unexpected_end;
 3243|      0|                        return;
 3244|      0|                     }
 3245|  9.12k|                  }
 3246|       |
 3247|       |                  if constexpr ((not Opts.minified) && (num_members > 1 || not Opts.error_on_unknown_keys) &&
 3248|  9.12k|                                (!Opts.comments)) {
 3249|  9.12k|                     if (ws_size && ws_size < size_t(end - it)) {
  ------------------
  |  Branch (3249:26): [True: 8.19k, False: 934]
  |  Branch (3249:37): [True: 7.95k, False: 235]
  ------------------
 3250|  7.95k|                        skip_matching_ws(ws_start, it, ws_size);
 3251|  7.95k|                     }
 3252|  9.12k|                  }
 3253|       |
 3254|  9.12k|                  if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (3254:23): [True: 0, False: 9.12k]
  ------------------
 3255|      0|                     return;
 3256|      0|                  }
 3257|  9.12k|               }
 3258|       |
 3259|  10.5k|               constexpr auto reflection_type = glaze_object_t<T> || reflectable<T>;
  ------------------
  |  Branch (3259:49): [Folded, False: 0]
  |  Branch (3259:70): [True: 0, Folded]
  ------------------
 3260|       |
 3261|       |               if constexpr (reflection_type && (num_members == 0)) {
 3262|       |                  if constexpr (Opts.error_on_unknown_keys) {
 3263|       |                     static_assert(false_v<T>, "This should be unreachable");
 3264|       |                  }
 3265|       |                  else {
 3266|       |                     if (match_invalid_end<'"', Opts>(ctx, it, end)) {
 3267|       |                        return;
 3268|       |                     }
 3269|       |
 3270|       |                     // parsing to an empty object, but at this point the JSON presents keys
 3271|       |
 3272|       |                     // Unknown key handler does not unescape keys. Unknown escaped keys are
 3273|       |                     // handled by the user.
 3274|       |
 3275|       |                     const auto start = it;
 3276|       |                     skip_string_view(ctx, it, end);
 3277|       |                     if (bool(ctx.error)) [[unlikely]]
 3278|       |                        return;
 3279|       |                     if (validate_utf8_span<Opts>(ctx, start, it)) [[unlikely]]
 3280|       |                        return;
 3281|       |                     const sv key{start, size_t(it - start)};
 3282|       |                     ++it;
 3283|       |                     if constexpr (not Opts.null_terminated) {
 3284|       |                        if (it == end) [[unlikely]] {
 3285|       |                           ctx.error = error_code::unexpected_end;
 3286|       |                           return;
 3287|       |                        }
 3288|       |                     }
 3289|       |
 3290|       |                     if (parse_ws_colon<Opts>(ctx, it, end)) {
 3291|       |                        return;
 3292|       |                     }
 3293|       |
 3294|       |                     // Check if this key is the variant tag that should be skipped
 3295|       |                     if constexpr (not tag.sv().empty()) {
 3296|       |                        if (key == tag.sv()) {
 3297|       |                           // Skip the tag value
 3298|       |                           skip_value<JSON>::op<Opts>(ctx, it, end);
 3299|       |                           if (bool(ctx.error)) [[unlikely]]
 3300|       |                              return;
 3301|       |                           resync_window_end(ctx, end); // a streaming skip refills
 3302|       |                           if (skip_ws<Opts>(ctx, it, end)) {
 3303|       |                              return;
 3304|       |                           }
 3305|       |                           continue;
 3306|       |                        }
 3307|       |                     }
 3308|       |
 3309|       |                     parse<JSON>::handle_unknown<Opts>(key, value, ctx, it, end);
 3310|       |                     if (bool(ctx.error)) [[unlikely]]
 3311|       |                        return;
 3312|       |                     if constexpr (not Opts.null_terminated) {
 3313|       |                        if (it == end) [[unlikely]] {
 3314|       |                           ctx.error = error_code::unexpected_end;
 3315|       |                           return;
 3316|       |                        }
 3317|       |                     }
 3318|       |                     if (skip_ws<Opts>(ctx, it, end)) {
 3319|       |                        return;
 3320|       |                     }
 3321|       |                  }
 3322|       |               }
 3323|  10.5k|               else if constexpr (reflection_type) {
 3324|  10.5k|                  static_assert(bool(hash_info<T>.type));
 3325|       |
 3326|  10.5k|                  if (*it != '"') [[unlikely]] {
  ------------------
  |  Branch (3326:23): [True: 783, False: 9.77k]
  ------------------
 3327|    783|                     ctx.error = error_code::expected_quote;
 3328|    783|                     return;
 3329|    783|                  }
 3330|  9.77k|                  ++it;
 3331|  9.77k|                  if constexpr (not Opts.null_terminated) {
 3332|  9.77k|                     if (it == end) [[unlikely]] {
  ------------------
  |  Branch (3332:26): [True: 0, False: 9.77k]
  ------------------
 3333|      0|                        ctx.error = error_code::unexpected_end;
 3334|      0|                        return;
 3335|      0|                     }
 3336|  9.77k|                  }
 3337|       |
 3338|       |                  if constexpr (not tag.sv().empty() && not contains_tag<T, tag>()) {
 3339|       |                     // For tagged variants we first check to see if the key matches the tag
 3340|       |                     // We only need to do this if the tag is not part of the keys
 3341|       |
 3342|       |                     const auto start = it;
 3343|       |                     skip_string_view(ctx, it, end);
 3344|       |                     if (bool(ctx.error)) [[unlikely]]
 3345|       |                        return;
 3346|       |                     if (validate_utf8_span<Opts>(ctx, start, it)) [[unlikely]]
 3347|       |                        return;
 3348|       |                     const sv key{start, size_t(it - start)};
 3349|       |                     ++it;
 3350|       |                     if constexpr (not Opts.null_terminated) {
 3351|       |                        if (it == end) [[unlikely]] {
 3352|       |                           ctx.error = error_code::unexpected_end;
 3353|       |                           return;
 3354|       |                        }
 3355|       |                     }
 3356|       |
 3357|       |                     if (key == tag.sv()) {
 3358|       |                        if (parse_ws_colon<Opts>(ctx, it, end)) {
 3359|       |                           return;
 3360|       |                        }
 3361|       |
 3362|       |                        parse<JSON>::handle_unknown<Opts>(key, value, ctx, it, end);
 3363|       |                        if (bool(ctx.error)) [[unlikely]]
 3364|       |                           return;
 3365|       |
 3366|       |                        if (skip_ws<Opts>(ctx, it, end)) {
 3367|       |                           return;
 3368|       |                        }
 3369|       |                        continue;
 3370|       |                     }
 3371|       |                     else {
 3372|       |                        it = start; // reset the iterator
 3373|       |                     }
 3374|       |                  }
 3375|       |
 3376|       |                  if constexpr (Opts.error_on_missing_keys || Opts.partial_read) {
 3377|       |                     size_t index = num_members;
 3378|       |                     parse_and_invoke<Opts, T>(value, ctx, it, end, index);
 3379|       |                     if (bool(ctx.error)) [[unlikely]]
 3380|       |                        return;
 3381|       |                     if (index < num_members) {
 3382|       |                        fields[index] = true;
 3383|       |                     }
 3384|       |                  }
 3385|  9.77k|                  else {
 3386|  9.77k|                     parse_and_invoke<Opts, T>(value, ctx, it, end);
 3387|  9.77k|                     if (bool(ctx.error)) [[unlikely]]
  ------------------
  |  Branch (3387:26): [True: 352, False: 9.42k]
  ------------------
 3388|    352|                        return;
 3389|  9.77k|                  }
 3390|       |               }
 3391|       |               else {
 3392|       |                  // For types like std::map, std::unordered_map
 3393|       |
 3394|       |                  auto reading = [&](auto&& key) {
 3395|       |                     if constexpr (Opts.partial_read) {
 3396|       |                        if (auto element = value.find(key); element != value.end()) {
 3397|       |                           ++read_count;
 3398|       |                           parse<JSON>::op<ws_handled<Opts>()>(element->second, ctx, it, end);
 3399|       |                        }
 3400|       |                        else {
 3401|       |                           skip_value<JSON>::op<Opts>(ctx, it, end);
 3402|       |                        }
 3403|       |                     }
 3404|       |                     else {
 3405|       |                        parse<JSON>::op<ws_handled<Opts>()>(value[key], ctx, it, end);
 3406|       |                     }
 3407|       |                  };
 3408|       |
 3409|       |                  // using Key = std::conditional_t<heterogeneous_map<T>, sv, typename T::key_type>;
 3410|       |                  using Key = typename T::key_type;
 3411|       |                  if constexpr (std::is_same_v<Key, std::string>) {
 3412|       |                     ctx.scratch.clear();
 3413|       |                     parse<JSON>::op<Opts>(ctx.scratch, ctx, it, end);
 3414|       |                     if (bool(ctx.error)) [[unlikely]]
 3415|       |                        return;
 3416|       |
 3417|       |                     if (parse_ws_colon<Opts>(ctx, it, end)) {
 3418|       |                        return;
 3419|       |                     }
 3420|       |
 3421|       |                     reading(ctx.scratch);
 3422|       |                     if constexpr (Opts.partial_read) {
 3423|       |                        if (read_count == value.size()) {
 3424|       |                           return;
 3425|       |                        }
 3426|       |                     }
 3427|       |                     if (bool(ctx.error)) [[unlikely]]
 3428|       |                        return;
 3429|       |                  }
 3430|       |                  else if constexpr (str_t<Key>) {
 3431|       |                     Key key;
 3432|       |                     parse<JSON>::op<Opts>(key, ctx, it, end);
 3433|       |                     if (bool(ctx.error)) [[unlikely]]
 3434|       |                        return;
 3435|       |
 3436|       |                     if (parse_ws_colon<Opts>(ctx, it, end)) {
 3437|       |                        return;
 3438|       |                     }
 3439|       |
 3440|       |                     reading(key);
 3441|       |                     if constexpr (Opts.partial_read) {
 3442|       |                        if (read_count == value.size()) {
 3443|       |                           return;
 3444|       |                        }
 3445|       |                     }
 3446|       |                     if (bool(ctx.error)) [[unlikely]]
 3447|       |                        return;
 3448|       |                  }
 3449|       |                  else {
 3450|       |                     Key key_value{};
 3451|       |                     if constexpr (is_named_enum<Key> || mimics_str_t<Key>) {
 3452|       |                        parse<JSON>::op<Opts>(key_value, ctx, it, end);
 3453|       |                     }
 3454|       |                     else if constexpr (std::is_arithmetic_v<Key>) {
 3455|       |                        // prefer over quoted_t below to avoid double parsing of quoted_t
 3456|       |                        parse<JSON>::op<opt_true<Opts, quoted_num_opt_tag{}>>(key_value, ctx, it, end);
 3457|       |                     }
 3458|       |                     else {
 3459|       |                        parse<JSON>::op<opt_false<Opts, raw_string_opt_tag{}>>(quoted_t<Key>{key_value}, ctx, it, end);
 3460|       |                     }
 3461|       |                     if (bool(ctx.error)) [[unlikely]]
 3462|       |                        return;
 3463|       |
 3464|       |                     if (parse_ws_colon<Opts>(ctx, it, end)) {
 3465|       |                        return;
 3466|       |                     }
 3467|       |
 3468|       |                     reading(key_value);
 3469|       |                     if constexpr (Opts.partial_read) {
 3470|       |                        if (read_count == value.size()) {
 3471|       |                           return;
 3472|       |                        }
 3473|       |                     }
 3474|       |                     if (bool(ctx.error)) [[unlikely]]
 3475|       |                        return;
 3476|       |                  }
 3477|       |               }
 3478|       |
 3479|       |               // Streaming refill point: after parsing each key-value pair, refill if buffer is low
 3480|       |               if constexpr (has_streaming_state<decltype(ctx)>) {
 3481|       |                  if (ctx.stream.enabled()) {
 3482|       |                     const size_t consumed = static_cast<size_t>(it - ctx.stream.data());
 3483|       |                     // Refill when less than 25% of buffer remains to ensure enough space for next element
 3484|       |                     if (ctx.stream.size() - consumed <= ctx.stream.size() / 4 || it >= end) {
 3485|       |                        const char* new_it;
 3486|       |                        const char* new_end;
 3487|       |                        ctx.stream.consume_and_refill(consumed, new_it, new_end);
 3488|       |                        it = new_it;
 3489|       |                        end = new_end;
 3490|       |                        if (it >= end && ctx.stream.at_eof()) {
 3491|       |                           ctx.error = error_code::unexpected_end;
 3492|       |                           return;
 3493|       |                        }
 3494|       |                     }
 3495|       |                  }
 3496|       |               }
 3497|       |
 3498|  10.5k|               if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (3498:20): [True: 0, False: 10.5k]
  ------------------
 3499|      0|                  return;
 3500|      0|               }
 3501|  10.5k|            }
 3502|  1.56k|         }
 3503|  1.56k|      }
_ZZN3glz4fromILj10EN12jsonrpc_fuzz6nestedEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnNS_14string_literalEXtlNS6_ILm1EEEEERS2_TkNS_10is_contextERNS_7contextERPKcSC_EEvOT1_OT2_OT3_T4_ENKUlvE_clEv:
 3148|  1.46k|            decltype(auto) fields = [&]() -> decltype(auto) {
 3149|       |               if constexpr ((glaze_object_t<T> || reflectable<T>) &&
 3150|       |                             (Opts.error_on_missing_keys || Opts.partial_read)) {
 3151|       |                  return bit_array<num_members>{};
 3152|       |               }
 3153|  1.46k|               else {
 3154|  1.46k|                  return nullptr;
 3155|  1.46k|               }
 3156|  1.46k|            }();
_ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__16vectorIiNS4_9allocatorIiEEEETkNS_10is_contextERNS_7contextERPKcSD_EEvOT0_OT1_OT2_T3_:
   49|  1.99k|      {
   50|       |         if constexpr (const_value_v<T>) {
   51|       |            if constexpr (check_error_on_const_read(Opts)) {
   52|       |               ctx.error = error_code::attempt_const_read;
   53|       |            }
   54|       |            else {
   55|       |               // do not read anything into the const value
   56|       |               skip_value<JSON>::op<Opts>(std::forward<Ctx>(ctx), std::forward<It0>(it), end);
   57|       |            }
   58|       |         }
   59|  1.99k|         else {
   60|  1.99k|            using V = std::remove_cvref_t<T>;
   61|  1.99k|            from<JSON, V>::template op<Opts>(std::forward<T>(value), std::forward<Ctx>(ctx), std::forward<It0>(it),
   62|  1.99k|                                             end);
   63|  1.99k|         }
   64|  1.99k|      }
_ZN3glz4fromILj10ENSt3__16vectorIiNS1_9allocatorIiEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS5_TkNS_10is_contextERNS_7contextERPKcSD_EEvOT0_OT1_OT2_T3_:
 2308|  1.99k|      {
 2309|  1.99k|         constexpr auto Opts = ws_handled_off<Options>();
 2310|  1.99k|         if constexpr (!check_ws_handled(Options)) {
 2311|  1.99k|            if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (2311:17): [True: 0, False: 1.99k]
  ------------------
 2312|      0|               return;
 2313|      0|            }
 2314|  1.99k|         }
 2315|       |
 2316|  1.99k|         if (match_invalid_end<'[', Opts>(ctx, it, end)) {
  ------------------
  |  Branch (2316:14): [True: 52, False: 1.94k]
  ------------------
 2317|     52|            return;
 2318|     52|         }
 2319|       |         // one nesting level (see enter_depth): counted in both modes so the limit binds,
 2320|       |         // released at each syntactic close below
 2321|  1.94k|         if (enter_depth(ctx)) [[unlikely]] {
  ------------------
  |  Branch (2321:14): [True: 0, False: 1.94k]
  ------------------
 2322|      0|            return;
 2323|      0|         }
 2324|       |
 2325|  1.94k|         const auto ws_start = it;
 2326|  1.94k|         if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (2326:14): [True: 0, False: 1.94k]
  ------------------
 2327|      0|            return;
 2328|      0|         }
 2329|       |
 2330|  1.94k|         if (*it == ']') {
  ------------------
  |  Branch (2330:14): [True: 20, False: 1.92k]
  ------------------
 2331|     20|            --ctx.depth;
 2332|     20|            ++it;
 2333|     20|            if constexpr ((resizable<T> || is_inplace_vector<T>) && not check_append_arrays(Opts)) {
 2334|     20|               value.clear();
 2335|       |
 2336|       |               if constexpr (check_shrink_to_fit(Opts) && has_shrink_to_fit<T>) {
 2337|       |                  value.shrink_to_fit();
 2338|       |               }
 2339|     20|            }
 2340|     20|            return;
 2341|     20|         }
 2342|       |
 2343|  1.92k|         const size_t ws_size = size_t(it - ws_start);
 2344|       |
 2345|  1.92k|         static constexpr bool should_append = (resizable<T> || is_inplace_vector<T>) && check_append_arrays(Opts);
  ------------------
  |  Branch (2345:49): [True: 1.92k, Folded]
  |  Branch (2345:65): [Folded, False: 0]
  |  Branch (2345:90): [Folded, False: 0]
  ------------------
 2346|  1.92k|         if constexpr (not should_append) {
 2347|  1.92k|            const auto n = value.size();
 2348|       |
 2349|  1.92k|            auto value_it = value.begin();
 2350|       |
 2351|  1.92k|            for (size_t i = 0; i < n; ++i) {
  ------------------
  |  Branch (2351:32): [True: 0, False: 1.92k]
  ------------------
 2352|      0|               parse<JSON>::op<ws_handled<Opts>()>(*value_it++, ctx, it, end);
 2353|      0|               if (bool(ctx.error)) [[unlikely]]
  ------------------
  |  Branch (2353:20): [True: 0, False: 0]
  ------------------
 2354|      0|                  return;
 2355|      0|               if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (2355:20): [True: 0, False: 0]
  ------------------
 2356|      0|                  return;
 2357|      0|               }
 2358|      0|               if (*it == ',') {
  ------------------
  |  Branch (2358:20): [True: 0, False: 0]
  ------------------
 2359|      0|                  ++it;
 2360|       |
 2361|      0|                  if constexpr (!Opts.minified && !Opts.comments) {
 2362|      0|                     if (ws_size && ws_size < size_t(end - it)) {
  ------------------
  |  Branch (2362:26): [True: 0, False: 0]
  |  Branch (2362:37): [True: 0, False: 0]
  ------------------
 2363|      0|                        skip_matching_ws(ws_start, it, ws_size);
 2364|      0|                     }
 2365|      0|                  }
 2366|       |
 2367|      0|                  if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (2367:23): [True: 0, False: 0]
  ------------------
 2368|      0|                     return;
 2369|      0|                  }
 2370|      0|               }
 2371|      0|               else if (*it == ']') {
  ------------------
  |  Branch (2371:25): [True: 0, False: 0]
  ------------------
 2372|      0|                  --ctx.depth;
 2373|      0|                  ++it;
 2374|      0|                  if constexpr (erasable<T>) {
 2375|      0|                     value.erase(value_it,
 2376|      0|                                 value.end()); // use erase rather than resize for non-default constructible elements
 2377|       |
 2378|       |                     if constexpr (check_shrink_to_fit(Opts) && has_shrink_to_fit<T>) {
 2379|       |                        value.shrink_to_fit();
 2380|       |                     }
 2381|      0|                  }
 2382|      0|                  return;
 2383|      0|               }
 2384|      0|               else [[unlikely]] {
 2385|      0|                  ctx.error = error_code::expected_bracket;
 2386|      0|                  return;
 2387|      0|               }
 2388|      0|            }
 2389|  1.92k|         }
 2390|       |
 2391|       |         if constexpr (Opts.partial_read) {
 2392|       |            // partial_read stops early on a success path, so give the level back like the
 2393|       |            // syntactic-close paths do; otherwise it accumulates across reads sharing a context.
 2394|       |            --ctx.depth;
 2395|       |            return;
 2396|       |         }
 2397|  1.92k|         else {
 2398|       |            // growing
 2399|  1.92k|            if constexpr (emplace_backable<T> || has_try_emplace_back<T>) {
 2400|   572k|               while (it < end) {
  ------------------
  |  Branch (2400:23): [True: 572k, False: 0]
  ------------------
 2401|       |                  // Streaming refill point: at start of each iteration, ensure buffer has data
 2402|       |                  if constexpr (has_streaming_state<decltype(ctx)>) {
 2403|       |                     if (ctx.stream.enabled()) {
 2404|       |                        const size_t consumed = static_cast<size_t>(it - ctx.stream.data());
 2405|       |                        const size_t remaining = ctx.stream.size() - consumed;
 2406|       |                        // Refill when less than half of buffer remains to ensure space for next element
 2407|       |                        if (remaining <= ctx.stream.size() / 2 || it >= end) {
 2408|       |                           const char* new_it;
 2409|       |                           const char* new_end;
 2410|       |                           ctx.stream.consume_and_refill(consumed, new_it, new_end);
 2411|       |                           it = new_it;
 2412|       |                           end = new_end;
 2413|       |                           if (it >= end && ctx.stream.at_eof()) {
 2414|       |                              break; // No more data, exit loop normally
 2415|       |                           }
 2416|       |                        }
 2417|       |                     }
 2418|       |                  }
 2419|       |
 2420|       |                  if constexpr (has_try_emplace_back<T>) {
 2421|       |                     if (value.try_emplace_back())
 2422|       |                        parse<JSON>::op<ws_handled<Opts>()>(value.back(), ctx, it, end);
 2423|       |                     else
 2424|       |                        ctx.error = error_code::exceeded_static_array_size;
 2425|       |                  }
 2426|   572k|                  else {
 2427|   572k|                     parse<JSON>::op<ws_handled<Opts>()>(value.emplace_back(), ctx, it, end);
 2428|   572k|                  }
 2429|       |
 2430|   572k|                  if (bool(ctx.error)) [[unlikely]]
  ------------------
  |  Branch (2430:23): [True: 1.06k, False: 571k]
  ------------------
 2431|  1.06k|                     return;
 2432|       |
 2433|       |                  // Streaming refill point: after parsing each element, refill if buffer is low
 2434|       |                  if constexpr (has_streaming_state<decltype(ctx)>) {
 2435|       |                     if (ctx.stream.enabled()) {
 2436|       |                        const size_t consumed = static_cast<size_t>(it - ctx.stream.data());
 2437|       |                        // Refill when less than 25% of buffer remains to ensure enough space for next element
 2438|       |                        if (ctx.stream.size() - consumed <= ctx.stream.size() / 4 || it >= end) {
 2439|       |                           const char* new_it;
 2440|       |                           const char* new_end;
 2441|       |                           ctx.stream.consume_and_refill(consumed, new_it, new_end);
 2442|       |                           it = new_it;
 2443|       |                           end = new_end;
 2444|       |                           if (it >= end && ctx.stream.at_eof()) {
 2445|       |                              ctx.error = error_code::unexpected_end;
 2446|       |                              return;
 2447|       |                           }
 2448|       |                        }
 2449|       |                     }
 2450|       |                  }
 2451|       |
 2452|   571k|                  if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (2452:23): [True: 0, False: 571k]
  ------------------
 2453|      0|                     return;
 2454|      0|                  }
 2455|   571k|                  if (*it == ',') [[likely]] {
  ------------------
  |  Branch (2455:23): [True: 570k, False: 854]
  ------------------
 2456|   570k|                     ++it;
 2457|       |
 2458|   570k|                     if constexpr (!Opts.minified && !Opts.comments) {
 2459|   570k|                        if (ws_size && ws_size < size_t(end - it)) {
  ------------------
  |  Branch (2459:29): [True: 548k, False: 22.1k]
  |  Branch (2459:40): [True: 548k, False: 425]
  ------------------
 2460|   548k|                           skip_matching_ws(ws_start, it, ws_size);
 2461|   548k|                        }
 2462|   570k|                     }
 2463|       |
 2464|   570k|                     if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (2464:26): [True: 0, False: 570k]
  ------------------
 2465|      0|                        return;
 2466|      0|                     }
 2467|   570k|                  }
 2468|    854|                  else if (*it == ']') {
  ------------------
  |  Branch (2468:28): [True: 415, False: 439]
  ------------------
 2469|    415|                     --ctx.depth;
 2470|    415|                     ++it;
 2471|       |                     if constexpr (check_shrink_to_fit(Opts) && has_shrink_to_fit<T>) {
 2472|       |                        value.shrink_to_fit();
 2473|       |                     }
 2474|    415|                     return;
 2475|    415|                  }
 2476|    439|                  else [[unlikely]] {
 2477|    439|                     ctx.error = error_code::expected_bracket;
 2478|    439|                     return;
 2479|    439|                  }
 2480|   571k|               }
 2481|       |
 2482|       |               // A valid array always returns from inside the loop upon reaching ']'.
 2483|       |               // For a null-terminated buffer the loop can only exit here by falling
 2484|       |               // through when `it` reaches the terminator without a closing bracket,
 2485|       |               // which means the input was truncated (e.g. "[", "[1," or "[1,2,").
 2486|       |               // Non-null-terminated buffers surface this through skip_ws/depth
 2487|       |               // tracking (or the streaming refill break), so this guard is limited
 2488|       |               // to the null-terminated case.
 2489|       |               if constexpr (Opts.null_terminated) {
 2490|       |                  ctx.error = error_code::unexpected_end;
 2491|       |               }
 2492|       |            }
 2493|       |            else {
 2494|       |               ctx.error = error_code::exceeded_static_array_size;
 2495|       |            }
 2496|  1.92k|         }
 2497|  1.92k|      }
_ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__13mapINS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEiNS4_4lessISB_EENS9_INS4_4pairIKSB_iEEEEEETkNS_10is_contextERNS_7contextERPKcSN_EEvOT0_OT1_OT2_T3_:
   49|  1.84k|      {
   50|       |         if constexpr (const_value_v<T>) {
   51|       |            if constexpr (check_error_on_const_read(Opts)) {
   52|       |               ctx.error = error_code::attempt_const_read;
   53|       |            }
   54|       |            else {
   55|       |               // do not read anything into the const value
   56|       |               skip_value<JSON>::op<Opts>(std::forward<Ctx>(ctx), std::forward<It0>(it), end);
   57|       |            }
   58|       |         }
   59|  1.84k|         else {
   60|  1.84k|            using V = std::remove_cvref_t<T>;
   61|  1.84k|            from<JSON, V>::template op<Opts>(std::forward<T>(value), std::forward<Ctx>(ctx), std::forward<It0>(it),
   62|  1.84k|                                             end);
   63|  1.84k|         }
   64|  1.84k|      }
_ZN3glz4fromILj10ENSt3__13mapINS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEiNS1_4lessIS8_EENS6_INS1_4pairIKS8_iEEEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnNS_14string_literalEXtlNSJ_ILm1EEEEERSF_TkNS_10is_contextERNS_7contextERPKcSP_EEvOT1_OT2_OT3_T4_:
 3044|  1.84k|      {
 3045|  1.84k|         static constexpr auto num_members = reflect<T>::size;
 3046|       |
 3047|  1.84k|         static constexpr auto Opts = opening_handled_off<ws_handled_off<Options>()>();
 3048|  1.84k|         if constexpr (!check_opening_handled(Options)) {
 3049|  1.84k|            if constexpr (!check_ws_handled(Options)) {
 3050|  1.84k|               if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (3050:20): [True: 0, False: 1.84k]
  ------------------
 3051|      0|                  return;
 3052|      0|               }
 3053|  1.84k|            }
 3054|  1.84k|            if (match_invalid_end<'{', Opts>(ctx, it, end)) {
  ------------------
  |  Branch (3054:17): [True: 36, False: 1.81k]
  ------------------
 3055|     36|               return;
 3056|     36|            }
 3057|  1.81k|            if constexpr (not Opts.null_terminated) {
 3058|  1.81k|               if (it == end) [[unlikely]] {
  ------------------
  |  Branch (3058:20): [True: 0, False: 1.81k]
  ------------------
 3059|      0|                  ctx.error = error_code::unexpected_end;
 3060|      0|                  return;
 3061|      0|               }
 3062|  1.81k|            }
 3063|       |            // one nesting level (see enter_depth): counted in both modes so the limit binds,
 3064|       |            // released at each syntactic close below
 3065|  1.81k|            if (enter_depth(ctx)) [[unlikely]] {
  ------------------
  |  Branch (3065:17): [True: 0, False: 1.81k]
  ------------------
 3066|      0|               return;
 3067|      0|            }
 3068|  1.81k|         }
 3069|  1.81k|         const auto ws_start = it;
 3070|  1.84k|         if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (3070:14): [True: 0, False: 1.84k]
  ------------------
 3071|      0|            return;
 3072|      0|         }
 3073|  1.84k|         const size_t ws_size = size_t(it - ws_start);
 3074|       |
 3075|       |         if constexpr ((glaze_object_t<T> || reflectable<T>) && num_members == 0 && Opts.error_on_unknown_keys) {
 3076|       |            if constexpr (not tag.sv().empty()) {
 3077|       |               if (*it == '"') {
 3078|       |                  ++it;
 3079|       |                  if constexpr (not Opts.null_terminated) {
 3080|       |                     if (it == end) [[unlikely]] {
 3081|       |                        ctx.error = error_code::unexpected_end;
 3082|       |                        return;
 3083|       |                     }
 3084|       |                  }
 3085|       |
 3086|       |                  const auto start = it;
 3087|       |                  skip_string_view(ctx, it, end);
 3088|       |                  if (bool(ctx.error)) [[unlikely]]
 3089|       |                     return;
 3090|       |                  if (validate_utf8_span<Opts>(ctx, start, it)) [[unlikely]]
 3091|       |                     return;
 3092|       |                  const sv key{start, size_t(it - start)};
 3093|       |                  ++it;
 3094|       |                  if constexpr (not Opts.null_terminated) {
 3095|       |                     if (it == end) [[unlikely]] {
 3096|       |                        ctx.error = error_code::unexpected_end;
 3097|       |                        return;
 3098|       |                     }
 3099|       |                  }
 3100|       |
 3101|       |                  if (key == tag.sv()) {
 3102|       |                     if (parse_ws_colon<Opts>(ctx, it, end)) {
 3103|       |                        return;
 3104|       |                     }
 3105|       |
 3106|       |                     parse<JSON>::handle_unknown<Opts>(key, value, ctx, it, end);
 3107|       |                     if (bool(ctx.error)) [[unlikely]]
 3108|       |                        return;
 3109|       |
 3110|       |                     if (skip_ws<Opts>(ctx, it, end)) {
 3111|       |                        return;
 3112|       |                     }
 3113|       |                  }
 3114|       |                  else {
 3115|       |                     ctx.error = error_code::unknown_key;
 3116|       |                     return;
 3117|       |                  }
 3118|       |               }
 3119|       |            }
 3120|       |
 3121|       |            if (*it == '}') [[likely]] {
 3122|       |               --ctx.depth;
 3123|       |               if constexpr (glaze_object_t<T> || reflectable<T>) {
 3124|       |                  if constexpr (has_self_constraint_v<T> && !check_skip_self_constraint(Opts)) {
 3125|       |                     auto wrapper = self_constraint_v<T>(value);
 3126|       |                     from<JSON, decltype(wrapper)>::template op<ws_handled<Opts>()>(wrapper, ctx, it, end);
 3127|       |                     if (bool(ctx.error)) {
 3128|       |                        return;
 3129|       |                     }
 3130|       |                  }
 3131|       |               }
 3132|       |               ++it;
 3133|       |               if constexpr (not Opts.null_terminated) {
 3134|       |                  if (it == end) {
 3135|       |                     ctx.error = error_code::end_reached;
 3136|       |                     return;
 3137|       |                  }
 3138|       |               }
 3139|       |               if constexpr (Opts.partial_read) {
 3140|       |                  ctx.error = error_code::partial_read_complete;
 3141|       |               }
 3142|       |               return;
 3143|       |            }
 3144|       |            ctx.error = error_code::unknown_key;
 3145|       |            return;
 3146|       |         }
 3147|  1.84k|         else {
 3148|  1.84k|            decltype(auto) fields = [&]() -> decltype(auto) {
 3149|  1.84k|               if constexpr ((glaze_object_t<T> || reflectable<T>) &&
 3150|  1.84k|                             (Opts.error_on_missing_keys || Opts.partial_read)) {
 3151|  1.84k|                  return bit_array<num_members>{};
 3152|  1.84k|               }
 3153|  1.84k|               else {
 3154|  1.84k|                  return nullptr;
 3155|  1.84k|               }
 3156|  1.84k|            }();
 3157|       |
 3158|  1.84k|            size_t read_count{}; // for partial_read
 3159|       |
 3160|  1.84k|            bool first = true;
 3161|  28.5k|            while (true) {
  ------------------
  |  Branch (3161:20): [True: 27.3k, Folded]
  ------------------
 3162|       |               if constexpr ((glaze_object_t<T> || reflectable<T>) && Opts.partial_read) {
 3163|       |                  static constexpr bit_array<num_members> all_fields = [] {
 3164|       |                     bit_array<num_members> arr{};
 3165|       |                     for (size_t i = 0; i < num_members; ++i) {
 3166|       |                        arr[i] = true;
 3167|       |                     }
 3168|       |                     return arr;
 3169|       |                  }();
 3170|       |
 3171|       |                  if ((all_fields & fields) == all_fields) {
 3172|       |                     ctx.error = error_code::partial_read_complete;
 3173|       |                     --ctx.depth; // as above: an early success still closes this level
 3174|       |                     return;
 3175|       |                  }
 3176|       |               }
 3177|       |
 3178|       |               // Streaming refill point: at start of each iteration, ensure buffer has data
 3179|       |               if constexpr (has_streaming_state<decltype(ctx)>) {
 3180|       |                  if (ctx.stream.enabled()) {
 3181|       |                     const size_t consumed = static_cast<size_t>(it - ctx.stream.data());
 3182|       |                     const size_t remaining = ctx.stream.size() - consumed;
 3183|       |                     // Refill when less than half of buffer remains to ensure space for next key-value pair
 3184|       |                     if (remaining <= ctx.stream.size() / 2 || it >= end) {
 3185|       |                        const char* new_it;
 3186|       |                        const char* new_end;
 3187|       |                        ctx.stream.consume_and_refill(consumed, new_it, new_end);
 3188|       |                        it = new_it;
 3189|       |                        end = new_end;
 3190|       |                        if (it >= end && ctx.stream.at_eof()) {
 3191|       |                           ctx.error = error_code::unexpected_end;
 3192|       |                           return;
 3193|       |                        }
 3194|       |                     }
 3195|       |                  }
 3196|       |               }
 3197|       |
 3198|  27.3k|               if (*it == '}') {
  ------------------
  |  Branch (3198:20): [True: 316, False: 27.0k]
  ------------------
 3199|    316|                  --ctx.depth;
 3200|       |                  if constexpr ((glaze_object_t<T> || reflectable<T>) && Opts.error_on_missing_keys) {
 3201|       |                     constexpr auto req_fields = required_fields<T, Opts>();
 3202|       |                     if ((req_fields & fields) != req_fields) {
 3203|       |                        for (size_t i = 0; i < num_members; ++i) {
 3204|       |                           if (not fields[i] && req_fields[i]) {
 3205|       |                              ctx.custom_error_message = reflect<T>::keys[i];
 3206|       |                              // We just return the first missing key in order to avoid heap allocations
 3207|       |                              break;
 3208|       |                           }
 3209|       |                        }
 3210|       |
 3211|       |                        ctx.error = error_code::missing_key;
 3212|       |                        return;
 3213|       |                     }
 3214|       |                  }
 3215|       |                  if constexpr (glaze_object_t<T> || reflectable<T>) {
 3216|       |                     if constexpr (has_self_constraint_v<T> && !check_skip_self_constraint(Opts)) {
 3217|       |                        auto wrapper = self_constraint_v<T>(value);
 3218|       |                        from<JSON, decltype(wrapper)>::template op<ws_handled<Opts>()>(wrapper, ctx, it, end);
 3219|       |                        if (bool(ctx.error)) {
 3220|       |                           return;
 3221|       |                        }
 3222|       |                     }
 3223|       |                  }
 3224|    316|                  ++it; // Increment after checking for missing keys so errors are within buffer bounds
 3225|    316|                  if constexpr (not Opts.null_terminated) {
 3226|    316|                     if (it == end) {
  ------------------
  |  Branch (3226:26): [True: 316, False: 0]
  ------------------
 3227|    316|                        ctx.error = error_code::end_reached;
 3228|    316|                        return;
 3229|    316|                     }
 3230|    316|                  }
 3231|      0|                  return;
 3232|    316|               }
 3233|  27.0k|               else if (first) {
  ------------------
  |  Branch (3233:25): [True: 1.78k, False: 25.2k]
  ------------------
 3234|  1.78k|                  first = false;
 3235|  1.78k|               }
 3236|  25.2k|               else {
 3237|  25.2k|                  if (match_invalid_end<',', Opts>(ctx, it, end)) {
  ------------------
  |  Branch (3237:23): [True: 298, False: 24.9k]
  ------------------
 3238|    298|                     return;
 3239|    298|                  }
 3240|  24.9k|                  if constexpr (not Opts.null_terminated) {
 3241|  24.9k|                     if (it == end) [[unlikely]] {
  ------------------
  |  Branch (3241:26): [True: 0, False: 24.9k]
  ------------------
 3242|      0|                        ctx.error = error_code::unexpected_end;
 3243|      0|                        return;
 3244|      0|                     }
 3245|  24.9k|                  }
 3246|       |
 3247|       |                  if constexpr ((not Opts.minified) && (num_members > 1 || not Opts.error_on_unknown_keys) &&
 3248|       |                                (!Opts.comments)) {
 3249|       |                     if (ws_size && ws_size < size_t(end - it)) {
 3250|       |                        skip_matching_ws(ws_start, it, ws_size);
 3251|       |                     }
 3252|       |                  }
 3253|       |
 3254|  24.9k|                  if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (3254:23): [True: 0, False: 24.9k]
  ------------------
 3255|      0|                     return;
 3256|      0|                  }
 3257|  24.9k|               }
 3258|       |
 3259|  26.7k|               constexpr auto reflection_type = glaze_object_t<T> || reflectable<T>;
  ------------------
  |  Branch (3259:49): [Folded, False: 0]
  |  Branch (3259:70): [Folded, False: 0]
  ------------------
 3260|       |
 3261|       |               if constexpr (reflection_type && (num_members == 0)) {
 3262|       |                  if constexpr (Opts.error_on_unknown_keys) {
 3263|       |                     static_assert(false_v<T>, "This should be unreachable");
 3264|       |                  }
 3265|       |                  else {
 3266|       |                     if (match_invalid_end<'"', Opts>(ctx, it, end)) {
 3267|       |                        return;
 3268|       |                     }
 3269|       |
 3270|       |                     // parsing to an empty object, but at this point the JSON presents keys
 3271|       |
 3272|       |                     // Unknown key handler does not unescape keys. Unknown escaped keys are
 3273|       |                     // handled by the user.
 3274|       |
 3275|       |                     const auto start = it;
 3276|       |                     skip_string_view(ctx, it, end);
 3277|       |                     if (bool(ctx.error)) [[unlikely]]
 3278|       |                        return;
 3279|       |                     if (validate_utf8_span<Opts>(ctx, start, it)) [[unlikely]]
 3280|       |                        return;
 3281|       |                     const sv key{start, size_t(it - start)};
 3282|       |                     ++it;
 3283|       |                     if constexpr (not Opts.null_terminated) {
 3284|       |                        if (it == end) [[unlikely]] {
 3285|       |                           ctx.error = error_code::unexpected_end;
 3286|       |                           return;
 3287|       |                        }
 3288|       |                     }
 3289|       |
 3290|       |                     if (parse_ws_colon<Opts>(ctx, it, end)) {
 3291|       |                        return;
 3292|       |                     }
 3293|       |
 3294|       |                     // Check if this key is the variant tag that should be skipped
 3295|       |                     if constexpr (not tag.sv().empty()) {
 3296|       |                        if (key == tag.sv()) {
 3297|       |                           // Skip the tag value
 3298|       |                           skip_value<JSON>::op<Opts>(ctx, it, end);
 3299|       |                           if (bool(ctx.error)) [[unlikely]]
 3300|       |                              return;
 3301|       |                           resync_window_end(ctx, end); // a streaming skip refills
 3302|       |                           if (skip_ws<Opts>(ctx, it, end)) {
 3303|       |                              return;
 3304|       |                           }
 3305|       |                           continue;
 3306|       |                        }
 3307|       |                     }
 3308|       |
 3309|       |                     parse<JSON>::handle_unknown<Opts>(key, value, ctx, it, end);
 3310|       |                     if (bool(ctx.error)) [[unlikely]]
 3311|       |                        return;
 3312|       |                     if constexpr (not Opts.null_terminated) {
 3313|       |                        if (it == end) [[unlikely]] {
 3314|       |                           ctx.error = error_code::unexpected_end;
 3315|       |                           return;
 3316|       |                        }
 3317|       |                     }
 3318|       |                     if (skip_ws<Opts>(ctx, it, end)) {
 3319|       |                        return;
 3320|       |                     }
 3321|       |                  }
 3322|       |               }
 3323|       |               else if constexpr (reflection_type) {
 3324|       |                  static_assert(bool(hash_info<T>.type));
 3325|       |
 3326|       |                  if (*it != '"') [[unlikely]] {
 3327|       |                     ctx.error = error_code::expected_quote;
 3328|       |                     return;
 3329|       |                  }
 3330|       |                  ++it;
 3331|       |                  if constexpr (not Opts.null_terminated) {
 3332|       |                     if (it == end) [[unlikely]] {
 3333|       |                        ctx.error = error_code::unexpected_end;
 3334|       |                        return;
 3335|       |                     }
 3336|       |                  }
 3337|       |
 3338|       |                  if constexpr (not tag.sv().empty() && not contains_tag<T, tag>()) {
 3339|       |                     // For tagged variants we first check to see if the key matches the tag
 3340|       |                     // We only need to do this if the tag is not part of the keys
 3341|       |
 3342|       |                     const auto start = it;
 3343|       |                     skip_string_view(ctx, it, end);
 3344|       |                     if (bool(ctx.error)) [[unlikely]]
 3345|       |                        return;
 3346|       |                     if (validate_utf8_span<Opts>(ctx, start, it)) [[unlikely]]
 3347|       |                        return;
 3348|       |                     const sv key{start, size_t(it - start)};
 3349|       |                     ++it;
 3350|       |                     if constexpr (not Opts.null_terminated) {
 3351|       |                        if (it == end) [[unlikely]] {
 3352|       |                           ctx.error = error_code::unexpected_end;
 3353|       |                           return;
 3354|       |                        }
 3355|       |                     }
 3356|       |
 3357|       |                     if (key == tag.sv()) {
 3358|       |                        if (parse_ws_colon<Opts>(ctx, it, end)) {
 3359|       |                           return;
 3360|       |                        }
 3361|       |
 3362|       |                        parse<JSON>::handle_unknown<Opts>(key, value, ctx, it, end);
 3363|       |                        if (bool(ctx.error)) [[unlikely]]
 3364|       |                           return;
 3365|       |
 3366|       |                        if (skip_ws<Opts>(ctx, it, end)) {
 3367|       |                           return;
 3368|       |                        }
 3369|       |                        continue;
 3370|       |                     }
 3371|       |                     else {
 3372|       |                        it = start; // reset the iterator
 3373|       |                     }
 3374|       |                  }
 3375|       |
 3376|       |                  if constexpr (Opts.error_on_missing_keys || Opts.partial_read) {
 3377|       |                     size_t index = num_members;
 3378|       |                     parse_and_invoke<Opts, T>(value, ctx, it, end, index);
 3379|       |                     if (bool(ctx.error)) [[unlikely]]
 3380|       |                        return;
 3381|       |                     if (index < num_members) {
 3382|       |                        fields[index] = true;
 3383|       |                     }
 3384|       |                  }
 3385|       |                  else {
 3386|       |                     parse_and_invoke<Opts, T>(value, ctx, it, end);
 3387|       |                     if (bool(ctx.error)) [[unlikely]]
 3388|       |                        return;
 3389|       |                  }
 3390|       |               }
 3391|  26.7k|               else {
 3392|       |                  // For types like std::map, std::unordered_map
 3393|       |
 3394|  26.7k|                  auto reading = [&](auto&& key) {
 3395|  26.7k|                     if constexpr (Opts.partial_read) {
 3396|  26.7k|                        if (auto element = value.find(key); element != value.end()) {
 3397|  26.7k|                           ++read_count;
 3398|  26.7k|                           parse<JSON>::op<ws_handled<Opts>()>(element->second, ctx, it, end);
 3399|  26.7k|                        }
 3400|  26.7k|                        else {
 3401|  26.7k|                           skip_value<JSON>::op<Opts>(ctx, it, end);
 3402|  26.7k|                        }
 3403|  26.7k|                     }
 3404|  26.7k|                     else {
 3405|  26.7k|                        parse<JSON>::op<ws_handled<Opts>()>(value[key], ctx, it, end);
 3406|  26.7k|                     }
 3407|  26.7k|                  };
 3408|       |
 3409|       |                  // using Key = std::conditional_t<heterogeneous_map<T>, sv, typename T::key_type>;
 3410|  26.7k|                  using Key = typename T::key_type;
 3411|  26.7k|                  if constexpr (std::is_same_v<Key, std::string>) {
 3412|  26.7k|                     ctx.scratch.clear();
 3413|  26.7k|                     parse<JSON>::op<Opts>(ctx.scratch, ctx, it, end);
 3414|  26.7k|                     if (bool(ctx.error)) [[unlikely]]
  ------------------
  |  Branch (3414:26): [True: 303, False: 26.4k]
  ------------------
 3415|    303|                        return;
 3416|       |
 3417|  26.4k|                     if (parse_ws_colon<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (3417:26): [True: 238, False: 26.2k]
  ------------------
 3418|    238|                        return;
 3419|    238|                     }
 3420|       |
 3421|  26.2k|                     reading(ctx.scratch);
 3422|       |                     if constexpr (Opts.partial_read) {
 3423|       |                        if (read_count == value.size()) {
 3424|       |                           return;
 3425|       |                        }
 3426|       |                     }
 3427|  26.2k|                     if (bool(ctx.error)) [[unlikely]]
  ------------------
  |  Branch (3427:26): [True: 656, False: 25.5k]
  ------------------
 3428|    656|                        return;
 3429|       |                  }
 3430|       |                  else if constexpr (str_t<Key>) {
 3431|       |                     Key key;
 3432|       |                     parse<JSON>::op<Opts>(key, ctx, it, end);
 3433|       |                     if (bool(ctx.error)) [[unlikely]]
 3434|       |                        return;
 3435|       |
 3436|       |                     if (parse_ws_colon<Opts>(ctx, it, end)) {
 3437|       |                        return;
 3438|       |                     }
 3439|       |
 3440|       |                     reading(key);
 3441|       |                     if constexpr (Opts.partial_read) {
 3442|       |                        if (read_count == value.size()) {
 3443|       |                           return;
 3444|       |                        }
 3445|       |                     }
 3446|       |                     if (bool(ctx.error)) [[unlikely]]
 3447|       |                        return;
 3448|       |                  }
 3449|       |                  else {
 3450|       |                     Key key_value{};
 3451|       |                     if constexpr (is_named_enum<Key> || mimics_str_t<Key>) {
 3452|       |                        parse<JSON>::op<Opts>(key_value, ctx, it, end);
 3453|       |                     }
 3454|       |                     else if constexpr (std::is_arithmetic_v<Key>) {
 3455|       |                        // prefer over quoted_t below to avoid double parsing of quoted_t
 3456|       |                        parse<JSON>::op<opt_true<Opts, quoted_num_opt_tag{}>>(key_value, ctx, it, end);
 3457|       |                     }
 3458|       |                     else {
 3459|       |                        parse<JSON>::op<opt_false<Opts, raw_string_opt_tag{}>>(quoted_t<Key>{key_value}, ctx, it, end);
 3460|       |                     }
 3461|       |                     if (bool(ctx.error)) [[unlikely]]
 3462|       |                        return;
 3463|       |
 3464|       |                     if (parse_ws_colon<Opts>(ctx, it, end)) {
 3465|       |                        return;
 3466|       |                     }
 3467|       |
 3468|       |                     reading(key_value);
 3469|       |                     if constexpr (Opts.partial_read) {
 3470|       |                        if (read_count == value.size()) {
 3471|       |                           return;
 3472|       |                        }
 3473|       |                     }
 3474|       |                     if (bool(ctx.error)) [[unlikely]]
 3475|       |                        return;
 3476|       |                  }
 3477|  26.7k|               }
 3478|       |
 3479|       |               // Streaming refill point: after parsing each key-value pair, refill if buffer is low
 3480|       |               if constexpr (has_streaming_state<decltype(ctx)>) {
 3481|       |                  if (ctx.stream.enabled()) {
 3482|       |                     const size_t consumed = static_cast<size_t>(it - ctx.stream.data());
 3483|       |                     // Refill when less than 25% of buffer remains to ensure enough space for next element
 3484|       |                     if (ctx.stream.size() - consumed <= ctx.stream.size() / 4 || it >= end) {
 3485|       |                        const char* new_it;
 3486|       |                        const char* new_end;
 3487|       |                        ctx.stream.consume_and_refill(consumed, new_it, new_end);
 3488|       |                        it = new_it;
 3489|       |                        end = new_end;
 3490|       |                        if (it >= end && ctx.stream.at_eof()) {
 3491|       |                           ctx.error = error_code::unexpected_end;
 3492|       |                           return;
 3493|       |                        }
 3494|       |                     }
 3495|       |                  }
 3496|       |               }
 3497|       |
 3498|  26.7k|               if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (3498:20): [True: 0, False: 26.7k]
  ------------------
 3499|      0|                  return;
 3500|      0|               }
 3501|  26.7k|            }
 3502|  1.84k|         }
 3503|  1.84k|      }
_ZZN3glz4fromILj10ENSt3__13mapINS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEiNS1_4lessIS8_EENS6_INS1_4pairIKS8_iEEEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnNS_14string_literalEXtlNSJ_ILm1EEEEERSF_TkNS_10is_contextERNS_7contextERPKcSP_EEvOT1_OT2_OT3_T4_ENKUlvE_clEv:
 3148|  1.81k|            decltype(auto) fields = [&]() -> decltype(auto) {
 3149|       |               if constexpr ((glaze_object_t<T> || reflectable<T>) &&
 3150|       |                             (Opts.error_on_missing_keys || Opts.partial_read)) {
 3151|       |                  return bit_array<num_members>{};
 3152|       |               }
 3153|  1.81k|               else {
 3154|  1.81k|                  return nullptr;
 3155|  1.81k|               }
 3156|  1.81k|            }();
_ZZN3glz4fromILj10ENSt3__13mapINS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEiNS1_4lessIS8_EENS6_INS1_4pairIKS8_iEEEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnNS_14string_literalEXtlNSJ_ILm1EEEEERSF_TkNS_10is_contextERNS_7contextERPKcSP_EEvOT1_OT2_OT3_T4_ENKUlOT_E_clIRS8_EEDaSZ_:
 3394|  26.2k|                  auto reading = [&](auto&& key) {
 3395|       |                     if constexpr (Opts.partial_read) {
 3396|       |                        if (auto element = value.find(key); element != value.end()) {
 3397|       |                           ++read_count;
 3398|       |                           parse<JSON>::op<ws_handled<Opts>()>(element->second, ctx, it, end);
 3399|       |                        }
 3400|       |                        else {
 3401|       |                           skip_value<JSON>::op<Opts>(ctx, it, end);
 3402|       |                        }
 3403|       |                     }
 3404|  26.2k|                     else {
 3405|  26.2k|                        parse<JSON>::op<ws_handled<Opts>()>(value[key], ctx, it, end);
 3406|  26.2k|                     }
 3407|  26.2k|                  };
_ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__18optionalIdEETkNS_10is_contextERNS_7contextERPKcSB_EEvOT0_OT1_OT2_T3_:
   49|  2.00k|      {
   50|       |         if constexpr (const_value_v<T>) {
   51|       |            if constexpr (check_error_on_const_read(Opts)) {
   52|       |               ctx.error = error_code::attempt_const_read;
   53|       |            }
   54|       |            else {
   55|       |               // do not read anything into the const value
   56|       |               skip_value<JSON>::op<Opts>(std::forward<Ctx>(ctx), std::forward<It0>(it), end);
   57|       |            }
   58|       |         }
   59|  2.00k|         else {
   60|  2.00k|            using V = std::remove_cvref_t<T>;
   61|  2.00k|            from<JSON, V>::template op<Opts>(std::forward<T>(value), std::forward<Ctx>(ctx), std::forward<It0>(it),
   62|  2.00k|                                             end);
   63|  2.00k|         }
   64|  2.00k|      }
_ZN3glz4fromILj10ENSt3__18optionalIdEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS3_TkNS_10is_contextERNS_7contextERPKcSB_EEvOT0_OT1_OT2_T3_:
 5088|  2.00k|      {
 5089|  2.00k|         constexpr auto Opts = ws_handled_off<Options>();
 5090|  2.00k|         if constexpr (!check_ws_handled(Options)) {
 5091|  2.00k|            if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (5091:17): [True: 0, False: 2.00k]
  ------------------
 5092|      0|               return;
 5093|      0|            }
 5094|  2.00k|         }
 5095|       |
 5096|  2.00k|         if (*it == 'n') {
  ------------------
  |  Branch (5096:14): [True: 0, False: 2.00k]
  ------------------
 5097|      0|            ++it;
 5098|      0|            if constexpr (not Opts.null_terminated) {
 5099|      0|               if (it == end) [[unlikely]] {
  ------------------
  |  Branch (5099:20): [True: 0, False: 0]
  ------------------
 5100|      0|                  ctx.error = error_code::unexpected_end;
 5101|      0|                  return;
 5102|      0|               }
 5103|      0|            }
 5104|      0|            match<"ull", Opts>(ctx, it, end);
 5105|      0|            if (bool(ctx.error)) [[unlikely]]
  ------------------
  |  Branch (5105:17): [True: 0, False: 0]
  ------------------
 5106|      0|               return;
 5107|      0|            if constexpr (requires { value.reset(); }) {
 5108|      0|               value.reset();
 5109|      0|            }
 5110|      0|         }
 5111|  2.00k|         else {
 5112|  2.00k|            if constexpr (nullable_value_t<T>) {
 5113|  2.00k|               if (not value.has_value()) {
  ------------------
  |  Branch (5113:20): [True: 2.00k, False: 0]
  ------------------
 5114|       |                  if constexpr (constructible<T>) {
 5115|       |                     value = meta_construct_v<T>();
 5116|       |                  }
 5117|  2.00k|                  else if constexpr (requires { value.emplace(); }) {
 5118|  2.00k|                     value.emplace();
 5119|       |                  }
 5120|       |                  else {
 5121|       |                     static_assert(false_v<T>,
 5122|       |                                   "Your nullable type must have `emplace()` or be glz::meta constructible, or "
 5123|       |                                   "create a custom glz::from specialization");
 5124|       |                  }
 5125|  2.00k|               }
 5126|  2.00k|               parse<JSON>::op<Opts>(value.value(), ctx, it, end);
 5127|       |            }
 5128|       |            else {
 5129|       |               if (!value) {
 5130|       |                  if (!nullable_emplace<Opts>(value, ctx)) {
 5131|       |                     return;
 5132|       |                  }
 5133|       |               }
 5134|       |               parse<JSON>::op<Opts>(*value, ctx, it, end);
 5135|       |            }
 5136|  2.00k|         }
 5137|  2.00k|      }
_ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__17variantIJNS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEN12jsonrpc_fuzz6amountEEEETkNS_10is_contextERNS_7contextERPKcSJ_EEvOT0_OT1_OT2_T3_:
   49|  1.09k|      {
   50|       |         if constexpr (const_value_v<T>) {
   51|       |            if constexpr (check_error_on_const_read(Opts)) {
   52|       |               ctx.error = error_code::attempt_const_read;
   53|       |            }
   54|       |            else {
   55|       |               // do not read anything into the const value
   56|       |               skip_value<JSON>::op<Opts>(std::forward<Ctx>(ctx), std::forward<It0>(it), end);
   57|       |            }
   58|       |         }
   59|  1.09k|         else {
   60|  1.09k|            using V = std::remove_cvref_t<T>;
   61|  1.09k|            from<JSON, V>::template op<Opts>(std::forward<T>(value), std::forward<Ctx>(ctx), std::forward<It0>(it),
   62|  1.09k|                                             end);
   63|  1.09k|         }
   64|  1.09k|      }
_ZN3glz4fromILj10ENSt3__17variantIJNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEN12jsonrpc_fuzz6amountEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSB_TkNS_10is_contextERNS_7contextERPKcSJ_EEvOT0_OT1_OT2_T3_:
 4065|  1.09k|      {
 4066|       |         if constexpr (tagging == variant_tagging_kind::adjacent) {
 4067|       |            read_adjacent<Options>(value, ctx, it, end);
 4068|       |         }
 4069|  1.09k|         else {
 4070|  1.09k|            read_deduced<Options>(value, ctx, it, end);
 4071|  1.09k|         }
 4072|  1.09k|      }
_ZN3glz4fromILj10ENSt3__17variantIJNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEN12jsonrpc_fuzz6amountEEEEE12read_deducedITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSB_TkNS_10is_contextERNS_7contextERPKcSJ_EEvOT0_OT1_OT2_T3_:
 4076|  1.09k|      {
 4077|  1.09k|         constexpr auto Opts = ws_handled_off<Options>();
 4078|  1.09k|         if constexpr (variant_is_auto_deducible<T>()) {
 4079|  1.09k|            if constexpr (not check_ws_handled(Options)) {
 4080|  1.09k|               if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (4080:20): [True: 0, False: 1.09k]
  ------------------
 4081|      0|                  return;
 4082|      0|               }
 4083|  1.09k|            }
 4084|       |
 4085|  1.09k|            switch (*it) {
 4086|      0|            case '\0':
  ------------------
  |  Branch (4086:13): [True: 0, False: 1.09k]
  ------------------
 4087|      0|               ctx.error = error_code::unexpected_end;
 4088|      0|               return;
 4089|    237|            case '{': {
  ------------------
  |  Branch (4089:13): [True: 237, False: 858]
  ------------------
 4090|       |               // This branch consumes the brace itself and hands the object to a reader with
 4091|       |               // `opening_handled`, which therefore does not count the level -- but does release it at
 4092|       |               // the closing brace. So the level is taken here, in both buffer modes, and paid back by
 4093|       |               // the reader below.
 4094|    237|               if (enter_depth(ctx)) [[unlikely]] {
  ------------------
  |  Branch (4094:20): [True: 0, False: 237]
  ------------------
 4095|      0|                  return;
 4096|      0|               }
 4097|       |
 4098|    237|               ++it;
 4099|    237|               if constexpr (not Opts.null_terminated) {
 4100|    237|                  if (it == end) [[unlikely]] {
  ------------------
  |  Branch (4100:23): [True: 0, False: 237]
  ------------------
 4101|      0|                     ctx.error = error_code::unexpected_end;
 4102|      0|                     return;
 4103|      0|                  }
 4104|    237|               }
 4105|    237|               using type_counts = variant_type_count<T>;
 4106|    237|               constexpr auto n_object_candidates = variant_object_candidate_count_v<Opts, T>;
 4107|       |               if constexpr (n_object_candidates < 1) {
 4108|       |                  ctx.error = error_code::no_matching_variant_type;
 4109|       |                  return;
 4110|       |               }
 4111|    237|               else if constexpr (n_object_candidates == 1 && tag_v<T>.empty()) {
 4112|    237|                  constexpr auto first_idx = variant_first_object_candidate_v<Opts, T>;
 4113|    237|                  using V = std::variant_alternative_t<first_idx, T>;
 4114|    237|                  if (!std::holds_alternative<V>(value)) value = V{};
  ------------------
  |  Branch (4114:23): [True: 237, False: 0]
  ------------------
 4115|    237|                  parse<JSON>::op<opening_handled<Opts>()>(std::get<V>(value), ctx, it, end);
 4116|    237|                  return;
 4117|       |               }
 4118|       |               else {
 4119|       |                  auto possible_types = bit_array<std::variant_size_v<T>>{}.flip();
 4120|       |                  static constexpr auto& deduction_bits = variant_deduction_bits<T>;
 4121|       |                  static constexpr size_t deduction_key_count = variant_deduction_key_count<T>;
 4122|       |                  static constexpr auto tag_literal = string_literal_from_view<tag_v<T>.size()>(tag_v<T>);
 4123|       |
 4124|       |                  // Track if we've encountered a tag and what value it had
 4125|       |                  std::optional<size_t> tag_specified_index{};
 4126|       |
 4127|       |                  if (skip_ws<Opts>(ctx, it, end)) {
 4128|       |                     return;
 4129|       |                  }
 4130|       |                  // Once the reader knows which alternative this object holds it may have to read
 4131|       |                  // it again from here. Anchor the position rather than keep the pointer: the scan
 4132|       |                  // below skips values, and a streaming skip refills, which moves the window out
 4133|       |                  // from under a raw pointer (see rewind_anchor).
 4134|       |                  auto start = make_rewind_anchor(ctx, it);
 4135|       |                  bool first_key = true;
 4136|       |                  // Parse bifurcation for tagged variants:
 4137|       |                  //
 4138|       |                  // Without this optimization, tagged variant parsing always uses two passes:
 4139|       |                  //   1. Scan all keys to find the tag (e.g. "type"), skipping values
 4140|       |                  //   2. Reset `it = start` and re-parse the entire object into the resolved type
 4141|       |                  //
 4142|       |                  // When the tag is the first key, the second pass redundantly re-reads every
 4143|       |                  // field that follows it. This lambda avoids that: if the tag was the first key,
 4144|       |                  // it advances past the trailing comma so the object parser picks up at the
 4145|       |                  // second field. If the tag was found later, it falls back to the full re-parse.
 4146|       |                  //
 4147|       |                  // One exception: if the tag name is also a field on the resolved struct
 4148|       |                  // (contains_tag), we must re-parse regardless so the value is stored in
 4149|       |                  // the struct field. This override is applied inside each std::visit lambda.
 4150|       |                  //
 4151|       |                  // Either way the rewind can fail under a streaming read: the window only holds so
 4152|       |                  // much, and an object wider than it has no start left to return to.
 4153|       |                  auto position_after_tag = [&] {
 4154|       |                     if (first_key) {
 4155|       |                        if (*it == ',') ++it; // skip comma; handles tag-only objects where *it == '}'
 4156|       |                        return true;
 4157|       |                     }
 4158|       |                     return start.rewind(ctx, it, end); // tag came later, re-parse from the beginning
 4159|       |                  };
 4160|       |                  // `first_key` also answers "were we reset to the object start", which is what
 4161|       |                  // position_after_tag does for every key but the first.
 4162|       |                  for (; *it != '}'; first_key = false) {
 4163|       |                     if (!first_key) {
 4164|       |                        if (match_invalid_end<',', Opts>(ctx, it, end)) {
 4165|       |                           return;
 4166|       |                        }
 4167|       |                     }
 4168|       |
 4169|       |                     if (skip_ws<Opts>(ctx, it, end)) {
 4170|       |                        return;
 4171|       |                     }
 4172|       |                     if (match_invalid_end<'"', Opts>(ctx, it, end)) {
 4173|       |                        return;
 4174|       |                     }
 4175|       |
 4176|       |                     auto* key_start = it;
 4177|       |                     skip_string_view(ctx, it, end);
 4178|       |                     if (bool(ctx.error)) [[unlikely]]
 4179|       |                        return;
 4180|       |                     if (validate_utf8_span<Opts>(ctx, key_start, it)) [[unlikely]]
 4181|       |                        return;
 4182|       |                     const sv key = {key_start, size_t(it - key_start)};
 4183|       |
 4184|       |                     if (match_invalid_end<'"', Opts>(ctx, it, end)) {
 4185|       |                        return;
 4186|       |                     }
 4187|       |
 4188|       |                     if constexpr (deduction_key_count > 0) {
 4189|       |                        // We first check if a tag is defined and see if the key matches the tag
 4190|       |                        if constexpr (not tag_v<T>.empty()) {
 4191|       |                           if (key == tag_v<T>) {
 4192|       |                              if (parse_ws_colon<Opts>(ctx, it, end)) {
 4193|       |                                 return;
 4194|       |                              }
 4195|       |
 4196|       |                              using id_type = std::decay_t<decltype(ids_v<T>[0])>;
 4197|       |
 4198|       |                              std::conditional_t<std::integral<id_type>, id_type, sv> type_id{};
 4199|       |                              if constexpr (std::integral<id_type>) {
 4200|       |                                 from<JSON, id_type>::template op<ws_handled<Opts>()>(type_id, ctx, it, end);
 4201|       |                              }
 4202|       |                              else {
 4203|       |                                 // The id is turned into an index below and never leaves this
 4204|       |                                 // reader, so the view of the window it borrows cannot outlive it.
 4205|       |                                 parse_transient_string_view<ws_handled<Opts>()>(type_id, ctx, it, end);
 4206|       |                              }
 4207|       |                              if (bool(ctx.error)) [[unlikely]]
 4208|       |                                 return;
 4209|       |                              if (skip_ws<Opts>(ctx, it, end)) {
 4210|       |                                 return;
 4211|       |                              }
 4212|       |                              if (!(*it == ',' || *it == '}')) [[unlikely]] {
 4213|       |                                 ctx.error = error_code::syntax_error;
 4214|       |                                 return;
 4215|       |                              }
 4216|       |
 4217|       |                              size_t type_index;
 4218|       |                              if constexpr (std::integral<id_type>) {
 4219|       |                                 type_index = variant_id_to_index<T>::op(type_id);
 4220|       |                              }
 4221|       |                              else {
 4222|       |                                 type_index = variant_id_to_index<T>::op(
 4223|       |                                    type_id.data(), type_id.data() + type_id.size(), type_id.size());
 4224|       |                              }
 4225|       |                              if (type_index < ids_v<T>.size()) [[likely]] {
 4226|       |                                 // Check if the deduced types include the tag-specified type
 4227|       |                                 // If not, the tag doesn't match the fields
 4228|       |                                 // We're already inside if constexpr (deduction_registry.size()), so we know deduction
 4229|       |                                 // is happening. At this point, possible_types has been narrowed by field deduction.
 4230|       |                                 // Check if the tag-specified type is still possible
 4231|       |                                 const bool type_is_possible = possible_types[type_index];
 4232|       |                                 if (!type_is_possible) {
 4233|       |                                    // Tag specifies a type that doesn't match the fields seen so far
 4234|       |                                    ctx.error = error_code::no_matching_variant_type;
 4235|       |                                    return;
 4236|       |                                 }
 4237|       |
 4238|       |                                 if (!position_after_tag()) return;
 4239|       |                                 tag_specified_index = type_index; // Store the tag-specified type
 4240|       |                                 if (value.index() != type_index) emplace_runtime_variant(value, type_index);
 4241|       |                                 std::visit(
 4242|       |                                    [&](auto&& v) {
 4243|       |                                       using V = std::decay_t<decltype(v)>;
 4244|       |                                       constexpr bool is_object =
 4245|       |                                          (glaze_object_t<V> || reflectable<V>) && not custom_read<V>;
 4246|       |                                       if constexpr (variant_unit_alternative<V>) {
 4247|       |                                          // A unit alternative carries no data; its object holds only the
 4248|       |                                          // discriminator. Consume that body through an empty reflected object so
 4249|       |                                          // unknown-key policy and terminator handling match every other alternative.
 4250|       |                                          detail::variant_unit_body unit_body{};
 4251|       |                                          from<JSON, detail::variant_unit_body>::template op<opening_handled<Opts>(),
 4252|       |                                                                                             tag_literal>(unit_body,
 4253|       |                                                                                                          ctx, it, end);
 4254|       |                                       }
 4255|       |                                       else if constexpr (is_object) {
 4256|       |                                          if constexpr (contains_tag<V, tag_literal>()) {
 4257|       |                                             // tag is a struct field, must re-parse
 4258|       |                                             if (!start.rewind(ctx, it, end)) return;
 4259|       |                                          }
 4260|       |                                          from<JSON, V>::template op<opening_handled<Opts>(), tag_literal>(v, ctx, it,
 4261|       |                                                                                                           end);
 4262|       |                                       }
 4263|       |                                       else if constexpr (is_memory_object<V>) {
 4264|       |                                          if (!v) {
 4265|       |                                             if constexpr (is_specialization_v<V, std::optional>) {
 4266|       |                                                if constexpr (requires { v.emplace(); }) {
 4267|       |                                                   v.emplace();
 4268|       |                                                }
 4269|       |                                                else {
 4270|       |                                                   v = typename V::value_type{};
 4271|       |                                                }
 4272|       |                                             }
 4273|       |                                             else if constexpr (is_specialization_v<V, std::unique_ptr>)
 4274|       |                                                v = std::make_unique<typename V::element_type>();
 4275|       |                                             else if constexpr (is_specialization_v<V, std::shared_ptr>)
 4276|       |                                                v = std::make_shared<typename V::element_type>();
 4277|       |                                             else if constexpr (constructible<V>) {
 4278|       |                                                v = meta_construct_v<V>();
 4279|       |                                             }
 4280|       |                                             else if constexpr (std::is_pointer_v<V> &&
 4281|       |                                                                can_allocate_raw_pointer<Opts,
 4282|       |                                                                                         std::decay_t<decltype(ctx)>>) {
 4283|       |                                                if (!try_allocate_raw_pointer<Opts>(v, ctx)) {
 4284|       |                                                   return;
 4285|       |                                                }
 4286|       |                                             }
 4287|       |                                             else {
 4288|       |                                                ctx.error = error_code::invalid_nullable_read;
 4289|       |                                                return;
 4290|       |                                                // Cannot read into unset nullable that is not std::optional,
 4291|       |                                                // std::unique_ptr, or std::shared_ptr
 4292|       |                                             }
 4293|       |                                          }
 4294|       |                                          if constexpr (contains_tag<memory_type<V>, tag_literal>()) {
 4295|       |                                             // tag is a struct field, must re-parse
 4296|       |                                             if (!start.rewind(ctx, it, end)) return;
 4297|       |                                          }
 4298|       |                                          from<JSON, memory_type<V>>::template op<opening_handled<Opts>(), tag_literal>(
 4299|       |                                             *v, ctx, it, end);
 4300|       |                                       }
 4301|       |                                       else if constexpr (custom_read<V>) {
 4302|       |                                          // Custom handlers parse the remaining body themselves and do not
 4303|       |                                          // accept the tag template parameter; the tag was already consumed.
 4304|       |                                          // This only works when the tag was the first key. If it came later,
 4305|       |                                          // we were reset to the object start and the custom handler would
 4306|       |                                          // absorb the tag, so error rather than corrupt the value.
 4307|       |                                          if (!first_key) {
 4308|       |                                             ctx.error = error_code::feature_not_supported;
 4309|       |                                             ctx.custom_error_message =
 4310|       |                                                "the tag must be the first key for a custom variant alternative";
 4311|       |                                             return;
 4312|       |                                          }
 4313|       |                                          from<JSON, V>::template op<opening_handled<Opts>()>(v, ctx, it, end);
 4314|       |                                       }
 4315|       |                                    },
 4316|       |                                    value);
 4317|       |
 4318|       |                                 return; // we've decoded our target type
 4319|       |                              }
 4320|       |                              else [[unlikely]] {
 4321|       |                                 // Check if we have a default type (ids array shorter than variant)
 4322|       |                                 constexpr auto ids_size = ids_v<T>.size();
 4323|       |                                 constexpr auto variant_size = std::variant_size_v<T>;
 4324|       |                                 if constexpr (ids_size < variant_size) {
 4325|       |                                    // Use the first unlabeled type as the default
 4326|       |                                    const auto default_type_index = ids_size;
 4327|       |
 4328|       |                                    if (!position_after_tag()) return;
 4329|       |                                    tag_specified_index = default_type_index; // Store the default type index
 4330|       |                                    if (value.index() != default_type_index)
 4331|       |                                       emplace_runtime_variant(value, default_type_index);
 4332|       |                                    std::visit(
 4333|       |                                       [&](auto&& v) {
 4334|       |                                          using V = std::decay_t<decltype(v)>;
 4335|       |                                          constexpr bool is_object =
 4336|       |                                             (glaze_object_t<V> || reflectable<V>) && not custom_read<V>;
 4337|       |                                          if constexpr (variant_unit_alternative<V>) {
 4338|       |                                             // A unit alternative carries no data; its object holds only the
 4339|       |                                             // discriminator. Consume that body through an empty reflected object so
 4340|       |                                             // unknown-key policy and terminator handling match every other
 4341|       |                                             // alternative.
 4342|       |                                             detail::variant_unit_body unit_body{};
 4343|       |                                             from<JSON, detail::variant_unit_body>::template op<opening_handled<Opts>(),
 4344|       |                                                                                                tag_literal>(
 4345|       |                                                unit_body, ctx, it, end);
 4346|       |                                          }
 4347|       |                                          else if constexpr (is_object) {
 4348|       |                                             if constexpr (contains_tag<V, tag_literal>()) {
 4349|       |                                                // tag is a struct field, must re-parse
 4350|       |                                                if (!start.rewind(ctx, it, end)) return;
 4351|       |                                             }
 4352|       |                                             from<JSON, V>::template op<opening_handled<Opts>()>(v, ctx, it, end);
 4353|       |                                          }
 4354|       |                                          else if constexpr (is_memory_object<V>) {
 4355|       |                                             if (!v) {
 4356|       |                                                if constexpr (is_specialization_v<V, std::optional>) {
 4357|       |                                                   if constexpr (requires { v.emplace(); }) {
 4358|       |                                                      v.emplace();
 4359|       |                                                   }
 4360|       |                                                   else {
 4361|       |                                                      v = typename V::value_type{};
 4362|       |                                                   }
 4363|       |                                                }
 4364|       |                                                else if constexpr (is_specialization_v<V, std::unique_ptr>)
 4365|       |                                                   v = std::make_unique<typename V::element_type>();
 4366|       |                                                else if constexpr (is_specialization_v<V, std::shared_ptr>)
 4367|       |                                                   v = std::make_shared<typename V::element_type>();
 4368|       |                                                else if constexpr (constructible<V>) {
 4369|       |                                                   v = meta_construct_v<V>();
 4370|       |                                                }
 4371|       |                                                else if constexpr (std::is_pointer_v<V> &&
 4372|       |                                                                   can_allocate_raw_pointer<
 4373|       |                                                                      Opts, std::decay_t<decltype(ctx)>>) {
 4374|       |                                                   if (!try_allocate_raw_pointer<Opts>(v, ctx)) {
 4375|       |                                                      return;
 4376|       |                                                   }
 4377|       |                                                }
 4378|       |                                                else {
 4379|       |                                                   ctx.error = error_code::invalid_nullable_read;
 4380|       |                                                   return;
 4381|       |                                                }
 4382|       |                                             }
 4383|       |                                             if constexpr (contains_tag<memory_type<V>, tag_literal>()) {
 4384|       |                                                // tag is a struct field, must re-parse
 4385|       |                                                if (!start.rewind(ctx, it, end)) return;
 4386|       |                                             }
 4387|       |                                             from<JSON, memory_type<V>>::template op<opening_handled<Opts>()>(*v, ctx,
 4388|       |                                                                                                              it, end);
 4389|       |                                          }
 4390|       |                                          else if constexpr (custom_read<V>) {
 4391|       |                                             // Custom handlers parse the remaining body themselves; this only
 4392|       |                                             // works when the tag was the first key (see above). If it came
 4393|       |                                             // later we were reset to the object start, so error rather than
 4394|       |                                             // let the custom handler absorb the tag.
 4395|       |                                             if (!first_key) {
 4396|       |                                                ctx.error = error_code::feature_not_supported;
 4397|       |                                                ctx.custom_error_message =
 4398|       |                                                   "the tag must be the first key for a custom variant alternative";
 4399|       |                                                return;
 4400|       |                                             }
 4401|       |                                             from<JSON, V>::template op<opening_handled<Opts>()>(v, ctx, it, end);
 4402|       |                                          }
 4403|       |                                       },
 4404|       |                                       value);
 4405|       |
 4406|       |                                    return;
 4407|       |                                 }
 4408|       |                                 else {
 4409|       |                                    ctx.error = error_code::no_matching_variant_type;
 4410|       |                                    ctx.custom_error_message = variant_ids_string_v<T>;
 4411|       |                                    return;
 4412|       |                                 }
 4413|       |                              }
 4414|       |                           }
 4415|       |                        }
 4416|       |
 4417|       |                        // Inline decode_hash lookup for variant deduction
 4418|       |                        using deduction_keys_t = keys_wrapper<variant_deduction_keys<T>>;
 4419|       |                        constexpr auto& DeductionHashInfo = hash_info<deduction_keys_t>;
 4420|       |                        const auto deduction_index =
 4421|       |                           decode_hash_with_size<JSON, deduction_keys_t, DeductionHashInfo, DeductionHashInfo.type>::op(
 4422|       |                              key.data(), key.data() + key.size(), key.size());
 4423|       |                        if (deduction_index < deduction_key_count && variant_deduction_keys<T>[deduction_index] == key)
 4424|       |                           [[likely]] {
 4425|       |                           possible_types &= deduction_bits[deduction_index];
 4426|       |                        }
 4427|       |                        else if constexpr (Opts.error_on_unknown_keys) {
 4428|       |                           ctx.error = error_code::unknown_key;
 4429|       |                           return;
 4430|       |                        }
 4431|       |                     }
 4432|       |                     else if constexpr (not tag_v<T>.empty()) {
 4433|       |                        // empty object case for variant, if there are no normal elements
 4434|       |                        if (key == tag_v<T>) {
 4435|       |                           if (parse_ws_colon<Opts>(ctx, it, end)) {
 4436|       |                              return;
 4437|       |                           }
 4438|       |
 4439|       |                           // The id is turned into an index below and never leaves this reader,
 4440|       |                           // so the view of the window it borrows cannot outlive that window.
 4441|       |                           std::string_view type_id{};
 4442|       |                           parse_transient_string_view<ws_handled<Opts>()>(type_id, ctx, it, end);
 4443|       |                           if (bool(ctx.error)) [[unlikely]]
 4444|       |                              return;
 4445|       |                           if (skip_ws<Opts>(ctx, it, end)) {
 4446|       |                              return;
 4447|       |                           }
 4448|       |
 4449|       |                           const auto type_index = variant_id_to_index<T>::op(
 4450|       |                              type_id.data(), type_id.data() + type_id.size(), type_id.size());
 4451|       |                           if (type_index < ids_v<T>.size()) [[likely]] {
 4452|       |                              if (!position_after_tag()) return;
 4453|       |                              tag_specified_index = type_index; // Store the tag-specified type
 4454|       |                              if (value.index() != type_index) emplace_runtime_variant(value, type_index);
 4455|       |                           }
 4456|       |                           else {
 4457|       |                              // Check if we have a default type (ids array shorter than variant)
 4458|       |                              constexpr auto ids_size = ids_v<T>.size();
 4459|       |                              constexpr auto variant_size = std::variant_size_v<T>;
 4460|       |                              if constexpr (ids_size < variant_size) {
 4461|       |                                 // Use the first unlabeled type as the default
 4462|       |                                 if (!position_after_tag()) return;
 4463|       |                                 const auto default_index = ids_size;
 4464|       |                                 tag_specified_index = default_index; // Store the default type index
 4465|       |                                 if (value.index() != default_index) emplace_runtime_variant(value, default_index);
 4466|       |                              }
 4467|       |                              else {
 4468|       |                                 ctx.error = error_code::no_matching_variant_type;
 4469|       |                                 ctx.custom_error_message = variant_ids_string_v<T>;
 4470|       |                                 return;
 4471|       |                              }
 4472|       |                           }
 4473|       |                           // Parse the type (handles tag skipping and unknown keys)
 4474|       |                           std::visit(
 4475|       |                              [&](auto&& v) {
 4476|       |                                 using V = std::decay_t<decltype(v)>;
 4477|       |                                 if constexpr (custom_read<V>) {
 4478|       |                                    // Custom handlers parse the remaining object body themselves and do not
 4479|       |                                    // accept the tag template parameter that reflected objects use to skip an
 4480|       |                                    // interior tag key. That only works when the tag is the first key (it was
 4481|       |                                    // just consumed). If the tag came after other keys, position_after_tag()
 4482|       |                                    // reset us to the object start and the custom handler would absorb the tag
 4483|       |                                    // into its value, so error here rather than corrupt the result.
 4484|       |                                    if (!first_key) {
 4485|       |                                       ctx.error = error_code::feature_not_supported;
 4486|       |                                       ctx.custom_error_message =
 4487|       |                                          "the tag must be the first key for a custom variant alternative";
 4488|       |                                       return;
 4489|       |                                    }
 4490|       |                                    from<JSON, V>::template op<opening_handled<Opts>()>(v, ctx, it, end);
 4491|       |                                 }
 4492|       |                                 else {
 4493|       |                                    if constexpr (contains_tag<V, tag_literal>()) {
 4494|       |                                       // tag is a struct field, must re-parse
 4495|       |                                       if (!start.rewind(ctx, it, end)) return;
 4496|       |                                    }
 4497|       |                                    from<JSON, V>::template op<opening_handled<Opts>(), tag_literal>(v, ctx, it, end);
 4498|       |                                 }
 4499|       |                              },
 4500|       |                              value);
 4501|       |                           return;
 4502|       |                        }
 4503|       |                        else if constexpr (Opts.error_on_unknown_keys) {
 4504|       |                           ctx.error = error_code::unknown_key;
 4505|       |                           return;
 4506|       |                        }
 4507|       |                        else {
 4508|       |                           // Skip unknown key's value (non-tag key in empty variant)
 4509|       |                           if (parse_ws_colon<Opts>(ctx, it, end)) {
 4510|       |                              return;
 4511|       |                           }
 4512|       |                           skip_value<JSON>::op<Opts>(ctx, it, end);
 4513|       |                           if (bool(ctx.error)) [[unlikely]]
 4514|       |                              return;
 4515|       |                           resync_window_end(ctx, end); // a streaming skip refills
 4516|       |                           if (skip_ws<Opts>(ctx, it, end)) {
 4517|       |                              return;
 4518|       |                           }
 4519|       |                           continue; // Continue loop to find the tag
 4520|       |                        }
 4521|       |                     }
 4522|       |                     else if constexpr (Opts.error_on_unknown_keys) {
 4523|       |                        ctx.error = error_code::unknown_key;
 4524|       |                        return;
 4525|       |                     }
 4526|       |
 4527|       |                     auto matching_types = possible_types.popcount();
 4528|       |                     if (matching_types == 0) {
 4529|       |                        ctx.error = error_code::no_matching_variant_type;
 4530|       |                        return;
 4531|       |                     }
 4532|       |                     // Only short-circuit for variants without tags
 4533|       |                     else if constexpr (tag_v<T>.empty()) {
 4534|       |                        if (matching_types == 1) {
 4535|       |                           if (!start.rewind(ctx, it, end)) return;
 4536|       |                           const auto type_index = possible_types.countr_zero();
 4537|       |
 4538|       |                           if (value.index() != static_cast<size_t>(type_index))
 4539|       |                              emplace_runtime_variant(value, type_index);
 4540|       |                           std::visit(
 4541|       |                              [&](auto&& v) {
 4542|       |                                 using V = std::decay_t<decltype(v)>;
 4543|       |                                 constexpr bool is_object = (glaze_object_t<V> || reflectable<V>) && not custom_read<V>;
 4544|       |                                 if constexpr (variant_unit_alternative<V>) {
 4545|       |                                    // A unit alternative carries no data; its object holds only the discriminator.
 4546|       |                                    // Consume that body through an empty reflected object so unknown-key policy and
 4547|       |                                    // terminator handling match every other alternative.
 4548|       |                                    detail::variant_unit_body unit_body{};
 4549|       |                                    from<JSON, detail::variant_unit_body>::template op<opening_handled<Opts>(),
 4550|       |                                                                                       tag_literal>(unit_body, ctx, it,
 4551|       |                                                                                                    end);
 4552|       |                                 }
 4553|       |                                 else if constexpr (is_object) {
 4554|       |                                    from<JSON, V>::template op<opening_handled<Opts>(), tag_literal>(v, ctx, it, end);
 4555|       |                                 }
 4556|       |                                 else if constexpr (is_memory_object<V>) {
 4557|       |                                    if (!v) {
 4558|       |                                       if constexpr (is_specialization_v<V, std::optional>) {
 4559|       |                                          if constexpr (requires { v.emplace(); }) {
 4560|       |                                             v.emplace();
 4561|       |                                          }
 4562|       |                                          else {
 4563|       |                                             v = typename V::value_type{};
 4564|       |                                          }
 4565|       |                                       }
 4566|       |                                       else if constexpr (is_specialization_v<V, std::unique_ptr>)
 4567|       |                                          v = std::make_unique<typename V::element_type>();
 4568|       |                                       else if constexpr (is_specialization_v<V, std::shared_ptr>)
 4569|       |                                          v = std::make_shared<typename V::element_type>();
 4570|       |                                       else if constexpr (constructible<V>) {
 4571|       |                                          v = meta_construct_v<V>();
 4572|       |                                       }
 4573|       |                                       else if constexpr (std::is_pointer_v<V> &&
 4574|       |                                                          can_allocate_raw_pointer<Opts, std::decay_t<decltype(ctx)>>) {
 4575|       |                                          if (!try_allocate_raw_pointer<Opts>(v, ctx)) {
 4576|       |                                             return;
 4577|       |                                          }
 4578|       |                                       }
 4579|       |                                       else {
 4580|       |                                          ctx.error = error_code::invalid_nullable_read;
 4581|       |                                          return;
 4582|       |                                          // Cannot read into unset nullable that is not std::optional,
 4583|       |                                          // std::unique_ptr, or std::shared_ptr
 4584|       |                                       }
 4585|       |                                    }
 4586|       |                                    from<JSON, memory_type<V>>::template op<opening_handled<Opts>(), tag_literal>(
 4587|       |                                       *v, ctx, it, end);
 4588|       |                                 }
 4589|       |                                 else if constexpr (custom_read<V>) {
 4590|       |                                    // Custom handlers parse the remaining body themselves.
 4591|       |                                    from<JSON, V>::template op<opening_handled<Opts>()>(v, ctx, it, end);
 4592|       |                                 }
 4593|       |                              },
 4594|       |                              value);
 4595|       |
 4596|       |                           return; // we've decoded our target type
 4597|       |                        }
 4598|       |                     }
 4599|       |                     // For tagged variants, continue processing to validate tags
 4600|       |                     if (parse_ws_colon<Opts>(ctx, it, end)) {
 4601|       |                        return;
 4602|       |                     }
 4603|       |
 4604|       |                     skip_value<JSON>::op<Opts>(ctx, it, end);
 4605|       |                     if (bool(ctx.error)) [[unlikely]]
 4606|       |                        return;
 4607|       |                     resync_window_end(ctx, end); // a streaming skip refills
 4608|       |                     if (skip_ws<Opts>(ctx, it, end)) {
 4609|       |                        return;
 4610|       |                     }
 4611|       |                  }
 4612|       |                  // Only apply ambiguous variant resolution if we have multiple object types
 4613|       |                  if constexpr ((type_counts::n_object + type_counts::n_nullable_object) > 1) {
 4614|       |                     // After parsing all keys, check if we have multiple matching types
 4615|       |                     // If so, choose the one with the fewest fields
 4616|       |                     auto final_matching = possible_types.popcount();
 4617|       |                     if (final_matching == 0) {
 4618|       |                        ctx.error = error_code::no_matching_variant_type;
 4619|       |                     }
 4620|       |                     else if (final_matching == 1) {
 4621|       |                        // Single type remains after field deduction
 4622|       |                        const auto type_index = possible_types.countr_zero();
 4623|       |
 4624|       |                        // Validate against tag if one was specified
 4625|       |                        if (tag_specified_index.has_value() &&
 4626|       |                            tag_specified_index.value() != static_cast<size_t>(type_index)) {
 4627|       |                           ctx.error = error_code::no_matching_variant_type;
 4628|       |                           return;
 4629|       |                        }
 4630|       |
 4631|       |                        if (!start.rewind(ctx, it, end)) return;
 4632|       |                        if (value.index() != static_cast<size_t>(type_index))
 4633|       |                           emplace_runtime_variant(value, type_index);
 4634|       |                        std::visit(
 4635|       |                           [&](auto&& v) {
 4636|       |                              using V = std::decay_t<decltype(v)>;
 4637|       |                              constexpr bool is_object = (glaze_object_t<V> || reflectable<V>) && not custom_read<V>;
 4638|       |                              if constexpr (variant_unit_alternative<V>) {
 4639|       |                                 // A unit alternative carries no data; its object holds only the discriminator.
 4640|       |                                 // Consume that body through an empty reflected object so unknown-key policy and
 4641|       |                                 // terminator handling match every other alternative.
 4642|       |                                 detail::variant_unit_body unit_body{};
 4643|       |                                 from<JSON, detail::variant_unit_body>::template op<opening_handled<Opts>(),
 4644|       |                                                                                    tag_literal>(unit_body, ctx, it,
 4645|       |                                                                                                 end);
 4646|       |                              }
 4647|       |                              else if constexpr (is_object) {
 4648|       |                                 from<JSON, V>::template op<opening_handled<Opts>(), tag_literal>(v, ctx, it, end);
 4649|       |                              }
 4650|       |                              else if constexpr (is_memory_object<V>) {
 4651|       |                                 if (!v) {
 4652|       |                                    if constexpr (is_specialization_v<V, std::optional>) {
 4653|       |                                       if constexpr (requires { v.emplace(); }) {
 4654|       |                                          v.emplace();
 4655|       |                                       }
 4656|       |                                       else {
 4657|       |                                          v = typename V::value_type{};
 4658|       |                                       }
 4659|       |                                    }
 4660|       |                                    else if constexpr (is_specialization_v<V, std::unique_ptr>)
 4661|       |                                       v = std::make_unique<typename V::element_type>();
 4662|       |                                    else if constexpr (is_specialization_v<V, std::shared_ptr>)
 4663|       |                                       v = std::make_shared<typename V::element_type>();
 4664|       |                                    else if constexpr (constructible<V>) {
 4665|       |                                       v = meta_construct_v<V>();
 4666|       |                                    }
 4667|       |                                    else if constexpr (std::is_pointer_v<V> &&
 4668|       |                                                       can_allocate_raw_pointer<Opts, std::decay_t<decltype(ctx)>>) {
 4669|       |                                       if (!try_allocate_raw_pointer<Opts>(v, ctx)) {
 4670|       |                                          return;
 4671|       |                                       }
 4672|       |                                    }
 4673|       |                                    else {
 4674|       |                                       ctx.error = error_code::invalid_nullable_read;
 4675|       |                                       return;
 4676|       |                                    }
 4677|       |                                 }
 4678|       |                                 from<JSON, memory_type<V>>::template op<opening_handled<Opts>(), tag_literal>(*v, ctx,
 4679|       |                                                                                                               it, end);
 4680|       |                              }
 4681|       |                              else if constexpr (custom_read<V>) {
 4682|       |                                 // Custom handlers parse the remaining body themselves.
 4683|       |                                 from<JSON, V>::template op<opening_handled<Opts>()>(v, ctx, it, end);
 4684|       |                              }
 4685|       |                           },
 4686|       |                           value);
 4687|       |                     }
 4688|       |                     else if (final_matching > 1) {
 4689|       |                        constexpr auto N = std::variant_size_v<T>;
 4690|       |
 4691|       |                        // Compile-time array of field counts for each variant type
 4692|       |                        constexpr auto field_counts = []<size_t... I>(std::index_sequence<I...>) {
 4693|       |                           return std::array<size_t, N> {
 4694|       |                              ([]<size_t J = I>() -> size_t {
 4695|       |                                 using V = std::decay_t<std::variant_alternative_t<J, T>>;
 4696|       |                                 if constexpr (glaze_object_t<V> || reflectable<V>) {
 4697|       |                                    return reflect<V>::size;
 4698|       |                                 }
 4699|       |                                 else if constexpr (is_memory_object<V>) {
 4700|       |                                    using X = memory_type<V>;
 4701|       |                                    if constexpr (glaze_object_t<X> || reflectable<X>) {
 4702|       |                                       return reflect<X>::size;
 4703|       |                                    }
 4704|       |                                    else {
 4705|       |                                       return (std::numeric_limits<size_t>::max)();
 4706|       |                                    }
 4707|       |                                 }
 4708|       |                                 else {
 4709|       |                                    return (std::numeric_limits<size_t>::max)();
 4710|       |                                 }
 4711|       |                              }.template operator()<I>())...
 4712|       |                           };
 4713|       |                        }(std::make_index_sequence<N>{});
 4714|       |
 4715|       |                        // Find the type with minimum field count among the possible types
 4716|       |                        size_t min_fields = (std::numeric_limits<size_t>::max)();
 4717|       |                        size_t chosen_index = N; // Invalid index initially
 4718|       |
 4719|       |                        for (size_t i = 0; i < N; ++i) {
 4720|       |                           if (possible_types[i] && field_counts[i] < min_fields) {
 4721|       |                              min_fields = field_counts[i];
 4722|       |                              chosen_index = i;
 4723|       |                           }
 4724|       |                        }
 4725|       |
 4726|       |                        if (chosen_index < N) {
 4727|       |                           // Validate against tag if one was specified
 4728|       |                           if (tag_specified_index.has_value() && tag_specified_index.value() != chosen_index) {
 4729|       |                              ctx.error = error_code::no_matching_variant_type;
 4730|       |                              return;
 4731|       |                           }
 4732|       |
 4733|       |                           if (!start.rewind(ctx, it, end)) return;
 4734|       |                           if (value.index() != chosen_index) emplace_runtime_variant(value, chosen_index);
 4735|       |                           std::visit(
 4736|       |                              [&](auto&& v) {
 4737|       |                                 using V = std::decay_t<decltype(v)>;
 4738|       |                                 constexpr bool is_object = (glaze_object_t<V> || reflectable<V>) && not custom_read<V>;
 4739|       |                                 if constexpr (variant_unit_alternative<V>) {
 4740|       |                                    // A unit alternative carries no data; its object holds only the discriminator.
 4741|       |                                    // Consume that body through an empty reflected object so unknown-key policy and
 4742|       |                                    // terminator handling match every other alternative.
 4743|       |                                    detail::variant_unit_body unit_body{};
 4744|       |                                    from<JSON, detail::variant_unit_body>::template op<opening_handled<Opts>(),
 4745|       |                                                                                       tag_literal>(unit_body, ctx, it,
 4746|       |                                                                                                    end);
 4747|       |                                 }
 4748|       |                                 else if constexpr (is_object) {
 4749|       |                                    from<JSON, V>::template op<opening_handled<Opts>(), tag_literal>(v, ctx, it, end);
 4750|       |                                 }
 4751|       |                                 else if constexpr (is_memory_object<V>) {
 4752|       |                                    if (!v) {
 4753|       |                                       if constexpr (is_specialization_v<V, std::optional>) {
 4754|       |                                          if constexpr (requires { v.emplace(); }) {
 4755|       |                                             v.emplace();
 4756|       |                                          }
 4757|       |                                          else {
 4758|       |                                             v = typename V::value_type{};
 4759|       |                                          }
 4760|       |                                       }
 4761|       |                                       else if constexpr (is_specialization_v<V, std::unique_ptr>)
 4762|       |                                          v = std::make_unique<typename V::element_type>();
 4763|       |                                       else if constexpr (is_specialization_v<V, std::shared_ptr>)
 4764|       |                                          v = std::make_shared<typename V::element_type>();
 4765|       |                                       else if constexpr (constructible<V>) {
 4766|       |                                          v = meta_construct_v<V>();
 4767|       |                                       }
 4768|       |                                       else if constexpr (std::is_pointer_v<V> &&
 4769|       |                                                          can_allocate_raw_pointer<Opts, std::decay_t<decltype(ctx)>>) {
 4770|       |                                          if (!try_allocate_raw_pointer<Opts>(v, ctx)) {
 4771|       |                                             return;
 4772|       |                                          }
 4773|       |                                       }
 4774|       |                                       else {
 4775|       |                                          ctx.error = error_code::invalid_nullable_read;
 4776|       |                                          return;
 4777|       |                                       }
 4778|       |                                    }
 4779|       |                                    from<JSON, memory_type<V>>::template op<opening_handled<Opts>(), tag_literal>(
 4780|       |                                       *v, ctx, it, end);
 4781|       |                                 }
 4782|       |                                 else if constexpr (custom_read<V>) {
 4783|       |                                    // Custom handlers parse the remaining body themselves.
 4784|       |                                    from<JSON, V>::template op<opening_handled<Opts>()>(v, ctx, it, end);
 4785|       |                                 }
 4786|       |                              },
 4787|       |                              value);
 4788|       |                        }
 4789|       |                        else {
 4790|       |                           ctx.error = error_code::no_matching_variant_type;
 4791|       |                        }
 4792|       |                     }
 4793|       |                  }
 4794|       |                  else {
 4795|       |                     // For variants with 0 or 1 object types, use the original error handling
 4796|       |                     ctx.error = error_code::no_matching_variant_type;
 4797|       |                  }
 4798|       |               }
 4799|      0|               break;
 4800|    237|            }
 4801|     14|            case '[':
  ------------------
  |  Branch (4801:13): [True: 14, False: 1.08k]
  ------------------
 4802|       |               // As with '{' above: the array reader each alternative goes through counts the level.
 4803|     14|               process_variant_alternatives<T, is_variant_array>::template op<Opts>(value, ctx, it, end);
 4804|     14|               break;
 4805|    641|            case '"': {
  ------------------
  |  Branch (4805:13): [True: 641, False: 454]
  ------------------
 4806|    641|               process_variant_alternatives<T, is_variant_str>::template op<Opts>(value, ctx, it, end);
 4807|    641|               break;
 4808|    237|            }
 4809|      3|            case 't':
  ------------------
  |  Branch (4809:13): [True: 3, False: 1.09k]
  ------------------
 4810|      6|            case 'f': {
  ------------------
  |  Branch (4810:13): [True: 3, False: 1.09k]
  ------------------
 4811|      6|               process_variant_alternatives<T, is_variant_bool>::template op<Opts>(value, ctx, it, end);
 4812|      6|               break;
 4813|      3|            }
 4814|      0|            case 'n':
  ------------------
  |  Branch (4814:13): [True: 0, False: 1.09k]
  ------------------
 4815|      0|               if constexpr (variant_count_v<T, is_variant_null> == 0) {
 4816|      0|                  ctx.error = error_code::no_matching_variant_type;
 4817|       |               }
 4818|       |               else {
 4819|       |                  constexpr auto first_idx = variant_first_index_v<T, is_variant_null>;
 4820|       |                  using V = std::variant_alternative_t<first_idx, T>;
 4821|       |                  if (!std::holds_alternative<V>(value)) value = V{};
 4822|       |                  match<"null", Opts>(ctx, it, end);
 4823|       |               }
 4824|      0|               break;
 4825|    197|            default: {
  ------------------
  |  Branch (4825:13): [True: 197, False: 898]
  ------------------
 4826|       |               // Not bool, string, object, or array so must be number or null
 4827|    197|               process_variant_alternatives<T, is_variant_num>::template op<Opts>(value, ctx, it, end);
 4828|    197|            }
 4829|  1.09k|            }
 4830|       |         }
 4831|       |         else {
 4832|       |            // For non-auto-deducible variants, try each type until one succeeds
 4833|       |            constexpr auto N = std::variant_size_v<T>;
 4834|       |            bool parsed = false;
 4835|       |            bool exhausted = false; // speculation budget spent; see charge_speculation
 4836|       |
 4837|       |            for_each<N>([&]<size_t I>() {
 4838|       |               if (parsed || exhausted || variant_alternative_exhausted(ctx)) return;
 4839|       |
 4840|       |               auto copy_it = it;
 4841|       |               // A rejected alternative may have bailed out inside a container, which leaves its
 4842|       |               // nesting level counted (see enter_depth), so the depth rewinds with the iterator.
 4843|       |               const auto copy_depth = ctx.depth;
 4844|       |
 4845|       |               // Try parsing as this type
 4846|       |               if (value.index() != I) {
 4847|       |                  emplace_runtime_variant(value, I);
 4848|       |               }
 4849|       |
 4850|       |               std::visit([&](auto&& v) { parse<JSON>::op<Options>(v, ctx, it, end); }, value);
 4851|       |               if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) {
 4852|       |                  exhausted = true; // only rejected attempts are charged; see charge_speculation
 4853|       |               }
 4854|       |
 4855|       |               if (!bool(ctx.error)) {
 4856|       |                  parsed = true;
 4857|       |               }
 4858|       |               else if constexpr (not Options.null_terminated) {
 4859|       |                  // In non-null-terminated mode, if we hit end_reached after advancing the iterator,
 4860|       |                  // it means we successfully parsed the value but couldn't skip trailing whitespace
 4861|       |                  if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) {
 4862|       |                     // We advanced the iterator, so we did parse something -- unless what advanced it
 4863|       |                     // was an abandoned attempt, which is what a spent speculation budget means.
 4864|       |                     parsed = true;
 4865|       |                     ctx.error = error_code::none;
 4866|       |                  }
 4867|       |                  else {
 4868|       |                     // Reset for next attempt (unless this is the last type)
 4869|       |                     it = copy_it;
 4870|       |                     rewind_depth<Options>(ctx, copy_depth);
 4871|       |                     if constexpr (I + 1 < N) {
 4872|       |                        if (not exhausted && not variant_alternative_exhausted(ctx)) {
 4873|       |                           ctx.error = error_code::none; // Clear error for next attempt
 4874|       |                        }
 4875|       |                     }
 4876|       |                  }
 4877|       |               }
 4878|       |               else {
 4879|       |                  // Reset for next attempt (unless this is the last type)
 4880|       |                  it = copy_it;
 4881|       |                  rewind_depth<Options>(ctx, copy_depth);
 4882|       |                  if constexpr (I + 1 < N) {
 4883|       |                     if (not exhausted && not variant_alternative_exhausted(ctx)) {
 4884|       |                        ctx.error = error_code::none; // Clear error for next attempt
 4885|       |                     }
 4886|       |                  }
 4887|       |               }
 4888|       |            });
 4889|       |         }
 4890|  1.09k|      }
_ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__16vectorIdNS4_9allocatorIdEEEETkNS_10is_contextERNS_7contextERPKcSD_EEvOT0_OT1_OT2_T3_:
   49|  3.87k|      {
   50|       |         if constexpr (const_value_v<T>) {
   51|       |            if constexpr (check_error_on_const_read(Opts)) {
   52|       |               ctx.error = error_code::attempt_const_read;
   53|       |            }
   54|       |            else {
   55|       |               // do not read anything into the const value
   56|       |               skip_value<JSON>::op<Opts>(std::forward<Ctx>(ctx), std::forward<It0>(it), end);
   57|       |            }
   58|       |         }
   59|  3.87k|         else {
   60|  3.87k|            using V = std::remove_cvref_t<T>;
   61|  3.87k|            from<JSON, V>::template op<Opts>(std::forward<T>(value), std::forward<Ctx>(ctx), std::forward<It0>(it),
   62|  3.87k|                                             end);
   63|  3.87k|         }
   64|  3.87k|      }
_ZN3glz4fromILj10ENSt3__16vectorIdNS1_9allocatorIdEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS5_TkNS_10is_contextERNS_7contextERPKcSD_EEvOT0_OT1_OT2_T3_:
 2308|  3.87k|      {
 2309|  3.87k|         constexpr auto Opts = ws_handled_off<Options>();
 2310|  3.87k|         if constexpr (!check_ws_handled(Options)) {
 2311|  3.87k|            if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (2311:17): [True: 0, False: 3.87k]
  ------------------
 2312|      0|               return;
 2313|      0|            }
 2314|  3.87k|         }
 2315|       |
 2316|  3.87k|         if (match_invalid_end<'[', Opts>(ctx, it, end)) {
  ------------------
  |  Branch (2316:14): [True: 117, False: 3.75k]
  ------------------
 2317|    117|            return;
 2318|    117|         }
 2319|       |         // one nesting level (see enter_depth): counted in both modes so the limit binds,
 2320|       |         // released at each syntactic close below
 2321|  3.75k|         if (enter_depth(ctx)) [[unlikely]] {
  ------------------
  |  Branch (2321:14): [True: 0, False: 3.75k]
  ------------------
 2322|      0|            return;
 2323|      0|         }
 2324|       |
 2325|  3.75k|         const auto ws_start = it;
 2326|  3.75k|         if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (2326:14): [True: 0, False: 3.75k]
  ------------------
 2327|      0|            return;
 2328|      0|         }
 2329|       |
 2330|  3.75k|         if (*it == ']') {
  ------------------
  |  Branch (2330:14): [True: 24, False: 3.73k]
  ------------------
 2331|     24|            --ctx.depth;
 2332|     24|            ++it;
 2333|     24|            if constexpr ((resizable<T> || is_inplace_vector<T>) && not check_append_arrays(Opts)) {
 2334|     24|               value.clear();
 2335|       |
 2336|       |               if constexpr (check_shrink_to_fit(Opts) && has_shrink_to_fit<T>) {
 2337|       |                  value.shrink_to_fit();
 2338|       |               }
 2339|     24|            }
 2340|     24|            return;
 2341|     24|         }
 2342|       |
 2343|  3.73k|         const size_t ws_size = size_t(it - ws_start);
 2344|       |
 2345|  3.73k|         static constexpr bool should_append = (resizable<T> || is_inplace_vector<T>) && check_append_arrays(Opts);
  ------------------
  |  Branch (2345:49): [True: 3.73k, Folded]
  |  Branch (2345:65): [Folded, False: 0]
  |  Branch (2345:90): [Folded, False: 0]
  ------------------
 2346|  3.73k|         if constexpr (not should_append) {
 2347|  3.73k|            const auto n = value.size();
 2348|       |
 2349|  3.73k|            auto value_it = value.begin();
 2350|       |
 2351|  3.73k|            for (size_t i = 0; i < n; ++i) {
  ------------------
  |  Branch (2351:32): [True: 0, False: 3.73k]
  ------------------
 2352|      0|               parse<JSON>::op<ws_handled<Opts>()>(*value_it++, ctx, it, end);
 2353|      0|               if (bool(ctx.error)) [[unlikely]]
  ------------------
  |  Branch (2353:20): [True: 0, False: 0]
  ------------------
 2354|      0|                  return;
 2355|      0|               if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (2355:20): [True: 0, False: 0]
  ------------------
 2356|      0|                  return;
 2357|      0|               }
 2358|      0|               if (*it == ',') {
  ------------------
  |  Branch (2358:20): [True: 0, False: 0]
  ------------------
 2359|      0|                  ++it;
 2360|       |
 2361|      0|                  if constexpr (!Opts.minified && !Opts.comments) {
 2362|      0|                     if (ws_size && ws_size < size_t(end - it)) {
  ------------------
  |  Branch (2362:26): [True: 0, False: 0]
  |  Branch (2362:37): [True: 0, False: 0]
  ------------------
 2363|      0|                        skip_matching_ws(ws_start, it, ws_size);
 2364|      0|                     }
 2365|      0|                  }
 2366|       |
 2367|      0|                  if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (2367:23): [True: 0, False: 0]
  ------------------
 2368|      0|                     return;
 2369|      0|                  }
 2370|      0|               }
 2371|      0|               else if (*it == ']') {
  ------------------
  |  Branch (2371:25): [True: 0, False: 0]
  ------------------
 2372|      0|                  --ctx.depth;
 2373|      0|                  ++it;
 2374|      0|                  if constexpr (erasable<T>) {
 2375|      0|                     value.erase(value_it,
 2376|      0|                                 value.end()); // use erase rather than resize for non-default constructible elements
 2377|       |
 2378|       |                     if constexpr (check_shrink_to_fit(Opts) && has_shrink_to_fit<T>) {
 2379|       |                        value.shrink_to_fit();
 2380|       |                     }
 2381|      0|                  }
 2382|      0|                  return;
 2383|      0|               }
 2384|      0|               else [[unlikely]] {
 2385|      0|                  ctx.error = error_code::expected_bracket;
 2386|      0|                  return;
 2387|      0|               }
 2388|      0|            }
 2389|  3.73k|         }
 2390|       |
 2391|       |         if constexpr (Opts.partial_read) {
 2392|       |            // partial_read stops early on a success path, so give the level back like the
 2393|       |            // syntactic-close paths do; otherwise it accumulates across reads sharing a context.
 2394|       |            --ctx.depth;
 2395|       |            return;
 2396|       |         }
 2397|  3.73k|         else {
 2398|       |            // growing
 2399|  3.73k|            if constexpr (emplace_backable<T> || has_try_emplace_back<T>) {
 2400|   633k|               while (it < end) {
  ------------------
  |  Branch (2400:23): [True: 633k, False: 0]
  ------------------
 2401|       |                  // Streaming refill point: at start of each iteration, ensure buffer has data
 2402|       |                  if constexpr (has_streaming_state<decltype(ctx)>) {
 2403|       |                     if (ctx.stream.enabled()) {
 2404|       |                        const size_t consumed = static_cast<size_t>(it - ctx.stream.data());
 2405|       |                        const size_t remaining = ctx.stream.size() - consumed;
 2406|       |                        // Refill when less than half of buffer remains to ensure space for next element
 2407|       |                        if (remaining <= ctx.stream.size() / 2 || it >= end) {
 2408|       |                           const char* new_it;
 2409|       |                           const char* new_end;
 2410|       |                           ctx.stream.consume_and_refill(consumed, new_it, new_end);
 2411|       |                           it = new_it;
 2412|       |                           end = new_end;
 2413|       |                           if (it >= end && ctx.stream.at_eof()) {
 2414|       |                              break; // No more data, exit loop normally
 2415|       |                           }
 2416|       |                        }
 2417|       |                     }
 2418|       |                  }
 2419|       |
 2420|       |                  if constexpr (has_try_emplace_back<T>) {
 2421|       |                     if (value.try_emplace_back())
 2422|       |                        parse<JSON>::op<ws_handled<Opts>()>(value.back(), ctx, it, end);
 2423|       |                     else
 2424|       |                        ctx.error = error_code::exceeded_static_array_size;
 2425|       |                  }
 2426|   633k|                  else {
 2427|   633k|                     parse<JSON>::op<ws_handled<Opts>()>(value.emplace_back(), ctx, it, end);
 2428|   633k|                  }
 2429|       |
 2430|   633k|                  if (bool(ctx.error)) [[unlikely]]
  ------------------
  |  Branch (2430:23): [True: 1.05k, False: 632k]
  ------------------
 2431|  1.05k|                     return;
 2432|       |
 2433|       |                  // Streaming refill point: after parsing each element, refill if buffer is low
 2434|       |                  if constexpr (has_streaming_state<decltype(ctx)>) {
 2435|       |                     if (ctx.stream.enabled()) {
 2436|       |                        const size_t consumed = static_cast<size_t>(it - ctx.stream.data());
 2437|       |                        // Refill when less than 25% of buffer remains to ensure enough space for next element
 2438|       |                        if (ctx.stream.size() - consumed <= ctx.stream.size() / 4 || it >= end) {
 2439|       |                           const char* new_it;
 2440|       |                           const char* new_end;
 2441|       |                           ctx.stream.consume_and_refill(consumed, new_it, new_end);
 2442|       |                           it = new_it;
 2443|       |                           end = new_end;
 2444|       |                           if (it >= end && ctx.stream.at_eof()) {
 2445|       |                              ctx.error = error_code::unexpected_end;
 2446|       |                              return;
 2447|       |                           }
 2448|       |                        }
 2449|       |                     }
 2450|       |                  }
 2451|       |
 2452|   632k|                  if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (2452:23): [True: 0, False: 632k]
  ------------------
 2453|      0|                     return;
 2454|      0|                  }
 2455|   632k|                  if (*it == ',') [[likely]] {
  ------------------
  |  Branch (2455:23): [True: 629k, False: 2.68k]
  ------------------
 2456|   629k|                     ++it;
 2457|       |
 2458|   629k|                     if constexpr (!Opts.minified && !Opts.comments) {
 2459|   629k|                        if (ws_size && ws_size < size_t(end - it)) {
  ------------------
  |  Branch (2459:29): [True: 13.2k, False: 616k]
  |  Branch (2459:40): [True: 12.8k, False: 314]
  ------------------
 2460|  12.8k|                           skip_matching_ws(ws_start, it, ws_size);
 2461|  12.8k|                        }
 2462|   629k|                     }
 2463|       |
 2464|   629k|                     if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (2464:26): [True: 0, False: 629k]
  ------------------
 2465|      0|                        return;
 2466|      0|                     }
 2467|   629k|                  }
 2468|  2.68k|                  else if (*it == ']') {
  ------------------
  |  Branch (2468:28): [True: 1.72k, False: 961]
  ------------------
 2469|  1.72k|                     --ctx.depth;
 2470|  1.72k|                     ++it;
 2471|       |                     if constexpr (check_shrink_to_fit(Opts) && has_shrink_to_fit<T>) {
 2472|       |                        value.shrink_to_fit();
 2473|       |                     }
 2474|  1.72k|                     return;
 2475|  1.72k|                  }
 2476|    961|                  else [[unlikely]] {
 2477|    961|                     ctx.error = error_code::expected_bracket;
 2478|    961|                     return;
 2479|    961|                  }
 2480|   632k|               }
 2481|       |
 2482|       |               // A valid array always returns from inside the loop upon reaching ']'.
 2483|       |               // For a null-terminated buffer the loop can only exit here by falling
 2484|       |               // through when `it` reaches the terminator without a closing bracket,
 2485|       |               // which means the input was truncated (e.g. "[", "[1," or "[1,2,").
 2486|       |               // Non-null-terminated buffers surface this through skip_ws/depth
 2487|       |               // tracking (or the streaming refill break), so this guard is limited
 2488|       |               // to the null-terminated case.
 2489|       |               if constexpr (Opts.null_terminated) {
 2490|       |                  ctx.error = error_code::unexpected_end;
 2491|       |               }
 2492|       |            }
 2493|       |            else {
 2494|       |               ctx.error = error_code::exceeded_static_array_size;
 2495|       |            }
 2496|  3.73k|         }
 2497|  3.73k|      }
_ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEERdTkNS_10is_contextERNS_7contextERPKcS8_EEvOT0_OT1_OT2_T3_:
   49|   902k|      {
   50|       |         if constexpr (const_value_v<T>) {
   51|       |            if constexpr (check_error_on_const_read(Opts)) {
   52|       |               ctx.error = error_code::attempt_const_read;
   53|       |            }
   54|       |            else {
   55|       |               // do not read anything into the const value
   56|       |               skip_value<JSON>::op<Opts>(std::forward<Ctx>(ctx), std::forward<It0>(it), end);
   57|       |            }
   58|       |         }
   59|   902k|         else {
   60|   902k|            using V = std::remove_cvref_t<T>;
   61|   902k|            from<JSON, V>::template op<Opts>(std::forward<T>(value), std::forward<Ctx>(ctx), std::forward<It0>(it),
   62|   902k|                                             end);
   63|   902k|         }
   64|   902k|      }
_ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__16vectorINS_14basic_raw_jsonINS4_17basic_string_viewIcNS4_11char_traitsIcEEEEEENS4_9allocatorISB_EEEETkNS_10is_contextERNS_7contextERPKcSJ_EEvOT0_OT1_OT2_T3_:
   49|  23.4k|      {
   50|       |         if constexpr (const_value_v<T>) {
   51|       |            if constexpr (check_error_on_const_read(Opts)) {
   52|       |               ctx.error = error_code::attempt_const_read;
   53|       |            }
   54|       |            else {
   55|       |               // do not read anything into the const value
   56|       |               skip_value<JSON>::op<Opts>(std::forward<Ctx>(ctx), std::forward<It0>(it), end);
   57|       |            }
   58|       |         }
   59|  23.4k|         else {
   60|  23.4k|            using V = std::remove_cvref_t<T>;
   61|  23.4k|            from<JSON, V>::template op<Opts>(std::forward<T>(value), std::forward<Ctx>(ctx), std::forward<It0>(it),
   62|  23.4k|                                             end);
   63|  23.4k|         }
   64|  23.4k|      }
_ZN3glz4fromILj10ENSt3__16vectorINS_14basic_raw_jsonINS1_17basic_string_viewIcNS1_11char_traitsIcEEEEEENS1_9allocatorIS8_EEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSB_TkNS_10is_contextERNS_7contextERPKcSJ_EEvOT0_OT1_OT2_T3_:
 2308|  23.4k|      {
 2309|  23.4k|         constexpr auto Opts = ws_handled_off<Options>();
 2310|  23.4k|         if constexpr (!check_ws_handled(Options)) {
 2311|  23.4k|            if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (2311:17): [True: 0, False: 23.4k]
  ------------------
 2312|      0|               return;
 2313|      0|            }
 2314|  23.4k|         }
 2315|       |
 2316|  23.4k|         if (match_invalid_end<'[', Opts>(ctx, it, end)) {
  ------------------
  |  Branch (2316:14): [True: 21, False: 23.4k]
  ------------------
 2317|     21|            return;
 2318|     21|         }
 2319|       |         // one nesting level (see enter_depth): counted in both modes so the limit binds,
 2320|       |         // released at each syntactic close below
 2321|  23.4k|         if (enter_depth(ctx)) [[unlikely]] {
  ------------------
  |  Branch (2321:14): [True: 0, False: 23.4k]
  ------------------
 2322|      0|            return;
 2323|      0|         }
 2324|       |
 2325|  23.4k|         const auto ws_start = it;
 2326|  23.4k|         if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (2326:14): [True: 14, False: 23.4k]
  ------------------
 2327|     14|            return;
 2328|     14|         }
 2329|       |
 2330|  23.4k|         if (*it == ']') {
  ------------------
  |  Branch (2330:14): [True: 11, False: 23.3k]
  ------------------
 2331|     11|            --ctx.depth;
 2332|     11|            ++it;
 2333|     11|            if constexpr ((resizable<T> || is_inplace_vector<T>) && not check_append_arrays(Opts)) {
 2334|     11|               value.clear();
 2335|       |
 2336|       |               if constexpr (check_shrink_to_fit(Opts) && has_shrink_to_fit<T>) {
 2337|       |                  value.shrink_to_fit();
 2338|       |               }
 2339|     11|            }
 2340|     11|            return;
 2341|     11|         }
 2342|       |
 2343|  23.3k|         const size_t ws_size = size_t(it - ws_start);
 2344|       |
 2345|  23.3k|         static constexpr bool should_append = (resizable<T> || is_inplace_vector<T>) && check_append_arrays(Opts);
  ------------------
  |  Branch (2345:49): [True: 23.3k, Folded]
  |  Branch (2345:65): [Folded, False: 0]
  |  Branch (2345:90): [Folded, False: 0]
  ------------------
 2346|  23.3k|         if constexpr (not should_append) {
 2347|  23.3k|            const auto n = value.size();
 2348|       |
 2349|  23.3k|            auto value_it = value.begin();
 2350|       |
 2351|  23.3k|            for (size_t i = 0; i < n; ++i) {
  ------------------
  |  Branch (2351:32): [True: 0, False: 23.3k]
  ------------------
 2352|      0|               parse<JSON>::op<ws_handled<Opts>()>(*value_it++, ctx, it, end);
 2353|      0|               if (bool(ctx.error)) [[unlikely]]
  ------------------
  |  Branch (2353:20): [True: 0, False: 0]
  ------------------
 2354|      0|                  return;
 2355|      0|               if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (2355:20): [True: 0, False: 0]
  ------------------
 2356|      0|                  return;
 2357|      0|               }
 2358|      0|               if (*it == ',') {
  ------------------
  |  Branch (2358:20): [True: 0, False: 0]
  ------------------
 2359|      0|                  ++it;
 2360|       |
 2361|      0|                  if constexpr (!Opts.minified && !Opts.comments) {
 2362|      0|                     if (ws_size && ws_size < size_t(end - it)) {
  ------------------
  |  Branch (2362:26): [True: 0, False: 0]
  |  Branch (2362:37): [True: 0, False: 0]
  ------------------
 2363|      0|                        skip_matching_ws(ws_start, it, ws_size);
 2364|      0|                     }
 2365|      0|                  }
 2366|       |
 2367|      0|                  if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (2367:23): [True: 0, False: 0]
  ------------------
 2368|      0|                     return;
 2369|      0|                  }
 2370|      0|               }
 2371|      0|               else if (*it == ']') {
  ------------------
  |  Branch (2371:25): [True: 0, False: 0]
  ------------------
 2372|      0|                  --ctx.depth;
 2373|      0|                  ++it;
 2374|      0|                  if constexpr (erasable<T>) {
 2375|      0|                     value.erase(value_it,
 2376|      0|                                 value.end()); // use erase rather than resize for non-default constructible elements
 2377|       |
 2378|       |                     if constexpr (check_shrink_to_fit(Opts) && has_shrink_to_fit<T>) {
 2379|       |                        value.shrink_to_fit();
 2380|       |                     }
 2381|      0|                  }
 2382|      0|                  return;
 2383|      0|               }
 2384|      0|               else [[unlikely]] {
 2385|      0|                  ctx.error = error_code::expected_bracket;
 2386|      0|                  return;
 2387|      0|               }
 2388|      0|            }
 2389|  23.3k|         }
 2390|       |
 2391|       |         if constexpr (Opts.partial_read) {
 2392|       |            // partial_read stops early on a success path, so give the level back like the
 2393|       |            // syntactic-close paths do; otherwise it accumulates across reads sharing a context.
 2394|       |            --ctx.depth;
 2395|       |            return;
 2396|       |         }
 2397|  23.3k|         else {
 2398|       |            // growing
 2399|  23.3k|            if constexpr (emplace_backable<T> || has_try_emplace_back<T>) {
 2400|  4.92M|               while (it < end) {
  ------------------
  |  Branch (2400:23): [True: 4.92M, False: 0]
  ------------------
 2401|       |                  // Streaming refill point: at start of each iteration, ensure buffer has data
 2402|       |                  if constexpr (has_streaming_state<decltype(ctx)>) {
 2403|       |                     if (ctx.stream.enabled()) {
 2404|       |                        const size_t consumed = static_cast<size_t>(it - ctx.stream.data());
 2405|       |                        const size_t remaining = ctx.stream.size() - consumed;
 2406|       |                        // Refill when less than half of buffer remains to ensure space for next element
 2407|       |                        if (remaining <= ctx.stream.size() / 2 || it >= end) {
 2408|       |                           const char* new_it;
 2409|       |                           const char* new_end;
 2410|       |                           ctx.stream.consume_and_refill(consumed, new_it, new_end);
 2411|       |                           it = new_it;
 2412|       |                           end = new_end;
 2413|       |                           if (it >= end && ctx.stream.at_eof()) {
 2414|       |                              break; // No more data, exit loop normally
 2415|       |                           }
 2416|       |                        }
 2417|       |                     }
 2418|       |                  }
 2419|       |
 2420|       |                  if constexpr (has_try_emplace_back<T>) {
 2421|       |                     if (value.try_emplace_back())
 2422|       |                        parse<JSON>::op<ws_handled<Opts>()>(value.back(), ctx, it, end);
 2423|       |                     else
 2424|       |                        ctx.error = error_code::exceeded_static_array_size;
 2425|       |                  }
 2426|  4.92M|                  else {
 2427|  4.92M|                     parse<JSON>::op<ws_handled<Opts>()>(value.emplace_back(), ctx, it, end);
 2428|  4.92M|                  }
 2429|       |
 2430|  4.92M|                  if (bool(ctx.error)) [[unlikely]]
  ------------------
  |  Branch (2430:23): [True: 3.25k, False: 4.92M]
  ------------------
 2431|  3.25k|                     return;
 2432|       |
 2433|       |                  // Streaming refill point: after parsing each element, refill if buffer is low
 2434|       |                  if constexpr (has_streaming_state<decltype(ctx)>) {
 2435|       |                     if (ctx.stream.enabled()) {
 2436|       |                        const size_t consumed = static_cast<size_t>(it - ctx.stream.data());
 2437|       |                        // Refill when less than 25% of buffer remains to ensure enough space for next element
 2438|       |                        if (ctx.stream.size() - consumed <= ctx.stream.size() / 4 || it >= end) {
 2439|       |                           const char* new_it;
 2440|       |                           const char* new_end;
 2441|       |                           ctx.stream.consume_and_refill(consumed, new_it, new_end);
 2442|       |                           it = new_it;
 2443|       |                           end = new_end;
 2444|       |                           if (it >= end && ctx.stream.at_eof()) {
 2445|       |                              ctx.error = error_code::unexpected_end;
 2446|       |                              return;
 2447|       |                           }
 2448|       |                        }
 2449|       |                     }
 2450|       |                  }
 2451|       |
 2452|  4.92M|                  if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (2452:23): [True: 366, False: 4.92M]
  ------------------
 2453|    366|                     return;
 2454|    366|                  }
 2455|  4.92M|                  if (*it == ',') [[likely]] {
  ------------------
  |  Branch (2455:23): [True: 4.90M, False: 19.7k]
  ------------------
 2456|  4.90M|                     ++it;
 2457|       |
 2458|  4.90M|                     if constexpr (!Opts.minified && !Opts.comments) {
 2459|  4.90M|                        if (ws_size && ws_size < size_t(end - it)) {
  ------------------
  |  Branch (2459:29): [True: 408k, False: 4.49M]
  |  Branch (2459:40): [True: 408k, False: 595]
  ------------------
 2460|   408k|                           skip_matching_ws(ws_start, it, ws_size);
 2461|   408k|                        }
 2462|  4.90M|                     }
 2463|       |
 2464|  4.90M|                     if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (2464:26): [True: 42, False: 4.90M]
  ------------------
 2465|     42|                        return;
 2466|     42|                     }
 2467|  4.90M|                  }
 2468|  19.7k|                  else if (*it == ']') {
  ------------------
  |  Branch (2468:28): [True: 16.6k, False: 3.06k]
  ------------------
 2469|  16.6k|                     --ctx.depth;
 2470|  16.6k|                     ++it;
 2471|       |                     if constexpr (check_shrink_to_fit(Opts) && has_shrink_to_fit<T>) {
 2472|       |                        value.shrink_to_fit();
 2473|       |                     }
 2474|  16.6k|                     return;
 2475|  16.6k|                  }
 2476|  3.06k|                  else [[unlikely]] {
 2477|  3.06k|                     ctx.error = error_code::expected_bracket;
 2478|  3.06k|                     return;
 2479|  3.06k|                  }
 2480|  4.92M|               }
 2481|       |
 2482|       |               // A valid array always returns from inside the loop upon reaching ']'.
 2483|       |               // For a null-terminated buffer the loop can only exit here by falling
 2484|       |               // through when `it` reaches the terminator without a closing bracket,
 2485|       |               // which means the input was truncated (e.g. "[", "[1," or "[1,2,").
 2486|       |               // Non-null-terminated buffers surface this through skip_ws/depth
 2487|       |               // tracking (or the streaming refill break), so this guard is limited
 2488|       |               // to the null-terminated case.
 2489|       |               if constexpr (Opts.null_terminated) {
 2490|       |                  ctx.error = error_code::unexpected_end;
 2491|       |               }
 2492|       |            }
 2493|       |            else {
 2494|       |               ctx.error = error_code::exceeded_static_array_size;
 2495|       |            }
 2496|  23.3k|         }
 2497|  23.3k|      }
_ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEERNS_14basic_raw_jsonINSt3__117basic_string_viewIcNS5_11char_traitsIcEEEEEETkNS_10is_contextERNS_7contextERPKcSF_EEvOT0_OT1_OT2_T3_:
   49|  4.92M|      {
   50|       |         if constexpr (const_value_v<T>) {
   51|       |            if constexpr (check_error_on_const_read(Opts)) {
   52|       |               ctx.error = error_code::attempt_const_read;
   53|       |            }
   54|       |            else {
   55|       |               // do not read anything into the const value
   56|       |               skip_value<JSON>::op<Opts>(std::forward<Ctx>(ctx), std::forward<It0>(it), end);
   57|       |            }
   58|       |         }
   59|  4.92M|         else {
   60|  4.92M|            using V = std::remove_cvref_t<T>;
   61|  4.92M|            from<JSON, V>::template op<Opts>(std::forward<T>(value), std::forward<Ctx>(ctx), std::forward<It0>(it),
   62|  4.92M|                                             end);
   63|  4.92M|         }
   64|  4.92M|      }
_ZN3glz4fromILj10ENS_14basic_raw_jsonINSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEERS7_TkNS_10is_contextERNS_7contextERPKcSF_EEvOT0_OT1_OT2_T3_:
 2208|  4.96M|      {
 2209|  4.96M|         auto it_start = it;
 2210|  4.96M|         if (*it == 'n') {
  ------------------
  |  Branch (2210:14): [True: 706, False: 4.96M]
  ------------------
 2211|    706|            match<"null", Opts>(ctx, it, end);
 2212|    706|         }
 2213|  4.96M|         else if (is_digit(uint8_t(*it))) {
  ------------------
  |  Branch (2213:19): [True: 53.9k, False: 4.90M]
  ------------------
 2214|  53.9k|            skip_number<Opts>(ctx, it, end);
 2215|  53.9k|         }
 2216|  4.90M|         else {
 2217|  4.90M|            skip_value<JSON>::op<Opts>(ctx, it, end);
 2218|  4.90M|         }
 2219|  4.96M|         if (bool(ctx.error)) [[unlikely]]
  ------------------
  |  Branch (2219:14): [True: 6.67k, False: 4.95M]
  ------------------
 2220|  6.67k|            return;
 2221|  4.95M|         if constexpr (string_view_t<T>) {
 2222|  4.95M|            GLZ_ASSERT_OWNS_ITS_BYTES(decltype(ctx));
  ------------------
  |  |  242|  4.95M|   static_assert(!::glz::has_streaming_state<Ctx>,                                                              \
  |  |  243|  4.95M|                 "This read fills a non-owning view (std::string_view, glz::raw_json_view, glz::text_view, or " \
  |  |  244|  4.95M|                 "a std::span) that would point into the streaming window. A streaming read refills that "      \
  |  |  245|  4.95M|                 "window as it goes, so the view would address overwritten bytes by the time the read "         \
  |  |  246|  4.95M|                 "returns, and the read would report success while handing back silently wrong data. Read "     \
  |  |  247|  4.95M|                 "into the owning equivalent instead (std::string, glz::raw_json, glz::text, or an owning "     \
  |  |  248|  4.95M|                 "container), or read from a buffer that holds the whole document.")
  ------------------
 2223|  4.95M|         }
 2224|  4.95M|         value.str = {it_start, static_cast<size_t>(it - it_start)};
 2225|  4.95M|      }
_ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNS_3rpc18request_envelope_tETkNS_10is_contextERNS_7contextERPKcSA_EEvOT0_OT1_OT2_T3_:
   49|   428k|      {
   50|       |         if constexpr (const_value_v<T>) {
   51|       |            if constexpr (check_error_on_const_read(Opts)) {
   52|       |               ctx.error = error_code::attempt_const_read;
   53|       |            }
   54|       |            else {
   55|       |               // do not read anything into the const value
   56|       |               skip_value<JSON>::op<Opts>(std::forward<Ctx>(ctx), std::forward<It0>(it), end);
   57|       |            }
   58|       |         }
   59|   428k|         else {
   60|   428k|            using V = std::remove_cvref_t<T>;
   61|   428k|            from<JSON, V>::template op<Opts>(std::forward<T>(value), std::forward<Ctx>(ctx), std::forward<It0>(it),
   62|   428k|                                             end);
   63|   428k|         }
   64|   428k|      }
_ZN3glz4fromILj10ENS_3rpc18request_envelope_tEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnNS_14string_literalEXtlNS6_ILm1EEEEERS2_TkNS_10is_contextERNS_7contextERPKcSC_EEvOT1_OT2_OT3_T4_:
 3044|   428k|      {
 3045|   428k|         static constexpr auto num_members = reflect<T>::size;
 3046|       |
 3047|   428k|         static constexpr auto Opts = opening_handled_off<ws_handled_off<Options>()>();
 3048|   428k|         if constexpr (!check_opening_handled(Options)) {
 3049|   428k|            if constexpr (!check_ws_handled(Options)) {
 3050|   428k|               if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (3050:20): [True: 15, False: 428k]
  ------------------
 3051|     15|                  return;
 3052|     15|               }
 3053|   428k|            }
 3054|   428k|            if (match_invalid_end<'{', Opts>(ctx, it, end)) {
  ------------------
  |  Branch (3054:17): [True: 261k, False: 167k]
  ------------------
 3055|   261k|               return;
 3056|   261k|            }
 3057|   167k|            if constexpr (not Opts.null_terminated) {
 3058|   167k|               if (it == end) [[unlikely]] {
  ------------------
  |  Branch (3058:20): [True: 0, False: 167k]
  ------------------
 3059|      0|                  ctx.error = error_code::unexpected_end;
 3060|      0|                  return;
 3061|      0|               }
 3062|   167k|            }
 3063|       |            // one nesting level (see enter_depth): counted in both modes so the limit binds,
 3064|       |            // released at each syntactic close below
 3065|   167k|            if (enter_depth(ctx)) [[unlikely]] {
  ------------------
  |  Branch (3065:17): [True: 0, False: 167k]
  ------------------
 3066|      0|               return;
 3067|      0|            }
 3068|   167k|         }
 3069|   167k|         const auto ws_start = it;
 3070|   428k|         if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (3070:14): [True: 19, False: 428k]
  ------------------
 3071|     19|            return;
 3072|     19|         }
 3073|   428k|         const size_t ws_size = size_t(it - ws_start);
 3074|       |
 3075|       |         if constexpr ((glaze_object_t<T> || reflectable<T>) && num_members == 0 && Opts.error_on_unknown_keys) {
 3076|       |            if constexpr (not tag.sv().empty()) {
 3077|       |               if (*it == '"') {
 3078|       |                  ++it;
 3079|       |                  if constexpr (not Opts.null_terminated) {
 3080|       |                     if (it == end) [[unlikely]] {
 3081|       |                        ctx.error = error_code::unexpected_end;
 3082|       |                        return;
 3083|       |                     }
 3084|       |                  }
 3085|       |
 3086|       |                  const auto start = it;
 3087|       |                  skip_string_view(ctx, it, end);
 3088|       |                  if (bool(ctx.error)) [[unlikely]]
 3089|       |                     return;
 3090|       |                  if (validate_utf8_span<Opts>(ctx, start, it)) [[unlikely]]
 3091|       |                     return;
 3092|       |                  const sv key{start, size_t(it - start)};
 3093|       |                  ++it;
 3094|       |                  if constexpr (not Opts.null_terminated) {
 3095|       |                     if (it == end) [[unlikely]] {
 3096|       |                        ctx.error = error_code::unexpected_end;
 3097|       |                        return;
 3098|       |                     }
 3099|       |                  }
 3100|       |
 3101|       |                  if (key == tag.sv()) {
 3102|       |                     if (parse_ws_colon<Opts>(ctx, it, end)) {
 3103|       |                        return;
 3104|       |                     }
 3105|       |
 3106|       |                     parse<JSON>::handle_unknown<Opts>(key, value, ctx, it, end);
 3107|       |                     if (bool(ctx.error)) [[unlikely]]
 3108|       |                        return;
 3109|       |
 3110|       |                     if (skip_ws<Opts>(ctx, it, end)) {
 3111|       |                        return;
 3112|       |                     }
 3113|       |                  }
 3114|       |                  else {
 3115|       |                     ctx.error = error_code::unknown_key;
 3116|       |                     return;
 3117|       |                  }
 3118|       |               }
 3119|       |            }
 3120|       |
 3121|       |            if (*it == '}') [[likely]] {
 3122|       |               --ctx.depth;
 3123|       |               if constexpr (glaze_object_t<T> || reflectable<T>) {
 3124|       |                  if constexpr (has_self_constraint_v<T> && !check_skip_self_constraint(Opts)) {
 3125|       |                     auto wrapper = self_constraint_v<T>(value);
 3126|       |                     from<JSON, decltype(wrapper)>::template op<ws_handled<Opts>()>(wrapper, ctx, it, end);
 3127|       |                     if (bool(ctx.error)) {
 3128|       |                        return;
 3129|       |                     }
 3130|       |                  }
 3131|       |               }
 3132|       |               ++it;
 3133|       |               if constexpr (not Opts.null_terminated) {
 3134|       |                  if (it == end) {
 3135|       |                     ctx.error = error_code::end_reached;
 3136|       |                     return;
 3137|       |                  }
 3138|       |               }
 3139|       |               if constexpr (Opts.partial_read) {
 3140|       |                  ctx.error = error_code::partial_read_complete;
 3141|       |               }
 3142|       |               return;
 3143|       |            }
 3144|       |            ctx.error = error_code::unknown_key;
 3145|       |            return;
 3146|       |         }
 3147|   428k|         else {
 3148|   428k|            decltype(auto) fields = [&]() -> decltype(auto) {
 3149|   428k|               if constexpr ((glaze_object_t<T> || reflectable<T>) &&
 3150|   428k|                             (Opts.error_on_missing_keys || Opts.partial_read)) {
 3151|   428k|                  return bit_array<num_members>{};
 3152|   428k|               }
 3153|   428k|               else {
 3154|   428k|                  return nullptr;
 3155|   428k|               }
 3156|   428k|            }();
 3157|       |
 3158|   428k|            size_t read_count{}; // for partial_read
 3159|       |
 3160|   428k|            bool first = true;
 3161|   724k|            while (true) {
  ------------------
  |  Branch (3161:20): [True: 370k, Folded]
  ------------------
 3162|       |               if constexpr ((glaze_object_t<T> || reflectable<T>) && Opts.partial_read) {
 3163|       |                  static constexpr bit_array<num_members> all_fields = [] {
 3164|       |                     bit_array<num_members> arr{};
 3165|       |                     for (size_t i = 0; i < num_members; ++i) {
 3166|       |                        arr[i] = true;
 3167|       |                     }
 3168|       |                     return arr;
 3169|       |                  }();
 3170|       |
 3171|       |                  if ((all_fields & fields) == all_fields) {
 3172|       |                     ctx.error = error_code::partial_read_complete;
 3173|       |                     --ctx.depth; // as above: an early success still closes this level
 3174|       |                     return;
 3175|       |                  }
 3176|       |               }
 3177|       |
 3178|       |               // Streaming refill point: at start of each iteration, ensure buffer has data
 3179|       |               if constexpr (has_streaming_state<decltype(ctx)>) {
 3180|       |                  if (ctx.stream.enabled()) {
 3181|       |                     const size_t consumed = static_cast<size_t>(it - ctx.stream.data());
 3182|       |                     const size_t remaining = ctx.stream.size() - consumed;
 3183|       |                     // Refill when less than half of buffer remains to ensure space for next key-value pair
 3184|       |                     if (remaining <= ctx.stream.size() / 2 || it >= end) {
 3185|       |                        const char* new_it;
 3186|       |                        const char* new_end;
 3187|       |                        ctx.stream.consume_and_refill(consumed, new_it, new_end);
 3188|       |                        it = new_it;
 3189|       |                        end = new_end;
 3190|       |                        if (it >= end && ctx.stream.at_eof()) {
 3191|       |                           ctx.error = error_code::unexpected_end;
 3192|       |                           return;
 3193|       |                        }
 3194|       |                     }
 3195|       |                  }
 3196|       |               }
 3197|       |
 3198|   370k|               if (*it == '}') {
  ------------------
  |  Branch (3198:20): [True: 63.8k, False: 306k]
  ------------------
 3199|  63.8k|                  --ctx.depth;
 3200|       |                  if constexpr ((glaze_object_t<T> || reflectable<T>) && Opts.error_on_missing_keys) {
 3201|       |                     constexpr auto req_fields = required_fields<T, Opts>();
 3202|       |                     if ((req_fields & fields) != req_fields) {
 3203|       |                        for (size_t i = 0; i < num_members; ++i) {
 3204|       |                           if (not fields[i] && req_fields[i]) {
 3205|       |                              ctx.custom_error_message = reflect<T>::keys[i];
 3206|       |                              // We just return the first missing key in order to avoid heap allocations
 3207|       |                              break;
 3208|       |                           }
 3209|       |                        }
 3210|       |
 3211|       |                        ctx.error = error_code::missing_key;
 3212|       |                        return;
 3213|       |                     }
 3214|       |                  }
 3215|  63.8k|                  if constexpr (glaze_object_t<T> || reflectable<T>) {
 3216|       |                     if constexpr (has_self_constraint_v<T> && !check_skip_self_constraint(Opts)) {
 3217|       |                        auto wrapper = self_constraint_v<T>(value);
 3218|       |                        from<JSON, decltype(wrapper)>::template op<ws_handled<Opts>()>(wrapper, ctx, it, end);
 3219|       |                        if (bool(ctx.error)) {
 3220|       |                           return;
 3221|       |                        }
 3222|       |                     }
 3223|  63.8k|                  }
 3224|  63.8k|                  ++it; // Increment after checking for missing keys so errors are within buffer bounds
 3225|  63.8k|                  if constexpr (not Opts.null_terminated) {
 3226|  63.8k|                     if (it == end) {
  ------------------
  |  Branch (3226:26): [True: 59.8k, False: 3.98k]
  ------------------
 3227|  59.8k|                        ctx.error = error_code::end_reached;
 3228|  59.8k|                        return;
 3229|  59.8k|                     }
 3230|  63.8k|                  }
 3231|  3.98k|                  return;
 3232|  63.8k|               }
 3233|   306k|               else if (first) {
  ------------------
  |  Branch (3233:25): [True: 163k, False: 143k]
  ------------------
 3234|   163k|                  first = false;
 3235|   163k|               }
 3236|   143k|               else {
 3237|   143k|                  if (match_invalid_end<',', Opts>(ctx, it, end)) {
  ------------------
  |  Branch (3237:23): [True: 10.9k, False: 132k]
  ------------------
 3238|  10.9k|                     return;
 3239|  10.9k|                  }
 3240|   132k|                  if constexpr (not Opts.null_terminated) {
 3241|   132k|                     if (it == end) [[unlikely]] {
  ------------------
  |  Branch (3241:26): [True: 0, False: 132k]
  ------------------
 3242|      0|                        ctx.error = error_code::unexpected_end;
 3243|      0|                        return;
 3244|      0|                     }
 3245|   132k|                  }
 3246|       |
 3247|       |                  if constexpr ((not Opts.minified) && (num_members > 1 || not Opts.error_on_unknown_keys) &&
 3248|   132k|                                (!Opts.comments)) {
 3249|   132k|                     if (ws_size && ws_size < size_t(end - it)) {
  ------------------
  |  Branch (3249:26): [True: 8.50k, False: 123k]
  |  Branch (3249:37): [True: 7.05k, False: 1.45k]
  ------------------
 3250|  7.05k|                        skip_matching_ws(ws_start, it, ws_size);
 3251|  7.05k|                     }
 3252|   132k|                  }
 3253|       |
 3254|   132k|                  if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (3254:23): [True: 5, False: 132k]
  ------------------
 3255|      5|                     return;
 3256|      5|                  }
 3257|   132k|               }
 3258|       |
 3259|   295k|               constexpr auto reflection_type = glaze_object_t<T> || reflectable<T>;
  ------------------
  |  Branch (3259:49): [True: 295k, Folded]
  |  Branch (3259:70): [Folded, False: 0]
  ------------------
 3260|       |
 3261|       |               if constexpr (reflection_type && (num_members == 0)) {
 3262|       |                  if constexpr (Opts.error_on_unknown_keys) {
 3263|       |                     static_assert(false_v<T>, "This should be unreachable");
 3264|       |                  }
 3265|       |                  else {
 3266|       |                     if (match_invalid_end<'"', Opts>(ctx, it, end)) {
 3267|       |                        return;
 3268|       |                     }
 3269|       |
 3270|       |                     // parsing to an empty object, but at this point the JSON presents keys
 3271|       |
 3272|       |                     // Unknown key handler does not unescape keys. Unknown escaped keys are
 3273|       |                     // handled by the user.
 3274|       |
 3275|       |                     const auto start = it;
 3276|       |                     skip_string_view(ctx, it, end);
 3277|       |                     if (bool(ctx.error)) [[unlikely]]
 3278|       |                        return;
 3279|       |                     if (validate_utf8_span<Opts>(ctx, start, it)) [[unlikely]]
 3280|       |                        return;
 3281|       |                     const sv key{start, size_t(it - start)};
 3282|       |                     ++it;
 3283|       |                     if constexpr (not Opts.null_terminated) {
 3284|       |                        if (it == end) [[unlikely]] {
 3285|       |                           ctx.error = error_code::unexpected_end;
 3286|       |                           return;
 3287|       |                        }
 3288|       |                     }
 3289|       |
 3290|       |                     if (parse_ws_colon<Opts>(ctx, it, end)) {
 3291|       |                        return;
 3292|       |                     }
 3293|       |
 3294|       |                     // Check if this key is the variant tag that should be skipped
 3295|       |                     if constexpr (not tag.sv().empty()) {
 3296|       |                        if (key == tag.sv()) {
 3297|       |                           // Skip the tag value
 3298|       |                           skip_value<JSON>::op<Opts>(ctx, it, end);
 3299|       |                           if (bool(ctx.error)) [[unlikely]]
 3300|       |                              return;
 3301|       |                           resync_window_end(ctx, end); // a streaming skip refills
 3302|       |                           if (skip_ws<Opts>(ctx, it, end)) {
 3303|       |                              return;
 3304|       |                           }
 3305|       |                           continue;
 3306|       |                        }
 3307|       |                     }
 3308|       |
 3309|       |                     parse<JSON>::handle_unknown<Opts>(key, value, ctx, it, end);
 3310|       |                     if (bool(ctx.error)) [[unlikely]]
 3311|       |                        return;
 3312|       |                     if constexpr (not Opts.null_terminated) {
 3313|       |                        if (it == end) [[unlikely]] {
 3314|       |                           ctx.error = error_code::unexpected_end;
 3315|       |                           return;
 3316|       |                        }
 3317|       |                     }
 3318|       |                     if (skip_ws<Opts>(ctx, it, end)) {
 3319|       |                        return;
 3320|       |                     }
 3321|       |                  }
 3322|       |               }
 3323|   295k|               else if constexpr (reflection_type) {
 3324|   295k|                  static_assert(bool(hash_info<T>.type));
 3325|       |
 3326|   295k|                  if (*it != '"') [[unlikely]] {
  ------------------
  |  Branch (3326:23): [True: 24.8k, False: 270k]
  ------------------
 3327|  24.8k|                     ctx.error = error_code::expected_quote;
 3328|  24.8k|                     return;
 3329|  24.8k|                  }
 3330|   270k|                  ++it;
 3331|   270k|                  if constexpr (not Opts.null_terminated) {
 3332|   270k|                     if (it == end) [[unlikely]] {
  ------------------
  |  Branch (3332:26): [True: 3, False: 270k]
  ------------------
 3333|      3|                        ctx.error = error_code::unexpected_end;
 3334|      3|                        return;
 3335|      3|                     }
 3336|   270k|                  }
 3337|       |
 3338|       |                  if constexpr (not tag.sv().empty() && not contains_tag<T, tag>()) {
 3339|       |                     // For tagged variants we first check to see if the key matches the tag
 3340|       |                     // We only need to do this if the tag is not part of the keys
 3341|       |
 3342|       |                     const auto start = it;
 3343|       |                     skip_string_view(ctx, it, end);
 3344|       |                     if (bool(ctx.error)) [[unlikely]]
 3345|       |                        return;
 3346|       |                     if (validate_utf8_span<Opts>(ctx, start, it)) [[unlikely]]
 3347|       |                        return;
 3348|       |                     const sv key{start, size_t(it - start)};
 3349|       |                     ++it;
 3350|       |                     if constexpr (not Opts.null_terminated) {
 3351|       |                        if (it == end) [[unlikely]] {
 3352|       |                           ctx.error = error_code::unexpected_end;
 3353|       |                           return;
 3354|       |                        }
 3355|       |                     }
 3356|       |
 3357|       |                     if (key == tag.sv()) {
 3358|       |                        if (parse_ws_colon<Opts>(ctx, it, end)) {
 3359|       |                           return;
 3360|       |                        }
 3361|       |
 3362|       |                        parse<JSON>::handle_unknown<Opts>(key, value, ctx, it, end);
 3363|       |                        if (bool(ctx.error)) [[unlikely]]
 3364|       |                           return;
 3365|       |
 3366|       |                        if (skip_ws<Opts>(ctx, it, end)) {
 3367|       |                           return;
 3368|       |                        }
 3369|       |                        continue;
 3370|       |                     }
 3371|       |                     else {
 3372|       |                        it = start; // reset the iterator
 3373|       |                     }
 3374|       |                  }
 3375|       |
 3376|       |                  if constexpr (Opts.error_on_missing_keys || Opts.partial_read) {
 3377|       |                     size_t index = num_members;
 3378|       |                     parse_and_invoke<Opts, T>(value, ctx, it, end, index);
 3379|       |                     if (bool(ctx.error)) [[unlikely]]
 3380|       |                        return;
 3381|       |                     if (index < num_members) {
 3382|       |                        fields[index] = true;
 3383|       |                     }
 3384|       |                  }
 3385|   270k|                  else {
 3386|   270k|                     parse_and_invoke<Opts, T>(value, ctx, it, end);
 3387|   270k|                     if (bool(ctx.error)) [[unlikely]]
  ------------------
  |  Branch (3387:26): [True: 67.7k, False: 203k]
  ------------------
 3388|  67.7k|                        return;
 3389|   270k|                  }
 3390|       |               }
 3391|       |               else {
 3392|       |                  // For types like std::map, std::unordered_map
 3393|       |
 3394|       |                  auto reading = [&](auto&& key) {
 3395|       |                     if constexpr (Opts.partial_read) {
 3396|       |                        if (auto element = value.find(key); element != value.end()) {
 3397|       |                           ++read_count;
 3398|       |                           parse<JSON>::op<ws_handled<Opts>()>(element->second, ctx, it, end);
 3399|       |                        }
 3400|       |                        else {
 3401|       |                           skip_value<JSON>::op<Opts>(ctx, it, end);
 3402|       |                        }
 3403|       |                     }
 3404|       |                     else {
 3405|       |                        parse<JSON>::op<ws_handled<Opts>()>(value[key], ctx, it, end);
 3406|       |                     }
 3407|       |                  };
 3408|       |
 3409|       |                  // using Key = std::conditional_t<heterogeneous_map<T>, sv, typename T::key_type>;
 3410|       |                  using Key = typename T::key_type;
 3411|       |                  if constexpr (std::is_same_v<Key, std::string>) {
 3412|       |                     ctx.scratch.clear();
 3413|       |                     parse<JSON>::op<Opts>(ctx.scratch, ctx, it, end);
 3414|       |                     if (bool(ctx.error)) [[unlikely]]
 3415|       |                        return;
 3416|       |
 3417|       |                     if (parse_ws_colon<Opts>(ctx, it, end)) {
 3418|       |                        return;
 3419|       |                     }
 3420|       |
 3421|       |                     reading(ctx.scratch);
 3422|       |                     if constexpr (Opts.partial_read) {
 3423|       |                        if (read_count == value.size()) {
 3424|       |                           return;
 3425|       |                        }
 3426|       |                     }
 3427|       |                     if (bool(ctx.error)) [[unlikely]]
 3428|       |                        return;
 3429|       |                  }
 3430|       |                  else if constexpr (str_t<Key>) {
 3431|       |                     Key key;
 3432|       |                     parse<JSON>::op<Opts>(key, ctx, it, end);
 3433|       |                     if (bool(ctx.error)) [[unlikely]]
 3434|       |                        return;
 3435|       |
 3436|       |                     if (parse_ws_colon<Opts>(ctx, it, end)) {
 3437|       |                        return;
 3438|       |                     }
 3439|       |
 3440|       |                     reading(key);
 3441|       |                     if constexpr (Opts.partial_read) {
 3442|       |                        if (read_count == value.size()) {
 3443|       |                           return;
 3444|       |                        }
 3445|       |                     }
 3446|       |                     if (bool(ctx.error)) [[unlikely]]
 3447|       |                        return;
 3448|       |                  }
 3449|       |                  else {
 3450|       |                     Key key_value{};
 3451|       |                     if constexpr (is_named_enum<Key> || mimics_str_t<Key>) {
 3452|       |                        parse<JSON>::op<Opts>(key_value, ctx, it, end);
 3453|       |                     }
 3454|       |                     else if constexpr (std::is_arithmetic_v<Key>) {
 3455|       |                        // prefer over quoted_t below to avoid double parsing of quoted_t
 3456|       |                        parse<JSON>::op<opt_true<Opts, quoted_num_opt_tag{}>>(key_value, ctx, it, end);
 3457|       |                     }
 3458|       |                     else {
 3459|       |                        parse<JSON>::op<opt_false<Opts, raw_string_opt_tag{}>>(quoted_t<Key>{key_value}, ctx, it, end);
 3460|       |                     }
 3461|       |                     if (bool(ctx.error)) [[unlikely]]
 3462|       |                        return;
 3463|       |
 3464|       |                     if (parse_ws_colon<Opts>(ctx, it, end)) {
 3465|       |                        return;
 3466|       |                     }
 3467|       |
 3468|       |                     reading(key_value);
 3469|       |                     if constexpr (Opts.partial_read) {
 3470|       |                        if (read_count == value.size()) {
 3471|       |                           return;
 3472|       |                        }
 3473|       |                     }
 3474|       |                     if (bool(ctx.error)) [[unlikely]]
 3475|       |                        return;
 3476|       |                  }
 3477|       |               }
 3478|       |
 3479|       |               // Streaming refill point: after parsing each key-value pair, refill if buffer is low
 3480|       |               if constexpr (has_streaming_state<decltype(ctx)>) {
 3481|       |                  if (ctx.stream.enabled()) {
 3482|       |                     const size_t consumed = static_cast<size_t>(it - ctx.stream.data());
 3483|       |                     // Refill when less than 25% of buffer remains to ensure enough space for next element
 3484|       |                     if (ctx.stream.size() - consumed <= ctx.stream.size() / 4 || it >= end) {
 3485|       |                        const char* new_it;
 3486|       |                        const char* new_end;
 3487|       |                        ctx.stream.consume_and_refill(consumed, new_it, new_end);
 3488|       |                        it = new_it;
 3489|       |                        end = new_end;
 3490|       |                        if (it >= end && ctx.stream.at_eof()) {
 3491|       |                           ctx.error = error_code::unexpected_end;
 3492|       |                           return;
 3493|       |                        }
 3494|       |                     }
 3495|       |                  }
 3496|       |               }
 3497|       |
 3498|   295k|               if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (3498:20): [True: 247, False: 295k]
  ------------------
 3499|    247|                  return;
 3500|    247|               }
 3501|   295k|            }
 3502|   428k|         }
 3503|   428k|      }
_ZZN3glz4fromILj10ENS_3rpc18request_envelope_tEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnNS_14string_literalEXtlNS6_ILm1EEEEERS2_TkNS_10is_contextERNS_7contextERPKcSC_EEvOT1_OT2_OT3_T4_ENKUlvE_clEv:
 3148|   167k|            decltype(auto) fields = [&]() -> decltype(auto) {
 3149|       |               if constexpr ((glaze_object_t<T> || reflectable<T>) &&
 3150|       |                             (Opts.error_on_missing_keys || Opts.partial_read)) {
 3151|       |                  return bit_array<num_members>{};
 3152|       |               }
 3153|   167k|               else {
 3154|   167k|                  return nullptr;
 3155|   167k|               }
 3156|   167k|            }();
_ZN3glz16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENS_3rpc18request_envelope_tERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT3_OT4_OT5_DpOT2_:
  376|   270k|   {
  377|   270k|      constexpr auto N = reflect<T>::size;
  378|       |
  379|       |      if constexpr (N == 1) {
  380|       |         decode_index<Opts, T, 0>(value, ctx, it, end, selected_index...);
  381|       |      }
  382|       |      else if constexpr (check_linear_search(Opts)) {
  383|       |         // Linear search path
  384|       |         auto key_start = it;
  385|       |         const auto index = decode_linear<T>(ctx, it, end);
  386|       |         if (bool(ctx.error)) [[unlikely]]
  387|       |            return;
  388|       |
  389|       |         if (index >= N) [[unlikely]] {
  390|       |            if constexpr (Opts.error_on_unknown_keys) {
  391|       |               ctx.error = error_code::unknown_key;
  392|       |               return;
  393|       |            }
  394|       |            else {
  395|       |               // it sits one past the closing quote, so the raw key spans [key_start, it - 1)
  396|       |               if (validate_utf8_span<Opts>(ctx, key_start, it - 1)) [[unlikely]] {
  397|       |                  return;
  398|       |               }
  399|       |               const sv key{key_start, size_t(it - key_start - 1)};
  400|       |               if constexpr (not Opts.null_terminated) {
  401|       |                  if (it == end) [[unlikely]] {
  402|       |                     ctx.error = error_code::unexpected_end;
  403|       |                     return;
  404|       |                  }
  405|       |               }
  406|       |               if (parse_ws_colon<Opts>(ctx, it, end)) {
  407|       |                  return;
  408|       |               }
  409|       |               parse<JSON>::handle_unknown<Opts>(key, value, ctx, it, end);
  410|       |               return;
  411|       |            }
  412|       |         }
  413|       |
  414|       |         if constexpr (not Opts.null_terminated) {
  415|       |            if (it == end) [[unlikely]] {
  416|       |               ctx.error = error_code::unexpected_end;
  417|       |               return;
  418|       |            }
  419|       |         }
  420|       |         if (skip_ws<Opts>(ctx, it, end)) {
  421|       |            return;
  422|       |         }
  423|       |         if (match_invalid_end<':', Opts>(ctx, it, end)) {
  424|       |            return;
  425|       |         }
  426|       |         if (skip_ws<Opts>(ctx, it, end)) {
  427|       |            return;
  428|       |         }
  429|       |
  430|       |         // Fold expression dispatch - avoids jump table overhead for smaller binary size.
  431|       |         // For linear_search, pass Opts through to the field parser to avoid duplicate template
  432|       |         // instantiations; the whitespace before the value has already been skipped either way.
  433|       |         [&]<size_t... Is>(std::index_sequence<Is...>) {
  434|       |            (void)(((index == Is ? (decode_field_value<Opts, Opts, T, Is>(value, ctx, it, end, selected_index...), true)
  435|       |                                 : false) ||
  436|       |                    ...));
  437|       |         }(std::make_index_sequence<N>{});
  438|       |      }
  439|   270k|      else {
  440|       |         // Hash-based lookup
  441|   270k|         constexpr auto& HashInfo = hash_info<T>;
  442|   270k|         constexpr auto type = HashInfo.type;
  443|   270k|         static_assert(bool(type), "invalid hash algorithm");
  444|       |
  445|   270k|         const auto index = decode_hash<JSON, T, HashInfo, HashInfo.type>::op(it, end);
  446|       |
  447|   270k|         if (index >= N) [[unlikely]] {
  ------------------
  |  Branch (447:14): [True: 22.2k, False: 248k]
  ------------------
  448|  22.2k|            if constexpr (Opts.error_on_unknown_keys) {
  449|  22.2k|               ctx.error = error_code::unknown_key;
  450|  22.2k|               return;
  451|       |            }
  452|       |            else {
  453|       |               auto start = it;
  454|       |               skip_string_view(ctx, it, end);
  455|       |               if (bool(ctx.error)) [[unlikely]]
  456|       |                  return;
  457|       |               if (validate_utf8_span<Opts>(ctx, start, it)) [[unlikely]]
  458|       |                  return;
  459|       |               const sv key = {start, size_t(it - start)};
  460|       |               ++it; // skip the quote
  461|       |               if constexpr (not Opts.null_terminated) {
  462|       |                  if (it == end) [[unlikely]] {
  463|       |                     ctx.error = error_code::unexpected_end;
  464|       |                     return;
  465|       |                  }
  466|       |               }
  467|       |               if (parse_ws_colon<Opts>(ctx, it, end)) {
  468|       |                  return;
  469|       |               }
  470|       |               parse<JSON>::handle_unknown<Opts>(key, value, ctx, it, end);
  471|       |               return;
  472|       |            }
  473|  22.2k|         }
  474|       |
  475|       |         if constexpr (N == 2) {
  476|       |            if (index == 0) {
  477|       |               decode_index<Opts, T, 0>(value, ctx, it, end, selected_index...);
  478|       |            }
  479|       |            else {
  480|       |               decode_index<Opts, T, 1>(value, ctx, it, end, selected_index...);
  481|       |            }
  482|       |         }
  483|   270k|         else {
  484|   270k|            visit<N>([&]<size_t I>() { decode_index<Opts, T, I>(value, ctx, it, end, selected_index...); }, index);
  485|   270k|         }
  486|   270k|      }
  487|   270k|   }
_ZZN3glz16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENS_3rpc18request_envelope_tERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT3_OT4_OT5_DpOT2_ENKUlTnmvE_clILm0EEEDav:
  484|  64.3k|            visit<N>([&]<size_t I>() { decode_index<Opts, T, I>(value, ctx, it, end, selected_index...); }, index);
_ZN3glz12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENS_3rpc18request_envelope_tELm0ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT2_OT4_OT5_OT6_DpOT3_:
  311|  64.3k|   {
  312|  64.3k|      static constexpr auto Key = get<I>(reflect<T>::keys);
  313|  64.3k|      static constexpr auto KeyWithEndQuote = join_v<Key, chars<"\"">>;
  314|  64.3k|      static constexpr auto Length = KeyWithEndQuote.size();
  315|       |
  316|  64.3k|      if (((it + Length) < end) && comparitor<KeyWithEndQuote>(it)) [[likely]] {
  ------------------
  |  Branch (316:11): [True: 63.9k, False: 331]
  |  Branch (316:36): [True: 62.3k, False: 1.59k]
  ------------------
  317|  62.3k|         it += Length;
  318|  62.3k|         if constexpr (not Opts.null_terminated) {
  319|  62.3k|            if (it == end) [[unlikely]] {
  ------------------
  |  Branch (319:17): [True: 0, False: 62.3k]
  ------------------
  320|      0|               ctx.error = error_code::unexpected_end;
  321|      0|               return;
  322|      0|            }
  323|  62.3k|         }
  324|       |
  325|  62.3k|         if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (325:14): [True: 2, False: 62.3k]
  ------------------
  326|      2|            return;
  327|      2|         }
  328|  62.3k|         if (match_invalid_end<':', Opts>(ctx, it, end)) {
  ------------------
  |  Branch (328:14): [True: 2.30k, False: 60.0k]
  ------------------
  329|  2.30k|            return;
  330|  2.30k|         }
  331|  60.0k|         if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (331:14): [True: 2, False: 60.0k]
  ------------------
  332|      2|            return;
  333|      2|         }
  334|       |
  335|       |         // The hash path has already consumed the whitespace before the value
  336|  60.0k|         decode_field_value<Opts, ws_handled<Opts>(), T, I>(value, ctx, it, end, selected_index...);
  337|  60.0k|      }
  338|  1.92k|      else [[unlikely]] {
  339|  1.92k|         decode_index_unknown_key<Opts, T>(value, ctx, it, end);
  340|  1.92k|      }
  341|  64.3k|   }
_ZN3glz18decode_field_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnDaXtlS1_Lj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEENS_3rpc18request_envelope_tELm0ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT1_E11reflectableISA_EEEvOT3_OT5_OT6_OT7_DpOT4_:
  245|  60.0k|   {
  246|       |      // Check for null value skipping on read
  247|       |      if constexpr (check_skip_null_members_on_read(Opts)) {
  248|       |         if (*it == 'n') {
  249|       |            ++it;
  250|       |            if constexpr (not Opts.null_terminated) {
  251|       |               if (it == end) [[unlikely]] {
  252|       |                  ctx.error = error_code::unexpected_end;
  253|       |                  return;
  254|       |               }
  255|       |            }
  256|       |            match<"ull", Opts>(ctx, it, end);
  257|       |            if (bool(ctx.error)) [[unlikely]]
  258|       |               return;
  259|       |            // Successfully matched "null", skip it
  260|       |            if constexpr (Opts.error_on_missing_keys || Opts.partial_read) {
  261|       |               ((selected_index = I), ...); // Mark as handled even if skipped
  262|       |            }
  263|       |            return;
  264|       |         }
  265|       |      }
  266|       |
  267|       |      if constexpr (skipped_by_meta<T, I, operation::parse>) {
  268|       |         skip_value<JSON>::op<Opts>(ctx, it, end);
  269|       |         if (bool(ctx.error)) [[unlikely]]
  270|       |            return; // Propagate error from skip_value
  271|       |      }
  272|  60.0k|      else {
  273|  60.0k|         using V = refl_t<T, I>;
  274|       |
  275|       |         if constexpr (const_value_v<V>) {
  276|       |            if constexpr (check_error_on_const_read(Opts)) {
  277|       |               ctx.error = error_code::attempt_const_read;
  278|       |            }
  279|       |            else {
  280|       |               // do not read anything into the const value
  281|       |               skip_value<JSON>::op<Opts>(ctx, it, end);
  282|       |            }
  283|       |         }
  284|       |         else if constexpr (is_function_ptr_or_ref<V>) {
  285|       |            // Function pointers cannot be deserialized from JSON.
  286|       |            // When write_function_pointers is enabled the writer emits a type-name string,
  287|       |            // but there is nothing meaningful to reconstruct on read — just skip the value.
  288|       |            // When write_function_pointers is off the key is never written, so this branch
  289|       |            // is unreachable in that case.
  290|       |            skip_value<JSON>::op<Opts>(ctx, it, end);
  291|       |         }
  292|  60.0k|         else if constexpr (glaze_object_t<T>) {
  293|  60.0k|            from<JSON, std::remove_cvref_t<V>>::template op<FieldOpts>(get_member(value, get<I>(reflect<T>::values)),
  294|  60.0k|                                                                       ctx, it, end);
  295|       |         }
  296|       |         else {
  297|       |            from<JSON, std::remove_cvref_t<V>>::template op<FieldOpts>(get_member(value, get<I>(to_tie(value))), ctx,
  298|       |                                                                       it, end);
  299|       |         }
  300|  60.0k|      }
  301|       |
  302|       |      // The key was present and handled, even when the value itself was skipped
  303|       |      if constexpr (Opts.error_on_missing_keys || Opts.partial_read) {
  304|       |         ((selected_index = I), ...);
  305|       |      }
  306|  60.0k|   }
_ZN3glz4fromILj10ENSt3__18optionalINS1_17basic_string_viewIcNS1_11char_traitsIcEEEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEERS7_TkNS_10is_contextERNS_7contextERPKcSF_EEvOT0_OT1_OT2_T3_:
 5088|   110k|      {
 5089|   110k|         constexpr auto Opts = ws_handled_off<Options>();
 5090|       |         if constexpr (!check_ws_handled(Options)) {
 5091|       |            if (skip_ws<Opts>(ctx, it, end)) {
 5092|       |               return;
 5093|       |            }
 5094|       |         }
 5095|       |
 5096|   110k|         if (*it == 'n') {
  ------------------
  |  Branch (5096:14): [True: 1.18k, False: 109k]
  ------------------
 5097|  1.18k|            ++it;
 5098|  1.18k|            if constexpr (not Opts.null_terminated) {
 5099|  1.18k|               if (it == end) [[unlikely]] {
  ------------------
  |  Branch (5099:20): [True: 1, False: 1.18k]
  ------------------
 5100|      1|                  ctx.error = error_code::unexpected_end;
 5101|      1|                  return;
 5102|      1|               }
 5103|  1.18k|            }
 5104|  1.18k|            match<"ull", Opts>(ctx, it, end);
 5105|  1.18k|            if (bool(ctx.error)) [[unlikely]]
  ------------------
  |  Branch (5105:17): [True: 648, False: 541]
  ------------------
 5106|    648|               return;
 5107|    541|            if constexpr (requires { value.reset(); }) {
 5108|    541|               value.reset();
 5109|    541|            }
 5110|    541|         }
 5111|   109k|         else {
 5112|   109k|            if constexpr (nullable_value_t<T>) {
 5113|   109k|               if (not value.has_value()) {
  ------------------
  |  Branch (5113:20): [True: 108k, False: 816]
  ------------------
 5114|       |                  if constexpr (constructible<T>) {
 5115|       |                     value = meta_construct_v<T>();
 5116|       |                  }
 5117|   108k|                  else if constexpr (requires { value.emplace(); }) {
 5118|   108k|                     value.emplace();
 5119|       |                  }
 5120|       |                  else {
 5121|       |                     static_assert(false_v<T>,
 5122|       |                                   "Your nullable type must have `emplace()` or be glz::meta constructible, or "
 5123|       |                                   "create a custom glz::from specialization");
 5124|       |                  }
 5125|   108k|               }
 5126|   109k|               parse<JSON>::op<Opts>(value.value(), ctx, it, end);
 5127|       |            }
 5128|       |            else {
 5129|       |               if (!value) {
 5130|       |                  if (!nullable_emplace<Opts>(value, ctx)) {
 5131|       |                     return;
 5132|       |                  }
 5133|       |               }
 5134|       |               parse<JSON>::op<Opts>(*value, ctx, it, end);
 5135|       |            }
 5136|   109k|         }
 5137|   110k|      }
_ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__117basic_string_viewIcNS4_11char_traitsIcEEEETkNS_10is_contextERNS_7contextERPKcSD_EEvOT0_OT1_OT2_T3_:
   49|   109k|      {
   50|       |         if constexpr (const_value_v<T>) {
   51|       |            if constexpr (check_error_on_const_read(Opts)) {
   52|       |               ctx.error = error_code::attempt_const_read;
   53|       |            }
   54|       |            else {
   55|       |               // do not read anything into the const value
   56|       |               skip_value<JSON>::op<Opts>(std::forward<Ctx>(ctx), std::forward<It0>(it), end);
   57|       |            }
   58|       |         }
   59|   109k|         else {
   60|   109k|            using V = std::remove_cvref_t<T>;
   61|   109k|            from<JSON, V>::template op<Opts>(std::forward<T>(value), std::forward<Ctx>(ctx), std::forward<It0>(it),
   62|   109k|                                             end);
   63|   109k|         }
   64|   109k|      }
_ZN3glz4fromILj10ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELb0ERPKcSA_S5_TkNS_10is_contextERNS_7contextEQntcl22check_string_as_numberTL0__EEEvRT3_OT4_OT1_T2_:
 1864|   109k|      {
 1865|   109k|         if constexpr (!check_opening_handled(Opts)) {
 1866|   109k|            if constexpr (!check_ws_handled(Opts)) {
 1867|   109k|               if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (1867:20): [True: 0, False: 109k]
  ------------------
 1868|      0|                  return;
 1869|      0|               }
 1870|   109k|            }
 1871|       |
 1872|   109k|            if (match_invalid_end<'"', Opts>(ctx, it, end)) {
  ------------------
  |  Branch (1872:17): [True: 1.61k, False: 108k]
  ------------------
 1873|  1.61k|               return;
 1874|  1.61k|            }
 1875|   109k|         }
 1876|       |
 1877|   108k|         auto start = it;
 1878|   109k|         skip_string_view(ctx, it, end);
 1879|   109k|         if (bool(ctx.error)) [[unlikely]]
  ------------------
  |  Branch (1879:14): [True: 3, False: 109k]
  ------------------
 1880|      3|            return;
 1881|       |
 1882|   109k|         if (validate_utf8_span<Opts>(ctx, start, it)) [[unlikely]] {
  ------------------
  |  Branch (1882:14): [True: 37, False: 109k]
  ------------------
 1883|     37|            return;
 1884|     37|         }
 1885|       |
 1886|   109k|         if constexpr (string_view_t<T>) {
 1887|   109k|            if constexpr (!Transient) {
 1888|   109k|               GLZ_ASSERT_OWNS_ITS_BYTES(decltype(ctx));
  ------------------
  |  |  242|   109k|   static_assert(!::glz::has_streaming_state<Ctx>,                                                              \
  |  |  243|   109k|                 "This read fills a non-owning view (std::string_view, glz::raw_json_view, glz::text_view, or " \
  |  |  244|   109k|                 "a std::span) that would point into the streaming window. A streaming read refills that "      \
  |  |  245|   109k|                 "window as it goes, so the view would address overwritten bytes by the time the read "         \
  |  |  246|   109k|                 "returns, and the read would report success while handing back silently wrong data. Read "     \
  |  |  247|   109k|                 "into the owning equivalent instead (std::string, glz::raw_json, glz::text, or an owning "     \
  |  |  248|   109k|                 "container), or read from a buffer that holds the whole document.")
  ------------------
 1889|   109k|            }
 1890|   109k|            using value_type = typename std::decay_t<T>::value_type;
 1891|       |            if constexpr (std::same_as<value_type, char8_t>) {
 1892|       |               value = {reinterpret_cast<const char8_t*>(start), size_t(it - start)};
 1893|       |            }
 1894|   109k|            else {
 1895|   109k|               value = {start, size_t(it - start)};
 1896|   109k|            }
 1897|       |         }
 1898|       |         else if constexpr (char_array_t<T>) {
 1899|       |            const size_t n = it - start;
 1900|       |            if ((n + 1) > sizeof(value)) {
 1901|       |               ctx.error = error_code::unexpected_end;
 1902|       |               return;
 1903|       |            }
 1904|       |            std::memcpy(value, start, n);
 1905|       |            value[n] = '\0';
 1906|       |         }
 1907|       |         else if constexpr (array_char_t<T>) {
 1908|       |            const size_t n = it - start;
 1909|       |            if ((n + 1) > value.size()) {
 1910|       |               ctx.error = error_code::unexpected_end;
 1911|       |               return;
 1912|       |            }
 1913|       |            std::memcpy(value.data(), start, n);
 1914|       |            value[n] = '\0';
 1915|       |         }
 1916|       |         else if constexpr (static_string_t<T>) {
 1917|       |            const size_t n = it - start;
 1918|       |            if (n > value.capacity()) {
 1919|       |               ctx.error = error_code::unexpected_end;
 1920|       |               return;
 1921|       |            }
 1922|       |            value.assign(start, n);
 1923|       |         }
 1924|   109k|         ++it; // skip closing quote
 1925|   109k|         if constexpr (not Opts.null_terminated) {
 1926|   109k|            if (it == end) {
  ------------------
  |  Branch (1926:17): [True: 5, False: 109k]
  ------------------
 1927|      5|               ctx.error = error_code::end_reached;
 1928|      5|               return;
 1929|      5|            }
 1930|   109k|         }
 1931|   109k|      }
_ZN3glz24decode_index_unknown_keyITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENS_3rpc18request_envelope_tERS3_TkNS_10is_contextERNS_7contextERPKcS8_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT2_OT3_T4_:
  177|  8.01k|   {
  178|  8.01k|      if constexpr (Opts.error_on_unknown_keys) {
  179|  8.01k|         ctx.error = error_code::unknown_key;
  180|       |      }
  181|       |      else {
  182|       |         auto* start = it;
  183|       |         skip_string_view(ctx, it, end);
  184|       |         if (bool(ctx.error)) [[unlikely]]
  185|       |            return;
  186|       |         if (validate_utf8_span<Opts>(ctx, start, it)) [[unlikely]]
  187|       |            return;
  188|       |         const sv key = {start, size_t(it - start)};
  189|       |         ++it;
  190|       |         if constexpr (not Opts.null_terminated) {
  191|       |            if (it == end) [[unlikely]] {
  192|       |               ctx.error = error_code::unexpected_end;
  193|       |               return;
  194|       |            }
  195|       |         }
  196|       |
  197|       |         if (parse_ws_colon<Opts>(ctx, it, end)) {
  198|       |            return;
  199|       |         }
  200|       |
  201|       |         parse<JSON>::handle_unknown<Opts>(key, value, ctx, it, end);
  202|       |      }
  203|  8.01k|   }
_ZZN3glz16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENS_3rpc18request_envelope_tERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT3_OT4_OT5_DpOT2_ENKUlTnmvE_clILm1EEEDav:
  484|  52.1k|            visit<N>([&]<size_t I>() { decode_index<Opts, T, I>(value, ctx, it, end, selected_index...); }, index);
_ZN3glz12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENS_3rpc18request_envelope_tELm1ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT2_OT4_OT5_OT6_DpOT3_:
  311|  52.1k|   {
  312|  52.1k|      static constexpr auto Key = get<I>(reflect<T>::keys);
  313|  52.1k|      static constexpr auto KeyWithEndQuote = join_v<Key, chars<"\"">>;
  314|  52.1k|      static constexpr auto Length = KeyWithEndQuote.size();
  315|       |
  316|  52.1k|      if (((it + Length) < end) && comparitor<KeyWithEndQuote>(it)) [[likely]] {
  ------------------
  |  Branch (316:11): [True: 51.4k, False: 752]
  |  Branch (316:36): [True: 50.8k, False: 525]
  ------------------
  317|  50.8k|         it += Length;
  318|  50.8k|         if constexpr (not Opts.null_terminated) {
  319|  50.8k|            if (it == end) [[unlikely]] {
  ------------------
  |  Branch (319:17): [True: 0, False: 50.8k]
  ------------------
  320|      0|               ctx.error = error_code::unexpected_end;
  321|      0|               return;
  322|      0|            }
  323|  50.8k|         }
  324|       |
  325|  50.8k|         if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (325:14): [True: 0, False: 50.8k]
  ------------------
  326|      0|            return;
  327|      0|         }
  328|  50.8k|         if (match_invalid_end<':', Opts>(ctx, it, end)) {
  ------------------
  |  Branch (328:14): [True: 0, False: 50.8k]
  ------------------
  329|      0|            return;
  330|      0|         }
  331|  50.8k|         if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (331:14): [True: 0, False: 50.8k]
  ------------------
  332|      0|            return;
  333|      0|         }
  334|       |
  335|       |         // The hash path has already consumed the whitespace before the value
  336|  50.8k|         decode_field_value<Opts, ws_handled<Opts>(), T, I>(value, ctx, it, end, selected_index...);
  337|  50.8k|      }
  338|  1.27k|      else [[unlikely]] {
  339|  1.27k|         decode_index_unknown_key<Opts, T>(value, ctx, it, end);
  340|  1.27k|      }
  341|  52.1k|   }
_ZN3glz18decode_field_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnDaXtlS1_Lj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEENS_3rpc18request_envelope_tELm1ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT1_E11reflectableISA_EEEvOT3_OT5_OT6_OT7_DpOT4_:
  245|  50.8k|   {
  246|       |      // Check for null value skipping on read
  247|       |      if constexpr (check_skip_null_members_on_read(Opts)) {
  248|       |         if (*it == 'n') {
  249|       |            ++it;
  250|       |            if constexpr (not Opts.null_terminated) {
  251|       |               if (it == end) [[unlikely]] {
  252|       |                  ctx.error = error_code::unexpected_end;
  253|       |                  return;
  254|       |               }
  255|       |            }
  256|       |            match<"ull", Opts>(ctx, it, end);
  257|       |            if (bool(ctx.error)) [[unlikely]]
  258|       |               return;
  259|       |            // Successfully matched "null", skip it
  260|       |            if constexpr (Opts.error_on_missing_keys || Opts.partial_read) {
  261|       |               ((selected_index = I), ...); // Mark as handled even if skipped
  262|       |            }
  263|       |            return;
  264|       |         }
  265|       |      }
  266|       |
  267|       |      if constexpr (skipped_by_meta<T, I, operation::parse>) {
  268|       |         skip_value<JSON>::op<Opts>(ctx, it, end);
  269|       |         if (bool(ctx.error)) [[unlikely]]
  270|       |            return; // Propagate error from skip_value
  271|       |      }
  272|  50.8k|      else {
  273|  50.8k|         using V = refl_t<T, I>;
  274|       |
  275|       |         if constexpr (const_value_v<V>) {
  276|       |            if constexpr (check_error_on_const_read(Opts)) {
  277|       |               ctx.error = error_code::attempt_const_read;
  278|       |            }
  279|       |            else {
  280|       |               // do not read anything into the const value
  281|       |               skip_value<JSON>::op<Opts>(ctx, it, end);
  282|       |            }
  283|       |         }
  284|       |         else if constexpr (is_function_ptr_or_ref<V>) {
  285|       |            // Function pointers cannot be deserialized from JSON.
  286|       |            // When write_function_pointers is enabled the writer emits a type-name string,
  287|       |            // but there is nothing meaningful to reconstruct on read — just skip the value.
  288|       |            // When write_function_pointers is off the key is never written, so this branch
  289|       |            // is unreachable in that case.
  290|       |            skip_value<JSON>::op<Opts>(ctx, it, end);
  291|       |         }
  292|  50.8k|         else if constexpr (glaze_object_t<T>) {
  293|  50.8k|            from<JSON, std::remove_cvref_t<V>>::template op<FieldOpts>(get_member(value, get<I>(reflect<T>::values)),
  294|  50.8k|                                                                       ctx, it, end);
  295|       |         }
  296|       |         else {
  297|       |            from<JSON, std::remove_cvref_t<V>>::template op<FieldOpts>(get_member(value, get<I>(to_tie(value))), ctx,
  298|       |                                                                       it, end);
  299|       |         }
  300|  50.8k|      }
  301|       |
  302|       |      // The key was present and handled, even when the value itself was skipped
  303|       |      if constexpr (Opts.error_on_missing_keys || Opts.partial_read) {
  304|       |         ((selected_index = I), ...);
  305|       |      }
  306|  50.8k|   }
_ZZN3glz16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENS_3rpc18request_envelope_tERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT3_OT4_OT5_DpOT2_ENKUlTnmvE_clILm2EEEDav:
  484|  36.6k|            visit<N>([&]<size_t I>() { decode_index<Opts, T, I>(value, ctx, it, end, selected_index...); }, index);
_ZN3glz12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENS_3rpc18request_envelope_tELm2ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT2_OT4_OT5_OT6_DpOT3_:
  311|  36.6k|   {
  312|  36.6k|      static constexpr auto Key = get<I>(reflect<T>::keys);
  313|  36.6k|      static constexpr auto KeyWithEndQuote = join_v<Key, chars<"\"">>;
  314|  36.6k|      static constexpr auto Length = KeyWithEndQuote.size();
  315|       |
  316|  36.6k|      if (((it + Length) < end) && comparitor<KeyWithEndQuote>(it)) [[likely]] {
  ------------------
  |  Branch (316:11): [True: 36.3k, False: 234]
  |  Branch (316:36): [True: 36.1k, False: 263]
  ------------------
  317|  36.1k|         it += Length;
  318|  36.1k|         if constexpr (not Opts.null_terminated) {
  319|  36.1k|            if (it == end) [[unlikely]] {
  ------------------
  |  Branch (319:17): [True: 0, False: 36.1k]
  ------------------
  320|      0|               ctx.error = error_code::unexpected_end;
  321|      0|               return;
  322|      0|            }
  323|  36.1k|         }
  324|       |
  325|  36.1k|         if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (325:14): [True: 0, False: 36.1k]
  ------------------
  326|      0|            return;
  327|      0|         }
  328|  36.1k|         if (match_invalid_end<':', Opts>(ctx, it, end)) {
  ------------------
  |  Branch (328:14): [True: 0, False: 36.1k]
  ------------------
  329|      0|            return;
  330|      0|         }
  331|  36.1k|         if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (331:14): [True: 0, False: 36.1k]
  ------------------
  332|      0|            return;
  333|      0|         }
  334|       |
  335|       |         // The hash path has already consumed the whitespace before the value
  336|  36.1k|         decode_field_value<Opts, ws_handled<Opts>(), T, I>(value, ctx, it, end, selected_index...);
  337|  36.1k|      }
  338|    497|      else [[unlikely]] {
  339|    497|         decode_index_unknown_key<Opts, T>(value, ctx, it, end);
  340|    497|      }
  341|  36.6k|   }
_ZN3glz18decode_field_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnDaXtlS1_Lj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEENS_3rpc18request_envelope_tELm2ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT1_E11reflectableISA_EEEvOT3_OT5_OT6_OT7_DpOT4_:
  245|  36.1k|   {
  246|       |      // Check for null value skipping on read
  247|       |      if constexpr (check_skip_null_members_on_read(Opts)) {
  248|       |         if (*it == 'n') {
  249|       |            ++it;
  250|       |            if constexpr (not Opts.null_terminated) {
  251|       |               if (it == end) [[unlikely]] {
  252|       |                  ctx.error = error_code::unexpected_end;
  253|       |                  return;
  254|       |               }
  255|       |            }
  256|       |            match<"ull", Opts>(ctx, it, end);
  257|       |            if (bool(ctx.error)) [[unlikely]]
  258|       |               return;
  259|       |            // Successfully matched "null", skip it
  260|       |            if constexpr (Opts.error_on_missing_keys || Opts.partial_read) {
  261|       |               ((selected_index = I), ...); // Mark as handled even if skipped
  262|       |            }
  263|       |            return;
  264|       |         }
  265|       |      }
  266|       |
  267|       |      if constexpr (skipped_by_meta<T, I, operation::parse>) {
  268|       |         skip_value<JSON>::op<Opts>(ctx, it, end);
  269|       |         if (bool(ctx.error)) [[unlikely]]
  270|       |            return; // Propagate error from skip_value
  271|       |      }
  272|  36.1k|      else {
  273|  36.1k|         using V = refl_t<T, I>;
  274|       |
  275|       |         if constexpr (const_value_v<V>) {
  276|       |            if constexpr (check_error_on_const_read(Opts)) {
  277|       |               ctx.error = error_code::attempt_const_read;
  278|       |            }
  279|       |            else {
  280|       |               // do not read anything into the const value
  281|       |               skip_value<JSON>::op<Opts>(ctx, it, end);
  282|       |            }
  283|       |         }
  284|       |         else if constexpr (is_function_ptr_or_ref<V>) {
  285|       |            // Function pointers cannot be deserialized from JSON.
  286|       |            // When write_function_pointers is enabled the writer emits a type-name string,
  287|       |            // but there is nothing meaningful to reconstruct on read — just skip the value.
  288|       |            // When write_function_pointers is off the key is never written, so this branch
  289|       |            // is unreachable in that case.
  290|       |            skip_value<JSON>::op<Opts>(ctx, it, end);
  291|       |         }
  292|  36.1k|         else if constexpr (glaze_object_t<T>) {
  293|  36.1k|            from<JSON, std::remove_cvref_t<V>>::template op<FieldOpts>(get_member(value, get<I>(reflect<T>::values)),
  294|  36.1k|                                                                       ctx, it, end);
  295|       |         }
  296|       |         else {
  297|       |            from<JSON, std::remove_cvref_t<V>>::template op<FieldOpts>(get_member(value, get<I>(to_tie(value))), ctx,
  298|       |                                                                       it, end);
  299|       |         }
  300|  36.1k|      }
  301|       |
  302|       |      // The key was present and handled, even when the value itself was skipped
  303|       |      if constexpr (Opts.error_on_missing_keys || Opts.partial_read) {
  304|       |         ((selected_index = I), ...);
  305|       |      }
  306|  36.1k|   }
_ZZN3glz16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENS_3rpc18request_envelope_tERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT3_OT4_OT5_DpOT2_ENKUlTnmvE_clILm3EEEDav:
  484|  95.5k|            visit<N>([&]<size_t I>() { decode_index<Opts, T, I>(value, ctx, it, end, selected_index...); }, index);
_ZN3glz12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENS_3rpc18request_envelope_tELm3ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT2_OT4_OT5_OT6_DpOT3_:
  311|  95.5k|   {
  312|  95.5k|      static constexpr auto Key = get<I>(reflect<T>::keys);
  313|  95.5k|      static constexpr auto KeyWithEndQuote = join_v<Key, chars<"\"">>;
  314|  95.5k|      static constexpr auto Length = KeyWithEndQuote.size();
  315|       |
  316|  95.5k|      if (((it + Length) < end) && comparitor<KeyWithEndQuote>(it)) [[likely]] {
  ------------------
  |  Branch (316:11): [True: 95.3k, False: 209]
  |  Branch (316:36): [True: 91.2k, False: 4.11k]
  ------------------
  317|  91.2k|         it += Length;
  318|  91.2k|         if constexpr (not Opts.null_terminated) {
  319|  91.2k|            if (it == end) [[unlikely]] {
  ------------------
  |  Branch (319:17): [True: 0, False: 91.2k]
  ------------------
  320|      0|               ctx.error = error_code::unexpected_end;
  321|      0|               return;
  322|      0|            }
  323|  91.2k|         }
  324|       |
  325|  91.2k|         if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (325:14): [True: 2, False: 91.2k]
  ------------------
  326|      2|            return;
  327|      2|         }
  328|  91.2k|         if (match_invalid_end<':', Opts>(ctx, it, end)) {
  ------------------
  |  Branch (328:14): [True: 1.67k, False: 89.5k]
  ------------------
  329|  1.67k|            return;
  330|  1.67k|         }
  331|  89.5k|         if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (331:14): [True: 2, False: 89.5k]
  ------------------
  332|      2|            return;
  333|      2|         }
  334|       |
  335|       |         // The hash path has already consumed the whitespace before the value
  336|  89.5k|         decode_field_value<Opts, ws_handled<Opts>(), T, I>(value, ctx, it, end, selected_index...);
  337|  89.5k|      }
  338|  4.32k|      else [[unlikely]] {
  339|  4.32k|         decode_index_unknown_key<Opts, T>(value, ctx, it, end);
  340|  4.32k|      }
  341|  95.5k|   }
_ZN3glz18decode_field_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnDaXtlS1_Lj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEENS_3rpc18request_envelope_tELm3ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT1_E11reflectableISA_EEEvOT3_OT5_OT6_OT7_DpOT4_:
  245|  89.5k|   {
  246|       |      // Check for null value skipping on read
  247|       |      if constexpr (check_skip_null_members_on_read(Opts)) {
  248|       |         if (*it == 'n') {
  249|       |            ++it;
  250|       |            if constexpr (not Opts.null_terminated) {
  251|       |               if (it == end) [[unlikely]] {
  252|       |                  ctx.error = error_code::unexpected_end;
  253|       |                  return;
  254|       |               }
  255|       |            }
  256|       |            match<"ull", Opts>(ctx, it, end);
  257|       |            if (bool(ctx.error)) [[unlikely]]
  258|       |               return;
  259|       |            // Successfully matched "null", skip it
  260|       |            if constexpr (Opts.error_on_missing_keys || Opts.partial_read) {
  261|       |               ((selected_index = I), ...); // Mark as handled even if skipped
  262|       |            }
  263|       |            return;
  264|       |         }
  265|       |      }
  266|       |
  267|       |      if constexpr (skipped_by_meta<T, I, operation::parse>) {
  268|       |         skip_value<JSON>::op<Opts>(ctx, it, end);
  269|       |         if (bool(ctx.error)) [[unlikely]]
  270|       |            return; // Propagate error from skip_value
  271|       |      }
  272|  89.5k|      else {
  273|  89.5k|         using V = refl_t<T, I>;
  274|       |
  275|       |         if constexpr (const_value_v<V>) {
  276|       |            if constexpr (check_error_on_const_read(Opts)) {
  277|       |               ctx.error = error_code::attempt_const_read;
  278|       |            }
  279|       |            else {
  280|       |               // do not read anything into the const value
  281|       |               skip_value<JSON>::op<Opts>(ctx, it, end);
  282|       |            }
  283|       |         }
  284|       |         else if constexpr (is_function_ptr_or_ref<V>) {
  285|       |            // Function pointers cannot be deserialized from JSON.
  286|       |            // When write_function_pointers is enabled the writer emits a type-name string,
  287|       |            // but there is nothing meaningful to reconstruct on read — just skip the value.
  288|       |            // When write_function_pointers is off the key is never written, so this branch
  289|       |            // is unreachable in that case.
  290|       |            skip_value<JSON>::op<Opts>(ctx, it, end);
  291|       |         }
  292|  89.5k|         else if constexpr (glaze_object_t<T>) {
  293|  89.5k|            from<JSON, std::remove_cvref_t<V>>::template op<FieldOpts>(get_member(value, get<I>(reflect<T>::values)),
  294|  89.5k|                                                                       ctx, it, end);
  295|       |         }
  296|       |         else {
  297|       |            from<JSON, std::remove_cvref_t<V>>::template op<FieldOpts>(get_member(value, get<I>(to_tie(value))), ctx,
  298|       |                                                                       it, end);
  299|       |         }
  300|  89.5k|      }
  301|       |
  302|       |      // The key was present and handled, even when the value itself was skipped
  303|       |      if constexpr (Opts.error_on_missing_keys || Opts.partial_read) {
  304|       |         ((selected_index = I), ...);
  305|       |      }
  306|  89.5k|   }
_ZN3glz4fromILj10ENSt3__17variantIJDnNS1_17basic_string_viewIcNS1_11char_traitsIcEEEElEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEERS7_TkNS_10is_contextERNS_7contextERPKcSF_EEvOT0_OT1_OT2_T3_:
 4065|  89.5k|      {
 4066|       |         if constexpr (tagging == variant_tagging_kind::adjacent) {
 4067|       |            read_adjacent<Options>(value, ctx, it, end);
 4068|       |         }
 4069|  89.5k|         else {
 4070|  89.5k|            read_deduced<Options>(value, ctx, it, end);
 4071|  89.5k|         }
 4072|  89.5k|      }
_ZN3glz4fromILj10ENSt3__17variantIJDnNS1_17basic_string_viewIcNS1_11char_traitsIcEEEElEEEE12read_deducedITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEERS7_TkNS_10is_contextERNS_7contextERPKcSF_EEvOT0_OT1_OT2_T3_:
 4076|  89.5k|      {
 4077|  89.5k|         constexpr auto Opts = ws_handled_off<Options>();
 4078|  89.5k|         if constexpr (variant_is_auto_deducible<T>()) {
 4079|       |            if constexpr (not check_ws_handled(Options)) {
 4080|       |               if (skip_ws<Opts>(ctx, it, end)) {
 4081|       |                  return;
 4082|       |               }
 4083|       |            }
 4084|       |
 4085|  89.5k|            switch (*it) {
 4086|    249|            case '\0':
  ------------------
  |  Branch (4086:13): [True: 249, False: 89.3k]
  ------------------
 4087|    249|               ctx.error = error_code::unexpected_end;
 4088|    249|               return;
 4089|  1.39k|            case '{': {
  ------------------
  |  Branch (4089:13): [True: 1.39k, False: 88.1k]
  ------------------
 4090|       |               // This branch consumes the brace itself and hands the object to a reader with
 4091|       |               // `opening_handled`, which therefore does not count the level -- but does release it at
 4092|       |               // the closing brace. So the level is taken here, in both buffer modes, and paid back by
 4093|       |               // the reader below.
 4094|  1.39k|               if (enter_depth(ctx)) [[unlikely]] {
  ------------------
  |  Branch (4094:20): [True: 0, False: 1.39k]
  ------------------
 4095|      0|                  return;
 4096|      0|               }
 4097|       |
 4098|  1.39k|               ++it;
 4099|  1.39k|               if constexpr (not Opts.null_terminated) {
 4100|  1.39k|                  if (it == end) [[unlikely]] {
  ------------------
  |  Branch (4100:23): [True: 1, False: 1.39k]
  ------------------
 4101|      1|                     ctx.error = error_code::unexpected_end;
 4102|      1|                     return;
 4103|      1|                  }
 4104|  1.39k|               }
 4105|  1.39k|               using type_counts = variant_type_count<T>;
 4106|  1.39k|               constexpr auto n_object_candidates = variant_object_candidate_count_v<Opts, T>;
 4107|  1.39k|               if constexpr (n_object_candidates < 1) {
 4108|  1.39k|                  ctx.error = error_code::no_matching_variant_type;
 4109|  1.39k|                  return;
 4110|       |               }
 4111|       |               else if constexpr (n_object_candidates == 1 && tag_v<T>.empty()) {
 4112|       |                  constexpr auto first_idx = variant_first_object_candidate_v<Opts, T>;
 4113|       |                  using V = std::variant_alternative_t<first_idx, T>;
 4114|       |                  if (!std::holds_alternative<V>(value)) value = V{};
 4115|       |                  parse<JSON>::op<opening_handled<Opts>()>(std::get<V>(value), ctx, it, end);
 4116|       |                  return;
 4117|       |               }
 4118|       |               else {
 4119|       |                  auto possible_types = bit_array<std::variant_size_v<T>>{}.flip();
 4120|       |                  static constexpr auto& deduction_bits = variant_deduction_bits<T>;
 4121|       |                  static constexpr size_t deduction_key_count = variant_deduction_key_count<T>;
 4122|       |                  static constexpr auto tag_literal = string_literal_from_view<tag_v<T>.size()>(tag_v<T>);
 4123|       |
 4124|       |                  // Track if we've encountered a tag and what value it had
 4125|       |                  std::optional<size_t> tag_specified_index{};
 4126|       |
 4127|       |                  if (skip_ws<Opts>(ctx, it, end)) {
 4128|       |                     return;
 4129|       |                  }
 4130|       |                  // Once the reader knows which alternative this object holds it may have to read
 4131|       |                  // it again from here. Anchor the position rather than keep the pointer: the scan
 4132|       |                  // below skips values, and a streaming skip refills, which moves the window out
 4133|       |                  // from under a raw pointer (see rewind_anchor).
 4134|       |                  auto start = make_rewind_anchor(ctx, it);
 4135|       |                  bool first_key = true;
 4136|       |                  // Parse bifurcation for tagged variants:
 4137|       |                  //
 4138|       |                  // Without this optimization, tagged variant parsing always uses two passes:
 4139|       |                  //   1. Scan all keys to find the tag (e.g. "type"), skipping values
 4140|       |                  //   2. Reset `it = start` and re-parse the entire object into the resolved type
 4141|       |                  //
 4142|       |                  // When the tag is the first key, the second pass redundantly re-reads every
 4143|       |                  // field that follows it. This lambda avoids that: if the tag was the first key,
 4144|       |                  // it advances past the trailing comma so the object parser picks up at the
 4145|       |                  // second field. If the tag was found later, it falls back to the full re-parse.
 4146|       |                  //
 4147|       |                  // One exception: if the tag name is also a field on the resolved struct
 4148|       |                  // (contains_tag), we must re-parse regardless so the value is stored in
 4149|       |                  // the struct field. This override is applied inside each std::visit lambda.
 4150|       |                  //
 4151|       |                  // Either way the rewind can fail under a streaming read: the window only holds so
 4152|       |                  // much, and an object wider than it has no start left to return to.
 4153|       |                  auto position_after_tag = [&] {
 4154|       |                     if (first_key) {
 4155|       |                        if (*it == ',') ++it; // skip comma; handles tag-only objects where *it == '}'
 4156|       |                        return true;
 4157|       |                     }
 4158|       |                     return start.rewind(ctx, it, end); // tag came later, re-parse from the beginning
 4159|       |                  };
 4160|       |                  // `first_key` also answers "were we reset to the object start", which is what
 4161|       |                  // position_after_tag does for every key but the first.
 4162|       |                  for (; *it != '}'; first_key = false) {
 4163|       |                     if (!first_key) {
 4164|       |                        if (match_invalid_end<',', Opts>(ctx, it, end)) {
 4165|       |                           return;
 4166|       |                        }
 4167|       |                     }
 4168|       |
 4169|       |                     if (skip_ws<Opts>(ctx, it, end)) {
 4170|       |                        return;
 4171|       |                     }
 4172|       |                     if (match_invalid_end<'"', Opts>(ctx, it, end)) {
 4173|       |                        return;
 4174|       |                     }
 4175|       |
 4176|       |                     auto* key_start = it;
 4177|       |                     skip_string_view(ctx, it, end);
 4178|       |                     if (bool(ctx.error)) [[unlikely]]
 4179|       |                        return;
 4180|       |                     if (validate_utf8_span<Opts>(ctx, key_start, it)) [[unlikely]]
 4181|       |                        return;
 4182|       |                     const sv key = {key_start, size_t(it - key_start)};
 4183|       |
 4184|       |                     if (match_invalid_end<'"', Opts>(ctx, it, end)) {
 4185|       |                        return;
 4186|       |                     }
 4187|       |
 4188|       |                     if constexpr (deduction_key_count > 0) {
 4189|       |                        // We first check if a tag is defined and see if the key matches the tag
 4190|       |                        if constexpr (not tag_v<T>.empty()) {
 4191|       |                           if (key == tag_v<T>) {
 4192|       |                              if (parse_ws_colon<Opts>(ctx, it, end)) {
 4193|       |                                 return;
 4194|       |                              }
 4195|       |
 4196|       |                              using id_type = std::decay_t<decltype(ids_v<T>[0])>;
 4197|       |
 4198|       |                              std::conditional_t<std::integral<id_type>, id_type, sv> type_id{};
 4199|       |                              if constexpr (std::integral<id_type>) {
 4200|       |                                 from<JSON, id_type>::template op<ws_handled<Opts>()>(type_id, ctx, it, end);
 4201|       |                              }
 4202|       |                              else {
 4203|       |                                 // The id is turned into an index below and never leaves this
 4204|       |                                 // reader, so the view of the window it borrows cannot outlive it.
 4205|       |                                 parse_transient_string_view<ws_handled<Opts>()>(type_id, ctx, it, end);
 4206|       |                              }
 4207|       |                              if (bool(ctx.error)) [[unlikely]]
 4208|       |                                 return;
 4209|       |                              if (skip_ws<Opts>(ctx, it, end)) {
 4210|       |                                 return;
 4211|       |                              }
 4212|       |                              if (!(*it == ',' || *it == '}')) [[unlikely]] {
 4213|       |                                 ctx.error = error_code::syntax_error;
 4214|       |                                 return;
 4215|       |                              }
 4216|       |
 4217|       |                              size_t type_index;
 4218|       |                              if constexpr (std::integral<id_type>) {
 4219|       |                                 type_index = variant_id_to_index<T>::op(type_id);
 4220|       |                              }
 4221|       |                              else {
 4222|       |                                 type_index = variant_id_to_index<T>::op(
 4223|       |                                    type_id.data(), type_id.data() + type_id.size(), type_id.size());
 4224|       |                              }
 4225|       |                              if (type_index < ids_v<T>.size()) [[likely]] {
 4226|       |                                 // Check if the deduced types include the tag-specified type
 4227|       |                                 // If not, the tag doesn't match the fields
 4228|       |                                 // We're already inside if constexpr (deduction_registry.size()), so we know deduction
 4229|       |                                 // is happening. At this point, possible_types has been narrowed by field deduction.
 4230|       |                                 // Check if the tag-specified type is still possible
 4231|       |                                 const bool type_is_possible = possible_types[type_index];
 4232|       |                                 if (!type_is_possible) {
 4233|       |                                    // Tag specifies a type that doesn't match the fields seen so far
 4234|       |                                    ctx.error = error_code::no_matching_variant_type;
 4235|       |                                    return;
 4236|       |                                 }
 4237|       |
 4238|       |                                 if (!position_after_tag()) return;
 4239|       |                                 tag_specified_index = type_index; // Store the tag-specified type
 4240|       |                                 if (value.index() != type_index) emplace_runtime_variant(value, type_index);
 4241|       |                                 std::visit(
 4242|       |                                    [&](auto&& v) {
 4243|       |                                       using V = std::decay_t<decltype(v)>;
 4244|       |                                       constexpr bool is_object =
 4245|       |                                          (glaze_object_t<V> || reflectable<V>) && not custom_read<V>;
 4246|       |                                       if constexpr (variant_unit_alternative<V>) {
 4247|       |                                          // A unit alternative carries no data; its object holds only the
 4248|       |                                          // discriminator. Consume that body through an empty reflected object so
 4249|       |                                          // unknown-key policy and terminator handling match every other alternative.
 4250|       |                                          detail::variant_unit_body unit_body{};
 4251|       |                                          from<JSON, detail::variant_unit_body>::template op<opening_handled<Opts>(),
 4252|       |                                                                                             tag_literal>(unit_body,
 4253|       |                                                                                                          ctx, it, end);
 4254|       |                                       }
 4255|       |                                       else if constexpr (is_object) {
 4256|       |                                          if constexpr (contains_tag<V, tag_literal>()) {
 4257|       |                                             // tag is a struct field, must re-parse
 4258|       |                                             if (!start.rewind(ctx, it, end)) return;
 4259|       |                                          }
 4260|       |                                          from<JSON, V>::template op<opening_handled<Opts>(), tag_literal>(v, ctx, it,
 4261|       |                                                                                                           end);
 4262|       |                                       }
 4263|       |                                       else if constexpr (is_memory_object<V>) {
 4264|       |                                          if (!v) {
 4265|       |                                             if constexpr (is_specialization_v<V, std::optional>) {
 4266|       |                                                if constexpr (requires { v.emplace(); }) {
 4267|       |                                                   v.emplace();
 4268|       |                                                }
 4269|       |                                                else {
 4270|       |                                                   v = typename V::value_type{};
 4271|       |                                                }
 4272|       |                                             }
 4273|       |                                             else if constexpr (is_specialization_v<V, std::unique_ptr>)
 4274|       |                                                v = std::make_unique<typename V::element_type>();
 4275|       |                                             else if constexpr (is_specialization_v<V, std::shared_ptr>)
 4276|       |                                                v = std::make_shared<typename V::element_type>();
 4277|       |                                             else if constexpr (constructible<V>) {
 4278|       |                                                v = meta_construct_v<V>();
 4279|       |                                             }
 4280|       |                                             else if constexpr (std::is_pointer_v<V> &&
 4281|       |                                                                can_allocate_raw_pointer<Opts,
 4282|       |                                                                                         std::decay_t<decltype(ctx)>>) {
 4283|       |                                                if (!try_allocate_raw_pointer<Opts>(v, ctx)) {
 4284|       |                                                   return;
 4285|       |                                                }
 4286|       |                                             }
 4287|       |                                             else {
 4288|       |                                                ctx.error = error_code::invalid_nullable_read;
 4289|       |                                                return;
 4290|       |                                                // Cannot read into unset nullable that is not std::optional,
 4291|       |                                                // std::unique_ptr, or std::shared_ptr
 4292|       |                                             }
 4293|       |                                          }
 4294|       |                                          if constexpr (contains_tag<memory_type<V>, tag_literal>()) {
 4295|       |                                             // tag is a struct field, must re-parse
 4296|       |                                             if (!start.rewind(ctx, it, end)) return;
 4297|       |                                          }
 4298|       |                                          from<JSON, memory_type<V>>::template op<opening_handled<Opts>(), tag_literal>(
 4299|       |                                             *v, ctx, it, end);
 4300|       |                                       }
 4301|       |                                       else if constexpr (custom_read<V>) {
 4302|       |                                          // Custom handlers parse the remaining body themselves and do not
 4303|       |                                          // accept the tag template parameter; the tag was already consumed.
 4304|       |                                          // This only works when the tag was the first key. If it came later,
 4305|       |                                          // we were reset to the object start and the custom handler would
 4306|       |                                          // absorb the tag, so error rather than corrupt the value.
 4307|       |                                          if (!first_key) {
 4308|       |                                             ctx.error = error_code::feature_not_supported;
 4309|       |                                             ctx.custom_error_message =
 4310|       |                                                "the tag must be the first key for a custom variant alternative";
 4311|       |                                             return;
 4312|       |                                          }
 4313|       |                                          from<JSON, V>::template op<opening_handled<Opts>()>(v, ctx, it, end);
 4314|       |                                       }
 4315|       |                                    },
 4316|       |                                    value);
 4317|       |
 4318|       |                                 return; // we've decoded our target type
 4319|       |                              }
 4320|       |                              else [[unlikely]] {
 4321|       |                                 // Check if we have a default type (ids array shorter than variant)
 4322|       |                                 constexpr auto ids_size = ids_v<T>.size();
 4323|       |                                 constexpr auto variant_size = std::variant_size_v<T>;
 4324|       |                                 if constexpr (ids_size < variant_size) {
 4325|       |                                    // Use the first unlabeled type as the default
 4326|       |                                    const auto default_type_index = ids_size;
 4327|       |
 4328|       |                                    if (!position_after_tag()) return;
 4329|       |                                    tag_specified_index = default_type_index; // Store the default type index
 4330|       |                                    if (value.index() != default_type_index)
 4331|       |                                       emplace_runtime_variant(value, default_type_index);
 4332|       |                                    std::visit(
 4333|       |                                       [&](auto&& v) {
 4334|       |                                          using V = std::decay_t<decltype(v)>;
 4335|       |                                          constexpr bool is_object =
 4336|       |                                             (glaze_object_t<V> || reflectable<V>) && not custom_read<V>;
 4337|       |                                          if constexpr (variant_unit_alternative<V>) {
 4338|       |                                             // A unit alternative carries no data; its object holds only the
 4339|       |                                             // discriminator. Consume that body through an empty reflected object so
 4340|       |                                             // unknown-key policy and terminator handling match every other
 4341|       |                                             // alternative.
 4342|       |                                             detail::variant_unit_body unit_body{};
 4343|       |                                             from<JSON, detail::variant_unit_body>::template op<opening_handled<Opts>(),
 4344|       |                                                                                                tag_literal>(
 4345|       |                                                unit_body, ctx, it, end);
 4346|       |                                          }
 4347|       |                                          else if constexpr (is_object) {
 4348|       |                                             if constexpr (contains_tag<V, tag_literal>()) {
 4349|       |                                                // tag is a struct field, must re-parse
 4350|       |                                                if (!start.rewind(ctx, it, end)) return;
 4351|       |                                             }
 4352|       |                                             from<JSON, V>::template op<opening_handled<Opts>()>(v, ctx, it, end);
 4353|       |                                          }
 4354|       |                                          else if constexpr (is_memory_object<V>) {
 4355|       |                                             if (!v) {
 4356|       |                                                if constexpr (is_specialization_v<V, std::optional>) {
 4357|       |                                                   if constexpr (requires { v.emplace(); }) {
 4358|       |                                                      v.emplace();
 4359|       |                                                   }
 4360|       |                                                   else {
 4361|       |                                                      v = typename V::value_type{};
 4362|       |                                                   }
 4363|       |                                                }
 4364|       |                                                else if constexpr (is_specialization_v<V, std::unique_ptr>)
 4365|       |                                                   v = std::make_unique<typename V::element_type>();
 4366|       |                                                else if constexpr (is_specialization_v<V, std::shared_ptr>)
 4367|       |                                                   v = std::make_shared<typename V::element_type>();
 4368|       |                                                else if constexpr (constructible<V>) {
 4369|       |                                                   v = meta_construct_v<V>();
 4370|       |                                                }
 4371|       |                                                else if constexpr (std::is_pointer_v<V> &&
 4372|       |                                                                   can_allocate_raw_pointer<
 4373|       |                                                                      Opts, std::decay_t<decltype(ctx)>>) {
 4374|       |                                                   if (!try_allocate_raw_pointer<Opts>(v, ctx)) {
 4375|       |                                                      return;
 4376|       |                                                   }
 4377|       |                                                }
 4378|       |                                                else {
 4379|       |                                                   ctx.error = error_code::invalid_nullable_read;
 4380|       |                                                   return;
 4381|       |                                                }
 4382|       |                                             }
 4383|       |                                             if constexpr (contains_tag<memory_type<V>, tag_literal>()) {
 4384|       |                                                // tag is a struct field, must re-parse
 4385|       |                                                if (!start.rewind(ctx, it, end)) return;
 4386|       |                                             }
 4387|       |                                             from<JSON, memory_type<V>>::template op<opening_handled<Opts>()>(*v, ctx,
 4388|       |                                                                                                              it, end);
 4389|       |                                          }
 4390|       |                                          else if constexpr (custom_read<V>) {
 4391|       |                                             // Custom handlers parse the remaining body themselves; this only
 4392|       |                                             // works when the tag was the first key (see above). If it came
 4393|       |                                             // later we were reset to the object start, so error rather than
 4394|       |                                             // let the custom handler absorb the tag.
 4395|       |                                             if (!first_key) {
 4396|       |                                                ctx.error = error_code::feature_not_supported;
 4397|       |                                                ctx.custom_error_message =
 4398|       |                                                   "the tag must be the first key for a custom variant alternative";
 4399|       |                                                return;
 4400|       |                                             }
 4401|       |                                             from<JSON, V>::template op<opening_handled<Opts>()>(v, ctx, it, end);
 4402|       |                                          }
 4403|       |                                       },
 4404|       |                                       value);
 4405|       |
 4406|       |                                    return;
 4407|       |                                 }
 4408|       |                                 else {
 4409|       |                                    ctx.error = error_code::no_matching_variant_type;
 4410|       |                                    ctx.custom_error_message = variant_ids_string_v<T>;
 4411|       |                                    return;
 4412|       |                                 }
 4413|       |                              }
 4414|       |                           }
 4415|       |                        }
 4416|       |
 4417|       |                        // Inline decode_hash lookup for variant deduction
 4418|       |                        using deduction_keys_t = keys_wrapper<variant_deduction_keys<T>>;
 4419|       |                        constexpr auto& DeductionHashInfo = hash_info<deduction_keys_t>;
 4420|       |                        const auto deduction_index =
 4421|       |                           decode_hash_with_size<JSON, deduction_keys_t, DeductionHashInfo, DeductionHashInfo.type>::op(
 4422|       |                              key.data(), key.data() + key.size(), key.size());
 4423|       |                        if (deduction_index < deduction_key_count && variant_deduction_keys<T>[deduction_index] == key)
 4424|       |                           [[likely]] {
 4425|       |                           possible_types &= deduction_bits[deduction_index];
 4426|       |                        }
 4427|       |                        else if constexpr (Opts.error_on_unknown_keys) {
 4428|       |                           ctx.error = error_code::unknown_key;
 4429|       |                           return;
 4430|       |                        }
 4431|       |                     }
 4432|       |                     else if constexpr (not tag_v<T>.empty()) {
 4433|       |                        // empty object case for variant, if there are no normal elements
 4434|       |                        if (key == tag_v<T>) {
 4435|       |                           if (parse_ws_colon<Opts>(ctx, it, end)) {
 4436|       |                              return;
 4437|       |                           }
 4438|       |
 4439|       |                           // The id is turned into an index below and never leaves this reader,
 4440|       |                           // so the view of the window it borrows cannot outlive that window.
 4441|       |                           std::string_view type_id{};
 4442|       |                           parse_transient_string_view<ws_handled<Opts>()>(type_id, ctx, it, end);
 4443|       |                           if (bool(ctx.error)) [[unlikely]]
 4444|       |                              return;
 4445|       |                           if (skip_ws<Opts>(ctx, it, end)) {
 4446|       |                              return;
 4447|       |                           }
 4448|       |
 4449|       |                           const auto type_index = variant_id_to_index<T>::op(
 4450|       |                              type_id.data(), type_id.data() + type_id.size(), type_id.size());
 4451|       |                           if (type_index < ids_v<T>.size()) [[likely]] {
 4452|       |                              if (!position_after_tag()) return;
 4453|       |                              tag_specified_index = type_index; // Store the tag-specified type
 4454|       |                              if (value.index() != type_index) emplace_runtime_variant(value, type_index);
 4455|       |                           }
 4456|       |                           else {
 4457|       |                              // Check if we have a default type (ids array shorter than variant)
 4458|       |                              constexpr auto ids_size = ids_v<T>.size();
 4459|       |                              constexpr auto variant_size = std::variant_size_v<T>;
 4460|       |                              if constexpr (ids_size < variant_size) {
 4461|       |                                 // Use the first unlabeled type as the default
 4462|       |                                 if (!position_after_tag()) return;
 4463|       |                                 const auto default_index = ids_size;
 4464|       |                                 tag_specified_index = default_index; // Store the default type index
 4465|       |                                 if (value.index() != default_index) emplace_runtime_variant(value, default_index);
 4466|       |                              }
 4467|       |                              else {
 4468|       |                                 ctx.error = error_code::no_matching_variant_type;
 4469|       |                                 ctx.custom_error_message = variant_ids_string_v<T>;
 4470|       |                                 return;
 4471|       |                              }
 4472|       |                           }
 4473|       |                           // Parse the type (handles tag skipping and unknown keys)
 4474|       |                           std::visit(
 4475|       |                              [&](auto&& v) {
 4476|       |                                 using V = std::decay_t<decltype(v)>;
 4477|       |                                 if constexpr (custom_read<V>) {
 4478|       |                                    // Custom handlers parse the remaining object body themselves and do not
 4479|       |                                    // accept the tag template parameter that reflected objects use to skip an
 4480|       |                                    // interior tag key. That only works when the tag is the first key (it was
 4481|       |                                    // just consumed). If the tag came after other keys, position_after_tag()
 4482|       |                                    // reset us to the object start and the custom handler would absorb the tag
 4483|       |                                    // into its value, so error here rather than corrupt the result.
 4484|       |                                    if (!first_key) {
 4485|       |                                       ctx.error = error_code::feature_not_supported;
 4486|       |                                       ctx.custom_error_message =
 4487|       |                                          "the tag must be the first key for a custom variant alternative";
 4488|       |                                       return;
 4489|       |                                    }
 4490|       |                                    from<JSON, V>::template op<opening_handled<Opts>()>(v, ctx, it, end);
 4491|       |                                 }
 4492|       |                                 else {
 4493|       |                                    if constexpr (contains_tag<V, tag_literal>()) {
 4494|       |                                       // tag is a struct field, must re-parse
 4495|       |                                       if (!start.rewind(ctx, it, end)) return;
 4496|       |                                    }
 4497|       |                                    from<JSON, V>::template op<opening_handled<Opts>(), tag_literal>(v, ctx, it, end);
 4498|       |                                 }
 4499|       |                              },
 4500|       |                              value);
 4501|       |                           return;
 4502|       |                        }
 4503|       |                        else if constexpr (Opts.error_on_unknown_keys) {
 4504|       |                           ctx.error = error_code::unknown_key;
 4505|       |                           return;
 4506|       |                        }
 4507|       |                        else {
 4508|       |                           // Skip unknown key's value (non-tag key in empty variant)
 4509|       |                           if (parse_ws_colon<Opts>(ctx, it, end)) {
 4510|       |                              return;
 4511|       |                           }
 4512|       |                           skip_value<JSON>::op<Opts>(ctx, it, end);
 4513|       |                           if (bool(ctx.error)) [[unlikely]]
 4514|       |                              return;
 4515|       |                           resync_window_end(ctx, end); // a streaming skip refills
 4516|       |                           if (skip_ws<Opts>(ctx, it, end)) {
 4517|       |                              return;
 4518|       |                           }
 4519|       |                           continue; // Continue loop to find the tag
 4520|       |                        }
 4521|       |                     }
 4522|       |                     else if constexpr (Opts.error_on_unknown_keys) {
 4523|       |                        ctx.error = error_code::unknown_key;
 4524|       |                        return;
 4525|       |                     }
 4526|       |
 4527|       |                     auto matching_types = possible_types.popcount();
 4528|       |                     if (matching_types == 0) {
 4529|       |                        ctx.error = error_code::no_matching_variant_type;
 4530|       |                        return;
 4531|       |                     }
 4532|       |                     // Only short-circuit for variants without tags
 4533|       |                     else if constexpr (tag_v<T>.empty()) {
 4534|       |                        if (matching_types == 1) {
 4535|       |                           if (!start.rewind(ctx, it, end)) return;
 4536|       |                           const auto type_index = possible_types.countr_zero();
 4537|       |
 4538|       |                           if (value.index() != static_cast<size_t>(type_index))
 4539|       |                              emplace_runtime_variant(value, type_index);
 4540|       |                           std::visit(
 4541|       |                              [&](auto&& v) {
 4542|       |                                 using V = std::decay_t<decltype(v)>;
 4543|       |                                 constexpr bool is_object = (glaze_object_t<V> || reflectable<V>) && not custom_read<V>;
 4544|       |                                 if constexpr (variant_unit_alternative<V>) {
 4545|       |                                    // A unit alternative carries no data; its object holds only the discriminator.
 4546|       |                                    // Consume that body through an empty reflected object so unknown-key policy and
 4547|       |                                    // terminator handling match every other alternative.
 4548|       |                                    detail::variant_unit_body unit_body{};
 4549|       |                                    from<JSON, detail::variant_unit_body>::template op<opening_handled<Opts>(),
 4550|       |                                                                                       tag_literal>(unit_body, ctx, it,
 4551|       |                                                                                                    end);
 4552|       |                                 }
 4553|       |                                 else if constexpr (is_object) {
 4554|       |                                    from<JSON, V>::template op<opening_handled<Opts>(), tag_literal>(v, ctx, it, end);
 4555|       |                                 }
 4556|       |                                 else if constexpr (is_memory_object<V>) {
 4557|       |                                    if (!v) {
 4558|       |                                       if constexpr (is_specialization_v<V, std::optional>) {
 4559|       |                                          if constexpr (requires { v.emplace(); }) {
 4560|       |                                             v.emplace();
 4561|       |                                          }
 4562|       |                                          else {
 4563|       |                                             v = typename V::value_type{};
 4564|       |                                          }
 4565|       |                                       }
 4566|       |                                       else if constexpr (is_specialization_v<V, std::unique_ptr>)
 4567|       |                                          v = std::make_unique<typename V::element_type>();
 4568|       |                                       else if constexpr (is_specialization_v<V, std::shared_ptr>)
 4569|       |                                          v = std::make_shared<typename V::element_type>();
 4570|       |                                       else if constexpr (constructible<V>) {
 4571|       |                                          v = meta_construct_v<V>();
 4572|       |                                       }
 4573|       |                                       else if constexpr (std::is_pointer_v<V> &&
 4574|       |                                                          can_allocate_raw_pointer<Opts, std::decay_t<decltype(ctx)>>) {
 4575|       |                                          if (!try_allocate_raw_pointer<Opts>(v, ctx)) {
 4576|       |                                             return;
 4577|       |                                          }
 4578|       |                                       }
 4579|       |                                       else {
 4580|       |                                          ctx.error = error_code::invalid_nullable_read;
 4581|       |                                          return;
 4582|       |                                          // Cannot read into unset nullable that is not std::optional,
 4583|       |                                          // std::unique_ptr, or std::shared_ptr
 4584|       |                                       }
 4585|       |                                    }
 4586|       |                                    from<JSON, memory_type<V>>::template op<opening_handled<Opts>(), tag_literal>(
 4587|       |                                       *v, ctx, it, end);
 4588|       |                                 }
 4589|       |                                 else if constexpr (custom_read<V>) {
 4590|       |                                    // Custom handlers parse the remaining body themselves.
 4591|       |                                    from<JSON, V>::template op<opening_handled<Opts>()>(v, ctx, it, end);
 4592|       |                                 }
 4593|       |                              },
 4594|       |                              value);
 4595|       |
 4596|       |                           return; // we've decoded our target type
 4597|       |                        }
 4598|       |                     }
 4599|       |                     // For tagged variants, continue processing to validate tags
 4600|       |                     if (parse_ws_colon<Opts>(ctx, it, end)) {
 4601|       |                        return;
 4602|       |                     }
 4603|       |
 4604|       |                     skip_value<JSON>::op<Opts>(ctx, it, end);
 4605|       |                     if (bool(ctx.error)) [[unlikely]]
 4606|       |                        return;
 4607|       |                     resync_window_end(ctx, end); // a streaming skip refills
 4608|       |                     if (skip_ws<Opts>(ctx, it, end)) {
 4609|       |                        return;
 4610|       |                     }
 4611|       |                  }
 4612|       |                  // Only apply ambiguous variant resolution if we have multiple object types
 4613|       |                  if constexpr ((type_counts::n_object + type_counts::n_nullable_object) > 1) {
 4614|       |                     // After parsing all keys, check if we have multiple matching types
 4615|       |                     // If so, choose the one with the fewest fields
 4616|       |                     auto final_matching = possible_types.popcount();
 4617|       |                     if (final_matching == 0) {
 4618|       |                        ctx.error = error_code::no_matching_variant_type;
 4619|       |                     }
 4620|       |                     else if (final_matching == 1) {
 4621|       |                        // Single type remains after field deduction
 4622|       |                        const auto type_index = possible_types.countr_zero();
 4623|       |
 4624|       |                        // Validate against tag if one was specified
 4625|       |                        if (tag_specified_index.has_value() &&
 4626|       |                            tag_specified_index.value() != static_cast<size_t>(type_index)) {
 4627|       |                           ctx.error = error_code::no_matching_variant_type;
 4628|       |                           return;
 4629|       |                        }
 4630|       |
 4631|       |                        if (!start.rewind(ctx, it, end)) return;
 4632|       |                        if (value.index() != static_cast<size_t>(type_index))
 4633|       |                           emplace_runtime_variant(value, type_index);
 4634|       |                        std::visit(
 4635|       |                           [&](auto&& v) {
 4636|       |                              using V = std::decay_t<decltype(v)>;
 4637|       |                              constexpr bool is_object = (glaze_object_t<V> || reflectable<V>) && not custom_read<V>;
 4638|       |                              if constexpr (variant_unit_alternative<V>) {
 4639|       |                                 // A unit alternative carries no data; its object holds only the discriminator.
 4640|       |                                 // Consume that body through an empty reflected object so unknown-key policy and
 4641|       |                                 // terminator handling match every other alternative.
 4642|       |                                 detail::variant_unit_body unit_body{};
 4643|       |                                 from<JSON, detail::variant_unit_body>::template op<opening_handled<Opts>(),
 4644|       |                                                                                    tag_literal>(unit_body, ctx, it,
 4645|       |                                                                                                 end);
 4646|       |                              }
 4647|       |                              else if constexpr (is_object) {
 4648|       |                                 from<JSON, V>::template op<opening_handled<Opts>(), tag_literal>(v, ctx, it, end);
 4649|       |                              }
 4650|       |                              else if constexpr (is_memory_object<V>) {
 4651|       |                                 if (!v) {
 4652|       |                                    if constexpr (is_specialization_v<V, std::optional>) {
 4653|       |                                       if constexpr (requires { v.emplace(); }) {
 4654|       |                                          v.emplace();
 4655|       |                                       }
 4656|       |                                       else {
 4657|       |                                          v = typename V::value_type{};
 4658|       |                                       }
 4659|       |                                    }
 4660|       |                                    else if constexpr (is_specialization_v<V, std::unique_ptr>)
 4661|       |                                       v = std::make_unique<typename V::element_type>();
 4662|       |                                    else if constexpr (is_specialization_v<V, std::shared_ptr>)
 4663|       |                                       v = std::make_shared<typename V::element_type>();
 4664|       |                                    else if constexpr (constructible<V>) {
 4665|       |                                       v = meta_construct_v<V>();
 4666|       |                                    }
 4667|       |                                    else if constexpr (std::is_pointer_v<V> &&
 4668|       |                                                       can_allocate_raw_pointer<Opts, std::decay_t<decltype(ctx)>>) {
 4669|       |                                       if (!try_allocate_raw_pointer<Opts>(v, ctx)) {
 4670|       |                                          return;
 4671|       |                                       }
 4672|       |                                    }
 4673|       |                                    else {
 4674|       |                                       ctx.error = error_code::invalid_nullable_read;
 4675|       |                                       return;
 4676|       |                                    }
 4677|       |                                 }
 4678|       |                                 from<JSON, memory_type<V>>::template op<opening_handled<Opts>(), tag_literal>(*v, ctx,
 4679|       |                                                                                                               it, end);
 4680|       |                              }
 4681|       |                              else if constexpr (custom_read<V>) {
 4682|       |                                 // Custom handlers parse the remaining body themselves.
 4683|       |                                 from<JSON, V>::template op<opening_handled<Opts>()>(v, ctx, it, end);
 4684|       |                              }
 4685|       |                           },
 4686|       |                           value);
 4687|       |                     }
 4688|       |                     else if (final_matching > 1) {
 4689|       |                        constexpr auto N = std::variant_size_v<T>;
 4690|       |
 4691|       |                        // Compile-time array of field counts for each variant type
 4692|       |                        constexpr auto field_counts = []<size_t... I>(std::index_sequence<I...>) {
 4693|       |                           return std::array<size_t, N> {
 4694|       |                              ([]<size_t J = I>() -> size_t {
 4695|       |                                 using V = std::decay_t<std::variant_alternative_t<J, T>>;
 4696|       |                                 if constexpr (glaze_object_t<V> || reflectable<V>) {
 4697|       |                                    return reflect<V>::size;
 4698|       |                                 }
 4699|       |                                 else if constexpr (is_memory_object<V>) {
 4700|       |                                    using X = memory_type<V>;
 4701|       |                                    if constexpr (glaze_object_t<X> || reflectable<X>) {
 4702|       |                                       return reflect<X>::size;
 4703|       |                                    }
 4704|       |                                    else {
 4705|       |                                       return (std::numeric_limits<size_t>::max)();
 4706|       |                                    }
 4707|       |                                 }
 4708|       |                                 else {
 4709|       |                                    return (std::numeric_limits<size_t>::max)();
 4710|       |                                 }
 4711|       |                              }.template operator()<I>())...
 4712|       |                           };
 4713|       |                        }(std::make_index_sequence<N>{});
 4714|       |
 4715|       |                        // Find the type with minimum field count among the possible types
 4716|       |                        size_t min_fields = (std::numeric_limits<size_t>::max)();
 4717|       |                        size_t chosen_index = N; // Invalid index initially
 4718|       |
 4719|       |                        for (size_t i = 0; i < N; ++i) {
 4720|       |                           if (possible_types[i] && field_counts[i] < min_fields) {
 4721|       |                              min_fields = field_counts[i];
 4722|       |                              chosen_index = i;
 4723|       |                           }
 4724|       |                        }
 4725|       |
 4726|       |                        if (chosen_index < N) {
 4727|       |                           // Validate against tag if one was specified
 4728|       |                           if (tag_specified_index.has_value() && tag_specified_index.value() != chosen_index) {
 4729|       |                              ctx.error = error_code::no_matching_variant_type;
 4730|       |                              return;
 4731|       |                           }
 4732|       |
 4733|       |                           if (!start.rewind(ctx, it, end)) return;
 4734|       |                           if (value.index() != chosen_index) emplace_runtime_variant(value, chosen_index);
 4735|       |                           std::visit(
 4736|       |                              [&](auto&& v) {
 4737|       |                                 using V = std::decay_t<decltype(v)>;
 4738|       |                                 constexpr bool is_object = (glaze_object_t<V> || reflectable<V>) && not custom_read<V>;
 4739|       |                                 if constexpr (variant_unit_alternative<V>) {
 4740|       |                                    // A unit alternative carries no data; its object holds only the discriminator.
 4741|       |                                    // Consume that body through an empty reflected object so unknown-key policy and
 4742|       |                                    // terminator handling match every other alternative.
 4743|       |                                    detail::variant_unit_body unit_body{};
 4744|       |                                    from<JSON, detail::variant_unit_body>::template op<opening_handled<Opts>(),
 4745|       |                                                                                       tag_literal>(unit_body, ctx, it,
 4746|       |                                                                                                    end);
 4747|       |                                 }
 4748|       |                                 else if constexpr (is_object) {
 4749|       |                                    from<JSON, V>::template op<opening_handled<Opts>(), tag_literal>(v, ctx, it, end);
 4750|       |                                 }
 4751|       |                                 else if constexpr (is_memory_object<V>) {
 4752|       |                                    if (!v) {
 4753|       |                                       if constexpr (is_specialization_v<V, std::optional>) {
 4754|       |                                          if constexpr (requires { v.emplace(); }) {
 4755|       |                                             v.emplace();
 4756|       |                                          }
 4757|       |                                          else {
 4758|       |                                             v = typename V::value_type{};
 4759|       |                                          }
 4760|       |                                       }
 4761|       |                                       else if constexpr (is_specialization_v<V, std::unique_ptr>)
 4762|       |                                          v = std::make_unique<typename V::element_type>();
 4763|       |                                       else if constexpr (is_specialization_v<V, std::shared_ptr>)
 4764|       |                                          v = std::make_shared<typename V::element_type>();
 4765|       |                                       else if constexpr (constructible<V>) {
 4766|       |                                          v = meta_construct_v<V>();
 4767|       |                                       }
 4768|       |                                       else if constexpr (std::is_pointer_v<V> &&
 4769|       |                                                          can_allocate_raw_pointer<Opts, std::decay_t<decltype(ctx)>>) {
 4770|       |                                          if (!try_allocate_raw_pointer<Opts>(v, ctx)) {
 4771|       |                                             return;
 4772|       |                                          }
 4773|       |                                       }
 4774|       |                                       else {
 4775|       |                                          ctx.error = error_code::invalid_nullable_read;
 4776|       |                                          return;
 4777|       |                                       }
 4778|       |                                    }
 4779|       |                                    from<JSON, memory_type<V>>::template op<opening_handled<Opts>(), tag_literal>(
 4780|       |                                       *v, ctx, it, end);
 4781|       |                                 }
 4782|       |                                 else if constexpr (custom_read<V>) {
 4783|       |                                    // Custom handlers parse the remaining body themselves.
 4784|       |                                    from<JSON, V>::template op<opening_handled<Opts>()>(v, ctx, it, end);
 4785|       |                                 }
 4786|       |                              },
 4787|       |                              value);
 4788|       |                        }
 4789|       |                        else {
 4790|       |                           ctx.error = error_code::no_matching_variant_type;
 4791|       |                        }
 4792|       |                     }
 4793|       |                  }
 4794|       |                  else {
 4795|       |                     // For variants with 0 or 1 object types, use the original error handling
 4796|       |                     ctx.error = error_code::no_matching_variant_type;
 4797|       |                  }
 4798|       |               }
 4799|      0|               break;
 4800|  1.39k|            }
 4801|  4.27k|            case '[':
  ------------------
  |  Branch (4801:13): [True: 4.27k, False: 85.2k]
  ------------------
 4802|       |               // As with '{' above: the array reader each alternative goes through counts the level.
 4803|  4.27k|               process_variant_alternatives<T, is_variant_array>::template op<Opts>(value, ctx, it, end);
 4804|  4.27k|               break;
 4805|  8.04k|            case '"': {
  ------------------
  |  Branch (4805:13): [True: 8.04k, False: 81.5k]
  ------------------
 4806|  8.04k|               process_variant_alternatives<T, is_variant_str>::template op<Opts>(value, ctx, it, end);
 4807|  8.04k|               break;
 4808|  1.39k|            }
 4809|    685|            case 't':
  ------------------
  |  Branch (4809:13): [True: 685, False: 88.8k]
  ------------------
 4810|  2.18k|            case 'f': {
  ------------------
  |  Branch (4810:13): [True: 1.50k, False: 88.0k]
  ------------------
 4811|  2.18k|               process_variant_alternatives<T, is_variant_bool>::template op<Opts>(value, ctx, it, end);
 4812|  2.18k|               break;
 4813|    685|            }
 4814|  1.51k|            case 'n':
  ------------------
  |  Branch (4814:13): [True: 1.51k, False: 88.0k]
  ------------------
 4815|       |               if constexpr (variant_count_v<T, is_variant_null> == 0) {
 4816|       |                  ctx.error = error_code::no_matching_variant_type;
 4817|       |               }
 4818|  1.51k|               else {
 4819|  1.51k|                  constexpr auto first_idx = variant_first_index_v<T, is_variant_null>;
 4820|  1.51k|                  using V = std::variant_alternative_t<first_idx, T>;
 4821|  1.51k|                  if (!std::holds_alternative<V>(value)) value = V{};
  ------------------
  |  Branch (4821:23): [True: 217, False: 1.29k]
  ------------------
 4822|  1.51k|                  match<"null", Opts>(ctx, it, end);
 4823|  1.51k|               }
 4824|  1.51k|               break;
 4825|  71.8k|            default: {
  ------------------
  |  Branch (4825:13): [True: 71.8k, False: 17.6k]
  ------------------
 4826|       |               // Not bool, string, object, or array so must be number or null
 4827|  71.8k|               process_variant_alternatives<T, is_variant_num>::template op<Opts>(value, ctx, it, end);
 4828|  71.8k|            }
 4829|  89.5k|            }
 4830|       |         }
 4831|       |         else {
 4832|       |            // For non-auto-deducible variants, try each type until one succeeds
 4833|       |            constexpr auto N = std::variant_size_v<T>;
 4834|       |            bool parsed = false;
 4835|       |            bool exhausted = false; // speculation budget spent; see charge_speculation
 4836|       |
 4837|       |            for_each<N>([&]<size_t I>() {
 4838|       |               if (parsed || exhausted || variant_alternative_exhausted(ctx)) return;
 4839|       |
 4840|       |               auto copy_it = it;
 4841|       |               // A rejected alternative may have bailed out inside a container, which leaves its
 4842|       |               // nesting level counted (see enter_depth), so the depth rewinds with the iterator.
 4843|       |               const auto copy_depth = ctx.depth;
 4844|       |
 4845|       |               // Try parsing as this type
 4846|       |               if (value.index() != I) {
 4847|       |                  emplace_runtime_variant(value, I);
 4848|       |               }
 4849|       |
 4850|       |               std::visit([&](auto&& v) { parse<JSON>::op<Options>(v, ctx, it, end); }, value);
 4851|       |               if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) {
 4852|       |                  exhausted = true; // only rejected attempts are charged; see charge_speculation
 4853|       |               }
 4854|       |
 4855|       |               if (!bool(ctx.error)) {
 4856|       |                  parsed = true;
 4857|       |               }
 4858|       |               else if constexpr (not Options.null_terminated) {
 4859|       |                  // In non-null-terminated mode, if we hit end_reached after advancing the iterator,
 4860|       |                  // it means we successfully parsed the value but couldn't skip trailing whitespace
 4861|       |                  if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) {
 4862|       |                     // We advanced the iterator, so we did parse something -- unless what advanced it
 4863|       |                     // was an abandoned attempt, which is what a spent speculation budget means.
 4864|       |                     parsed = true;
 4865|       |                     ctx.error = error_code::none;
 4866|       |                  }
 4867|       |                  else {
 4868|       |                     // Reset for next attempt (unless this is the last type)
 4869|       |                     it = copy_it;
 4870|       |                     rewind_depth<Options>(ctx, copy_depth);
 4871|       |                     if constexpr (I + 1 < N) {
 4872|       |                        if (not exhausted && not variant_alternative_exhausted(ctx)) {
 4873|       |                           ctx.error = error_code::none; // Clear error for next attempt
 4874|       |                        }
 4875|       |                     }
 4876|       |                  }
 4877|       |               }
 4878|       |               else {
 4879|       |                  // Reset for next attempt (unless this is the last type)
 4880|       |                  it = copy_it;
 4881|       |                  rewind_depth<Options>(ctx, copy_depth);
 4882|       |                  if constexpr (I + 1 < N) {
 4883|       |                     if (not exhausted && not variant_alternative_exhausted(ctx)) {
 4884|       |                        ctx.error = error_code::none; // Clear error for next attempt
 4885|       |                     }
 4886|       |                  }
 4887|       |               }
 4888|       |            });
 4889|       |         }
 4890|  89.5k|      }
_ZN3glz28process_variant_alternativesINSt3__17variantIJDnNS1_17basic_string_viewIcNS1_11char_traitsIcEEEElEEENS_16is_variant_arrayEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS7_TkNS_10is_contextERNS_7contextERPKcSG_EEvOT0_OT1_OT2_T3_:
 3725|  6.57k|      {
 3726|  6.57k|         constexpr auto category_count = variant_count_v<Variant, Trait>;
 3727|       |
 3728|  6.57k|         if constexpr (category_count == 0) {
 3729|  6.57k|            ctx.error = error_code::no_matching_variant_type;
 3730|       |         }
 3731|       |         else {
 3732|       |            constexpr auto N = std::variant_size_v<Variant>;
 3733|       |            constexpr auto const_count = variant_filtered_count_v<Variant, Trait, true>;
 3734|       |            constexpr auto non_const_count = variant_filtered_count_v<Variant, Trait, false>;
 3735|       |
 3736|       |            bool found_match{};
 3737|       |            // Set when the speculative parsing budget runs out; see charge_speculation. An ambiguous
 3738|       |            // nest re-parses the same subtree per alternative at every level, which is exponential,
 3739|       |            // so the budget stops it and the failure already in hand is reported.
 3740|       |            bool exhausted{};
 3741|       |
 3742|       |            // First pass: const glaze types in this category
 3743|       |            if constexpr (const_count > 0) {
 3744|       |               for_each<N>([&]<size_t I>() {
 3745|       |                  if (found_match || exhausted || variant_alternative_exhausted(ctx)) {
 3746|       |                     return;
 3747|       |                  }
 3748|       |                  using V = std::variant_alternative_t<I, Variant>;
 3749|       |                  if constexpr (Trait<V>::value && glaze_const_value_t<V>) {
 3750|       |                     // run time substitute to compare to const value
 3751|       |                     std::remove_const_t<std::remove_pointer_t<std::remove_const_t<meta_wrapper_t<V>>>> substitute{};
 3752|       |                     auto copy_it{it};
 3753|       |                     // A rejected alternative may have bailed out inside a container, which leaves its
 3754|       |                     // nesting level counted (see enter_depth). Rewind the depth with the iterator so
 3755|       |                     // trying N alternatives cannot spend N levels of the recursion budget.
 3756|       |                     const auto copy_depth{ctx.depth};
 3757|       |                     parse<JSON>::op<ws_handled<Options>()>(substitute, ctx, it, end);
 3758|       |                     static constexpr auto const_value{*meta_wrapper_v<V>};
 3759|       |                     if (substitute == const_value) {
 3760|       |                        found_match = true;
 3761|       |                        if (!std::holds_alternative<V>(value)) {
 3762|       |                           value = V{};
 3763|       |                        }
 3764|       |                     }
 3765|       |                     else {
 3766|       |                        // Rejected: charge the bytes it parsed before we rewind. See charge_speculation.
 3767|       |                        if (!charge_speculation(ctx, size_t(it - copy_it))) {
 3768|       |                           exhausted = true;
 3769|       |                        }
 3770|       |                        if constexpr (not Options.null_terminated) {
 3771|       |                           if (ctx.error == error_code::end_reached && not exhausted) {
 3772|       |                              ctx.error = error_code::none;
 3773|       |                           }
 3774|       |                        }
 3775|       |                        it = copy_it;
 3776|       |                        rewind_depth<Options>(ctx, copy_depth);
 3777|       |                     }
 3778|       |                  }
 3779|       |               });
 3780|       |               if (found_match) {
 3781|       |                  return;
 3782|       |               }
 3783|       |            }
 3784|       |
 3785|       |            // Second pass: non-const types in this category
 3786|       |            if constexpr (non_const_count > 0) {
 3787|       |               // Track position within matching types for "is last" check.
 3788|       |               // We iterate over all variant indices but only process matching types,
 3789|       |               // so we need runtime tracking (vs the old tuple-based approach where
 3790|       |               // the loop index directly corresponded to position in filtered set).
 3791|       |               // This has negligible cost: one increment per matching type.
 3792|       |               size_t non_const_idx = 0;
 3793|       |
 3794|       |               for_each<N>([&]<size_t I>() {
 3795|       |                  if (found_match || exhausted || variant_alternative_exhausted(ctx)) {
 3796|       |                     return;
 3797|       |                  }
 3798|       |                  using V = std::variant_alternative_t<I, Variant>;
 3799|       |                  if constexpr (Trait<V>::value && !glaze_const_value_t<V>) {
 3800|       |                     auto copy_it{it};
 3801|       |                     const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above
 3802|       |                     if (!std::holds_alternative<V>(value)) {
 3803|       |                        value = V{};
 3804|       |                     }
 3805|       |                     parse<JSON>::op<ws_handled<Options>()>(std::get<V>(value), ctx, it, end);
 3806|       |                     if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) {
 3807|       |                        exhausted = true; // only rejected attempts are charged; see charge_speculation
 3808|       |                     }
 3809|       |                     if (!bool(ctx.error)) {
 3810|       |                        found_match = true;
 3811|       |                     }
 3812|       |                     else if constexpr (not Options.null_terminated) {
 3813|       |                        constexpr bool is_complete_type =
 3814|       |                           num_t<V> || bool_t<V> || string_t<V> || std::is_enum_v<V> || tuple_t<V> || is_std_tuple<V>;
 3815|       |
 3816|       |                        if constexpr (is_complete_type) {
 3817|       |                           if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) {
 3818|       |                              found_match = true;
 3819|       |                              ctx.error = error_code::none;
 3820|       |                           }
 3821|       |                           else {
 3822|       |                              it = copy_it;
 3823|       |                              rewind_depth<Options>(ctx, copy_depth);
 3824|       |                              if (non_const_idx + 1 < non_const_count && not exhausted &&
 3825|       |                                  not variant_alternative_exhausted(ctx)) {
 3826|       |                                 ctx.error = error_code::none;
 3827|       |                              }
 3828|       |                           }
 3829|       |                        }
 3830|       |                        else {
 3831|       |                           it = copy_it;
 3832|       |                           rewind_depth<Options>(ctx, copy_depth);
 3833|       |                           if (non_const_idx + 1 < non_const_count && not exhausted &&
 3834|       |                               not variant_alternative_exhausted(ctx)) {
 3835|       |                              ctx.error = error_code::none;
 3836|       |                           }
 3837|       |                        }
 3838|       |                     }
 3839|       |                     else {
 3840|       |                        it = copy_it;
 3841|       |                        rewind_depth<Options>(ctx, copy_depth);
 3842|       |                        if (non_const_idx + 1 < non_const_count && not exhausted &&
 3843|       |                            not variant_alternative_exhausted(ctx)) {
 3844|       |                           ctx.error = error_code::none;
 3845|       |                        }
 3846|       |                     }
 3847|       |                     ++non_const_idx;
 3848|       |                  }
 3849|       |               });
 3850|       |               if (!found_match) {
 3851|       |                  if constexpr (non_const_count == 1) {
 3852|       |                     // Keep the specific error from the single type we tried
 3853|       |                  }
 3854|       |                  else if (not exhausted && not variant_alternative_exhausted(ctx)) {
 3855|       |                     // Over-nested input is not a failure of the alternative set; keep saying so.
 3856|       |                     ctx.error = error_code::no_matching_variant_type;
 3857|       |                  }
 3858|       |               }
 3859|       |            }
 3860|       |            else {
 3861|       |               ctx.error = error_code::no_matching_variant_type;
 3862|       |            }
 3863|       |         }
 3864|  6.57k|      }
_ZN3glz28process_variant_alternativesINSt3__17variantIJDnNS1_17basic_string_viewIcNS1_11char_traitsIcEEEElEEENS_14is_variant_strEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS7_TkNS_10is_contextERNS_7contextERPKcSG_EEvOT0_OT1_OT2_T3_:
 3725|  9.00k|      {
 3726|  9.00k|         constexpr auto category_count = variant_count_v<Variant, Trait>;
 3727|       |
 3728|       |         if constexpr (category_count == 0) {
 3729|       |            ctx.error = error_code::no_matching_variant_type;
 3730|       |         }
 3731|  9.00k|         else {
 3732|  9.00k|            constexpr auto N = std::variant_size_v<Variant>;
 3733|  9.00k|            constexpr auto const_count = variant_filtered_count_v<Variant, Trait, true>;
 3734|  9.00k|            constexpr auto non_const_count = variant_filtered_count_v<Variant, Trait, false>;
 3735|       |
 3736|  9.00k|            bool found_match{};
 3737|       |            // Set when the speculative parsing budget runs out; see charge_speculation. An ambiguous
 3738|       |            // nest re-parses the same subtree per alternative at every level, which is exponential,
 3739|       |            // so the budget stops it and the failure already in hand is reported.
 3740|  9.00k|            bool exhausted{};
 3741|       |
 3742|       |            // First pass: const glaze types in this category
 3743|       |            if constexpr (const_count > 0) {
 3744|       |               for_each<N>([&]<size_t I>() {
 3745|       |                  if (found_match || exhausted || variant_alternative_exhausted(ctx)) {
 3746|       |                     return;
 3747|       |                  }
 3748|       |                  using V = std::variant_alternative_t<I, Variant>;
 3749|       |                  if constexpr (Trait<V>::value && glaze_const_value_t<V>) {
 3750|       |                     // run time substitute to compare to const value
 3751|       |                     std::remove_const_t<std::remove_pointer_t<std::remove_const_t<meta_wrapper_t<V>>>> substitute{};
 3752|       |                     auto copy_it{it};
 3753|       |                     // A rejected alternative may have bailed out inside a container, which leaves its
 3754|       |                     // nesting level counted (see enter_depth). Rewind the depth with the iterator so
 3755|       |                     // trying N alternatives cannot spend N levels of the recursion budget.
 3756|       |                     const auto copy_depth{ctx.depth};
 3757|       |                     parse<JSON>::op<ws_handled<Options>()>(substitute, ctx, it, end);
 3758|       |                     static constexpr auto const_value{*meta_wrapper_v<V>};
 3759|       |                     if (substitute == const_value) {
 3760|       |                        found_match = true;
 3761|       |                        if (!std::holds_alternative<V>(value)) {
 3762|       |                           value = V{};
 3763|       |                        }
 3764|       |                     }
 3765|       |                     else {
 3766|       |                        // Rejected: charge the bytes it parsed before we rewind. See charge_speculation.
 3767|       |                        if (!charge_speculation(ctx, size_t(it - copy_it))) {
 3768|       |                           exhausted = true;
 3769|       |                        }
 3770|       |                        if constexpr (not Options.null_terminated) {
 3771|       |                           if (ctx.error == error_code::end_reached && not exhausted) {
 3772|       |                              ctx.error = error_code::none;
 3773|       |                           }
 3774|       |                        }
 3775|       |                        it = copy_it;
 3776|       |                        rewind_depth<Options>(ctx, copy_depth);
 3777|       |                     }
 3778|       |                  }
 3779|       |               });
 3780|       |               if (found_match) {
 3781|       |                  return;
 3782|       |               }
 3783|       |            }
 3784|       |
 3785|       |            // Second pass: non-const types in this category
 3786|  9.00k|            if constexpr (non_const_count > 0) {
 3787|       |               // Track position within matching types for "is last" check.
 3788|       |               // We iterate over all variant indices but only process matching types,
 3789|       |               // so we need runtime tracking (vs the old tuple-based approach where
 3790|       |               // the loop index directly corresponded to position in filtered set).
 3791|       |               // This has negligible cost: one increment per matching type.
 3792|  9.00k|               size_t non_const_idx = 0;
 3793|       |
 3794|  9.00k|               for_each<N>([&]<size_t I>() {
 3795|  9.00k|                  if (found_match || exhausted || variant_alternative_exhausted(ctx)) {
 3796|  9.00k|                     return;
 3797|  9.00k|                  }
 3798|  9.00k|                  using V = std::variant_alternative_t<I, Variant>;
 3799|  9.00k|                  if constexpr (Trait<V>::value && !glaze_const_value_t<V>) {
 3800|  9.00k|                     auto copy_it{it};
 3801|  9.00k|                     const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above
 3802|  9.00k|                     if (!std::holds_alternative<V>(value)) {
 3803|  9.00k|                        value = V{};
 3804|  9.00k|                     }
 3805|  9.00k|                     parse<JSON>::op<ws_handled<Options>()>(std::get<V>(value), ctx, it, end);
 3806|  9.00k|                     if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) {
 3807|  9.00k|                        exhausted = true; // only rejected attempts are charged; see charge_speculation
 3808|  9.00k|                     }
 3809|  9.00k|                     if (!bool(ctx.error)) {
 3810|  9.00k|                        found_match = true;
 3811|  9.00k|                     }
 3812|  9.00k|                     else if constexpr (not Options.null_terminated) {
 3813|  9.00k|                        constexpr bool is_complete_type =
 3814|  9.00k|                           num_t<V> || bool_t<V> || string_t<V> || std::is_enum_v<V> || tuple_t<V> || is_std_tuple<V>;
 3815|       |
 3816|  9.00k|                        if constexpr (is_complete_type) {
 3817|  9.00k|                           if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) {
 3818|  9.00k|                              found_match = true;
 3819|  9.00k|                              ctx.error = error_code::none;
 3820|  9.00k|                           }
 3821|  9.00k|                           else {
 3822|  9.00k|                              it = copy_it;
 3823|  9.00k|                              rewind_depth<Options>(ctx, copy_depth);
 3824|  9.00k|                              if (non_const_idx + 1 < non_const_count && not exhausted &&
 3825|  9.00k|                                  not variant_alternative_exhausted(ctx)) {
 3826|  9.00k|                                 ctx.error = error_code::none;
 3827|  9.00k|                              }
 3828|  9.00k|                           }
 3829|  9.00k|                        }
 3830|  9.00k|                        else {
 3831|  9.00k|                           it = copy_it;
 3832|  9.00k|                           rewind_depth<Options>(ctx, copy_depth);
 3833|  9.00k|                           if (non_const_idx + 1 < non_const_count && not exhausted &&
 3834|  9.00k|                               not variant_alternative_exhausted(ctx)) {
 3835|  9.00k|                              ctx.error = error_code::none;
 3836|  9.00k|                           }
 3837|  9.00k|                        }
 3838|  9.00k|                     }
 3839|  9.00k|                     else {
 3840|  9.00k|                        it = copy_it;
 3841|  9.00k|                        rewind_depth<Options>(ctx, copy_depth);
 3842|  9.00k|                        if (non_const_idx + 1 < non_const_count && not exhausted &&
 3843|  9.00k|                            not variant_alternative_exhausted(ctx)) {
 3844|  9.00k|                           ctx.error = error_code::none;
 3845|  9.00k|                        }
 3846|  9.00k|                     }
 3847|  9.00k|                     ++non_const_idx;
 3848|  9.00k|                  }
 3849|  9.00k|               });
 3850|  9.00k|               if (!found_match) {
  ------------------
  |  Branch (3850:20): [True: 1.05k, False: 7.95k]
  ------------------
 3851|  1.05k|                  if constexpr (non_const_count == 1) {
 3852|       |                     // Keep the specific error from the single type we tried
 3853|       |                  }
 3854|       |                  else if (not exhausted && not variant_alternative_exhausted(ctx)) {
 3855|       |                     // Over-nested input is not a failure of the alternative set; keep saying so.
 3856|       |                     ctx.error = error_code::no_matching_variant_type;
 3857|       |                  }
 3858|  1.05k|               }
 3859|       |            }
 3860|       |            else {
 3861|       |               ctx.error = error_code::no_matching_variant_type;
 3862|       |            }
 3863|  9.00k|         }
 3864|  9.00k|      }
_ZZN3glz28process_variant_alternativesINSt3__17variantIJDnNS1_17basic_string_viewIcNS1_11char_traitsIcEEEElEEENS_14is_variant_strEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS7_TkNS_10is_contextERNS_7contextERPKcSG_EEvOT0_OT1_OT2_T3_ENKUlTnmvE_clILm0EEEDav:
 3794|  9.00k|               for_each<N>([&]<size_t I>() {
 3795|  9.00k|                  if (found_match || exhausted || variant_alternative_exhausted(ctx)) {
  ------------------
  |  Branch (3795:23): [True: 0, False: 9.00k]
  |  Branch (3795:38): [True: 0, False: 9.00k]
  |  Branch (3795:51): [True: 0, False: 9.00k]
  ------------------
 3796|      0|                     return;
 3797|      0|                  }
 3798|  9.00k|                  using V = std::variant_alternative_t<I, Variant>;
 3799|       |                  if constexpr (Trait<V>::value && !glaze_const_value_t<V>) {
 3800|       |                     auto copy_it{it};
 3801|       |                     const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above
 3802|       |                     if (!std::holds_alternative<V>(value)) {
 3803|       |                        value = V{};
 3804|       |                     }
 3805|       |                     parse<JSON>::op<ws_handled<Options>()>(std::get<V>(value), ctx, it, end);
 3806|       |                     if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) {
 3807|       |                        exhausted = true; // only rejected attempts are charged; see charge_speculation
 3808|       |                     }
 3809|       |                     if (!bool(ctx.error)) {
 3810|       |                        found_match = true;
 3811|       |                     }
 3812|       |                     else if constexpr (not Options.null_terminated) {
 3813|       |                        constexpr bool is_complete_type =
 3814|       |                           num_t<V> || bool_t<V> || string_t<V> || std::is_enum_v<V> || tuple_t<V> || is_std_tuple<V>;
 3815|       |
 3816|       |                        if constexpr (is_complete_type) {
 3817|       |                           if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) {
 3818|       |                              found_match = true;
 3819|       |                              ctx.error = error_code::none;
 3820|       |                           }
 3821|       |                           else {
 3822|       |                              it = copy_it;
 3823|       |                              rewind_depth<Options>(ctx, copy_depth);
 3824|       |                              if (non_const_idx + 1 < non_const_count && not exhausted &&
 3825|       |                                  not variant_alternative_exhausted(ctx)) {
 3826|       |                                 ctx.error = error_code::none;
 3827|       |                              }
 3828|       |                           }
 3829|       |                        }
 3830|       |                        else {
 3831|       |                           it = copy_it;
 3832|       |                           rewind_depth<Options>(ctx, copy_depth);
 3833|       |                           if (non_const_idx + 1 < non_const_count && not exhausted &&
 3834|       |                               not variant_alternative_exhausted(ctx)) {
 3835|       |                              ctx.error = error_code::none;
 3836|       |                           }
 3837|       |                        }
 3838|       |                     }
 3839|       |                     else {
 3840|       |                        it = copy_it;
 3841|       |                        rewind_depth<Options>(ctx, copy_depth);
 3842|       |                        if (non_const_idx + 1 < non_const_count && not exhausted &&
 3843|       |                            not variant_alternative_exhausted(ctx)) {
 3844|       |                           ctx.error = error_code::none;
 3845|       |                        }
 3846|       |                     }
 3847|       |                     ++non_const_idx;
 3848|       |                  }
 3849|  9.00k|               });
_ZZN3glz28process_variant_alternativesINSt3__17variantIJDnNS1_17basic_string_viewIcNS1_11char_traitsIcEEEElEEENS_14is_variant_strEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS7_TkNS_10is_contextERNS_7contextERPKcSG_EEvOT0_OT1_OT2_T3_ENKUlTnmvE_clILm1EEEDav:
 3794|  9.00k|               for_each<N>([&]<size_t I>() {
 3795|  9.00k|                  if (found_match || exhausted || variant_alternative_exhausted(ctx)) {
  ------------------
  |  Branch (3795:23): [True: 0, False: 9.00k]
  |  Branch (3795:38): [True: 0, False: 9.00k]
  |  Branch (3795:51): [True: 0, False: 9.00k]
  ------------------
 3796|      0|                     return;
 3797|      0|                  }
 3798|  9.00k|                  using V = std::variant_alternative_t<I, Variant>;
 3799|  9.00k|                  if constexpr (Trait<V>::value && !glaze_const_value_t<V>) {
 3800|  9.00k|                     auto copy_it{it};
 3801|  9.00k|                     const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above
 3802|  9.00k|                     if (!std::holds_alternative<V>(value)) {
  ------------------
  |  Branch (3802:26): [True: 8.67k, False: 334]
  ------------------
 3803|  8.67k|                        value = V{};
 3804|  8.67k|                     }
 3805|  9.00k|                     parse<JSON>::op<ws_handled<Options>()>(std::get<V>(value), ctx, it, end);
 3806|  9.00k|                     if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) {
  ------------------
  |  Branch (3806:26): [True: 1.05k, False: 7.95k]
  |  Branch (3806:45): [True: 0, False: 1.05k]
  ------------------
 3807|      0|                        exhausted = true; // only rejected attempts are charged; see charge_speculation
 3808|      0|                     }
 3809|  9.00k|                     if (!bool(ctx.error)) {
  ------------------
  |  Branch (3809:26): [True: 7.95k, False: 1.05k]
  ------------------
 3810|  7.95k|                        found_match = true;
 3811|  7.95k|                     }
 3812|  1.05k|                     else if constexpr (not Options.null_terminated) {
 3813|  1.05k|                        constexpr bool is_complete_type =
 3814|  1.05k|                           num_t<V> || bool_t<V> || string_t<V> || std::is_enum_v<V> || tuple_t<V> || is_std_tuple<V>;
  ------------------
  |  Branch (3814:28): [Folded, False: 0]
  |  Branch (3814:40): [Folded, False: 0]
  |  Branch (3814:53): [Folded, False: 0]
  |  Branch (3814:68): [Folded, False: 0]
  |  Branch (3814:89): [Folded, False: 0]
  |  Branch (3814:103): [Folded, False: 0]
  ------------------
 3815|       |
 3816|       |                        if constexpr (is_complete_type) {
 3817|       |                           if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) {
 3818|       |                              found_match = true;
 3819|       |                              ctx.error = error_code::none;
 3820|       |                           }
 3821|       |                           else {
 3822|       |                              it = copy_it;
 3823|       |                              rewind_depth<Options>(ctx, copy_depth);
 3824|       |                              if (non_const_idx + 1 < non_const_count && not exhausted &&
 3825|       |                                  not variant_alternative_exhausted(ctx)) {
 3826|       |                                 ctx.error = error_code::none;
 3827|       |                              }
 3828|       |                           }
 3829|       |                        }
 3830|  1.05k|                        else {
 3831|  1.05k|                           it = copy_it;
 3832|  1.05k|                           rewind_depth<Options>(ctx, copy_depth);
 3833|  1.05k|                           if (non_const_idx + 1 < non_const_count && not exhausted &&
  ------------------
  |  Branch (3833:32): [True: 0, False: 1.05k]
  |  Branch (3833:71): [True: 0, False: 0]
  ------------------
 3834|      0|                               not variant_alternative_exhausted(ctx)) {
  ------------------
  |  Branch (3834:32): [True: 0, False: 0]
  ------------------
 3835|      0|                              ctx.error = error_code::none;
 3836|      0|                           }
 3837|  1.05k|                        }
 3838|       |                     }
 3839|       |                     else {
 3840|       |                        it = copy_it;
 3841|       |                        rewind_depth<Options>(ctx, copy_depth);
 3842|       |                        if (non_const_idx + 1 < non_const_count && not exhausted &&
 3843|       |                            not variant_alternative_exhausted(ctx)) {
 3844|       |                           ctx.error = error_code::none;
 3845|       |                        }
 3846|       |                     }
 3847|  9.00k|                     ++non_const_idx;
 3848|  9.00k|                  }
 3849|  9.00k|               });
_ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEERNSt3__117basic_string_viewIcNS4_11char_traitsIcEEEETkNS_10is_contextERNS_7contextERPKcSD_EEvOT0_OT1_OT2_T3_:
   49|  9.00k|      {
   50|       |         if constexpr (const_value_v<T>) {
   51|       |            if constexpr (check_error_on_const_read(Opts)) {
   52|       |               ctx.error = error_code::attempt_const_read;
   53|       |            }
   54|       |            else {
   55|       |               // do not read anything into the const value
   56|       |               skip_value<JSON>::op<Opts>(std::forward<Ctx>(ctx), std::forward<It0>(it), end);
   57|       |            }
   58|       |         }
   59|  9.00k|         else {
   60|  9.00k|            using V = std::remove_cvref_t<T>;
   61|  9.00k|            from<JSON, V>::template op<Opts>(std::forward<T>(value), std::forward<Ctx>(ctx), std::forward<It0>(it),
   62|  9.00k|                                             end);
   63|  9.00k|         }
   64|  9.00k|      }
_ZN3glz4fromILj10ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEELb0ERPKcSA_S5_TkNS_10is_contextERNS_7contextEQntcl22check_string_as_numberTL0__EEEvRT3_OT4_OT1_T2_:
 1864|  9.00k|      {
 1865|  9.00k|         if constexpr (!check_opening_handled(Opts)) {
 1866|       |            if constexpr (!check_ws_handled(Opts)) {
 1867|       |               if (skip_ws<Opts>(ctx, it, end)) {
 1868|       |                  return;
 1869|       |               }
 1870|       |            }
 1871|       |
 1872|  9.00k|            if (match_invalid_end<'"', Opts>(ctx, it, end)) {
  ------------------
  |  Branch (1872:17): [True: 1, False: 9.00k]
  ------------------
 1873|      1|               return;
 1874|      1|            }
 1875|  9.00k|         }
 1876|       |
 1877|  9.00k|         auto start = it;
 1878|  9.00k|         skip_string_view(ctx, it, end);
 1879|  9.00k|         if (bool(ctx.error)) [[unlikely]]
  ------------------
  |  Branch (1879:14): [True: 7, False: 8.99k]
  ------------------
 1880|      7|            return;
 1881|       |
 1882|  8.99k|         if (validate_utf8_span<Opts>(ctx, start, it)) [[unlikely]] {
  ------------------
  |  Branch (1882:14): [True: 82, False: 8.91k]
  ------------------
 1883|     82|            return;
 1884|     82|         }
 1885|       |
 1886|  8.91k|         if constexpr (string_view_t<T>) {
 1887|  8.91k|            if constexpr (!Transient) {
 1888|  8.91k|               GLZ_ASSERT_OWNS_ITS_BYTES(decltype(ctx));
  ------------------
  |  |  242|  8.91k|   static_assert(!::glz::has_streaming_state<Ctx>,                                                              \
  |  |  243|  8.91k|                 "This read fills a non-owning view (std::string_view, glz::raw_json_view, glz::text_view, or " \
  |  |  244|  8.91k|                 "a std::span) that would point into the streaming window. A streaming read refills that "      \
  |  |  245|  8.91k|                 "window as it goes, so the view would address overwritten bytes by the time the read "         \
  |  |  246|  8.91k|                 "returns, and the read would report success while handing back silently wrong data. Read "     \
  |  |  247|  8.91k|                 "into the owning equivalent instead (std::string, glz::raw_json, glz::text, or an owning "     \
  |  |  248|  8.91k|                 "container), or read from a buffer that holds the whole document.")
  ------------------
 1889|  8.91k|            }
 1890|  8.91k|            using value_type = typename std::decay_t<T>::value_type;
 1891|       |            if constexpr (std::same_as<value_type, char8_t>) {
 1892|       |               value = {reinterpret_cast<const char8_t*>(start), size_t(it - start)};
 1893|       |            }
 1894|  8.91k|            else {
 1895|  8.91k|               value = {start, size_t(it - start)};
 1896|  8.91k|            }
 1897|       |         }
 1898|       |         else if constexpr (char_array_t<T>) {
 1899|       |            const size_t n = it - start;
 1900|       |            if ((n + 1) > sizeof(value)) {
 1901|       |               ctx.error = error_code::unexpected_end;
 1902|       |               return;
 1903|       |            }
 1904|       |            std::memcpy(value, start, n);
 1905|       |            value[n] = '\0';
 1906|       |         }
 1907|       |         else if constexpr (array_char_t<T>) {
 1908|       |            const size_t n = it - start;
 1909|       |            if ((n + 1) > value.size()) {
 1910|       |               ctx.error = error_code::unexpected_end;
 1911|       |               return;
 1912|       |            }
 1913|       |            std::memcpy(value.data(), start, n);
 1914|       |            value[n] = '\0';
 1915|       |         }
 1916|       |         else if constexpr (static_string_t<T>) {
 1917|       |            const size_t n = it - start;
 1918|       |            if (n > value.capacity()) {
 1919|       |               ctx.error = error_code::unexpected_end;
 1920|       |               return;
 1921|       |            }
 1922|       |            value.assign(start, n);
 1923|       |         }
 1924|  8.91k|         ++it; // skip closing quote
 1925|  8.91k|         if constexpr (not Opts.null_terminated) {
 1926|  8.91k|            if (it == end) {
  ------------------
  |  Branch (1926:17): [True: 964, False: 7.95k]
  ------------------
 1927|    964|               ctx.error = error_code::end_reached;
 1928|    964|               return;
 1929|    964|            }
 1930|  8.91k|         }
 1931|  8.91k|      }
_ZZN3glz28process_variant_alternativesINSt3__17variantIJDnNS1_17basic_string_viewIcNS1_11char_traitsIcEEEElEEENS_14is_variant_strEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS7_TkNS_10is_contextERNS_7contextERPKcSG_EEvOT0_OT1_OT2_T3_ENKUlTnmvE_clILm2EEEDav:
 3794|  9.00k|               for_each<N>([&]<size_t I>() {
 3795|  9.00k|                  if (found_match || exhausted || variant_alternative_exhausted(ctx)) {
  ------------------
  |  Branch (3795:23): [True: 7.95k, False: 1.05k]
  |  Branch (3795:38): [True: 0, False: 1.05k]
  |  Branch (3795:51): [True: 0, False: 1.05k]
  ------------------
 3796|  7.95k|                     return;
 3797|  7.95k|                  }
 3798|  1.05k|                  using V = std::variant_alternative_t<I, Variant>;
 3799|       |                  if constexpr (Trait<V>::value && !glaze_const_value_t<V>) {
 3800|       |                     auto copy_it{it};
 3801|       |                     const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above
 3802|       |                     if (!std::holds_alternative<V>(value)) {
 3803|       |                        value = V{};
 3804|       |                     }
 3805|       |                     parse<JSON>::op<ws_handled<Options>()>(std::get<V>(value), ctx, it, end);
 3806|       |                     if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) {
 3807|       |                        exhausted = true; // only rejected attempts are charged; see charge_speculation
 3808|       |                     }
 3809|       |                     if (!bool(ctx.error)) {
 3810|       |                        found_match = true;
 3811|       |                     }
 3812|       |                     else if constexpr (not Options.null_terminated) {
 3813|       |                        constexpr bool is_complete_type =
 3814|       |                           num_t<V> || bool_t<V> || string_t<V> || std::is_enum_v<V> || tuple_t<V> || is_std_tuple<V>;
 3815|       |
 3816|       |                        if constexpr (is_complete_type) {
 3817|       |                           if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) {
 3818|       |                              found_match = true;
 3819|       |                              ctx.error = error_code::none;
 3820|       |                           }
 3821|       |                           else {
 3822|       |                              it = copy_it;
 3823|       |                              rewind_depth<Options>(ctx, copy_depth);
 3824|       |                              if (non_const_idx + 1 < non_const_count && not exhausted &&
 3825|       |                                  not variant_alternative_exhausted(ctx)) {
 3826|       |                                 ctx.error = error_code::none;
 3827|       |                              }
 3828|       |                           }
 3829|       |                        }
 3830|       |                        else {
 3831|       |                           it = copy_it;
 3832|       |                           rewind_depth<Options>(ctx, copy_depth);
 3833|       |                           if (non_const_idx + 1 < non_const_count && not exhausted &&
 3834|       |                               not variant_alternative_exhausted(ctx)) {
 3835|       |                              ctx.error = error_code::none;
 3836|       |                           }
 3837|       |                        }
 3838|       |                     }
 3839|       |                     else {
 3840|       |                        it = copy_it;
 3841|       |                        rewind_depth<Options>(ctx, copy_depth);
 3842|       |                        if (non_const_idx + 1 < non_const_count && not exhausted &&
 3843|       |                            not variant_alternative_exhausted(ctx)) {
 3844|       |                           ctx.error = error_code::none;
 3845|       |                        }
 3846|       |                     }
 3847|       |                     ++non_const_idx;
 3848|       |                  }
 3849|  1.05k|               });
_ZN3glz28process_variant_alternativesINSt3__17variantIJDnNS1_17basic_string_viewIcNS1_11char_traitsIcEEEElEEENS_15is_variant_boolEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS7_TkNS_10is_contextERNS_7contextERPKcSG_EEvOT0_OT1_OT2_T3_:
 3725|  2.95k|      {
 3726|  2.95k|         constexpr auto category_count = variant_count_v<Variant, Trait>;
 3727|       |
 3728|  2.95k|         if constexpr (category_count == 0) {
 3729|  2.95k|            ctx.error = error_code::no_matching_variant_type;
 3730|       |         }
 3731|       |         else {
 3732|       |            constexpr auto N = std::variant_size_v<Variant>;
 3733|       |            constexpr auto const_count = variant_filtered_count_v<Variant, Trait, true>;
 3734|       |            constexpr auto non_const_count = variant_filtered_count_v<Variant, Trait, false>;
 3735|       |
 3736|       |            bool found_match{};
 3737|       |            // Set when the speculative parsing budget runs out; see charge_speculation. An ambiguous
 3738|       |            // nest re-parses the same subtree per alternative at every level, which is exponential,
 3739|       |            // so the budget stops it and the failure already in hand is reported.
 3740|       |            bool exhausted{};
 3741|       |
 3742|       |            // First pass: const glaze types in this category
 3743|       |            if constexpr (const_count > 0) {
 3744|       |               for_each<N>([&]<size_t I>() {
 3745|       |                  if (found_match || exhausted || variant_alternative_exhausted(ctx)) {
 3746|       |                     return;
 3747|       |                  }
 3748|       |                  using V = std::variant_alternative_t<I, Variant>;
 3749|       |                  if constexpr (Trait<V>::value && glaze_const_value_t<V>) {
 3750|       |                     // run time substitute to compare to const value
 3751|       |                     std::remove_const_t<std::remove_pointer_t<std::remove_const_t<meta_wrapper_t<V>>>> substitute{};
 3752|       |                     auto copy_it{it};
 3753|       |                     // A rejected alternative may have bailed out inside a container, which leaves its
 3754|       |                     // nesting level counted (see enter_depth). Rewind the depth with the iterator so
 3755|       |                     // trying N alternatives cannot spend N levels of the recursion budget.
 3756|       |                     const auto copy_depth{ctx.depth};
 3757|       |                     parse<JSON>::op<ws_handled<Options>()>(substitute, ctx, it, end);
 3758|       |                     static constexpr auto const_value{*meta_wrapper_v<V>};
 3759|       |                     if (substitute == const_value) {
 3760|       |                        found_match = true;
 3761|       |                        if (!std::holds_alternative<V>(value)) {
 3762|       |                           value = V{};
 3763|       |                        }
 3764|       |                     }
 3765|       |                     else {
 3766|       |                        // Rejected: charge the bytes it parsed before we rewind. See charge_speculation.
 3767|       |                        if (!charge_speculation(ctx, size_t(it - copy_it))) {
 3768|       |                           exhausted = true;
 3769|       |                        }
 3770|       |                        if constexpr (not Options.null_terminated) {
 3771|       |                           if (ctx.error == error_code::end_reached && not exhausted) {
 3772|       |                              ctx.error = error_code::none;
 3773|       |                           }
 3774|       |                        }
 3775|       |                        it = copy_it;
 3776|       |                        rewind_depth<Options>(ctx, copy_depth);
 3777|       |                     }
 3778|       |                  }
 3779|       |               });
 3780|       |               if (found_match) {
 3781|       |                  return;
 3782|       |               }
 3783|       |            }
 3784|       |
 3785|       |            // Second pass: non-const types in this category
 3786|       |            if constexpr (non_const_count > 0) {
 3787|       |               // Track position within matching types for "is last" check.
 3788|       |               // We iterate over all variant indices but only process matching types,
 3789|       |               // so we need runtime tracking (vs the old tuple-based approach where
 3790|       |               // the loop index directly corresponded to position in filtered set).
 3791|       |               // This has negligible cost: one increment per matching type.
 3792|       |               size_t non_const_idx = 0;
 3793|       |
 3794|       |               for_each<N>([&]<size_t I>() {
 3795|       |                  if (found_match || exhausted || variant_alternative_exhausted(ctx)) {
 3796|       |                     return;
 3797|       |                  }
 3798|       |                  using V = std::variant_alternative_t<I, Variant>;
 3799|       |                  if constexpr (Trait<V>::value && !glaze_const_value_t<V>) {
 3800|       |                     auto copy_it{it};
 3801|       |                     const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above
 3802|       |                     if (!std::holds_alternative<V>(value)) {
 3803|       |                        value = V{};
 3804|       |                     }
 3805|       |                     parse<JSON>::op<ws_handled<Options>()>(std::get<V>(value), ctx, it, end);
 3806|       |                     if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) {
 3807|       |                        exhausted = true; // only rejected attempts are charged; see charge_speculation
 3808|       |                     }
 3809|       |                     if (!bool(ctx.error)) {
 3810|       |                        found_match = true;
 3811|       |                     }
 3812|       |                     else if constexpr (not Options.null_terminated) {
 3813|       |                        constexpr bool is_complete_type =
 3814|       |                           num_t<V> || bool_t<V> || string_t<V> || std::is_enum_v<V> || tuple_t<V> || is_std_tuple<V>;
 3815|       |
 3816|       |                        if constexpr (is_complete_type) {
 3817|       |                           if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) {
 3818|       |                              found_match = true;
 3819|       |                              ctx.error = error_code::none;
 3820|       |                           }
 3821|       |                           else {
 3822|       |                              it = copy_it;
 3823|       |                              rewind_depth<Options>(ctx, copy_depth);
 3824|       |                              if (non_const_idx + 1 < non_const_count && not exhausted &&
 3825|       |                                  not variant_alternative_exhausted(ctx)) {
 3826|       |                                 ctx.error = error_code::none;
 3827|       |                              }
 3828|       |                           }
 3829|       |                        }
 3830|       |                        else {
 3831|       |                           it = copy_it;
 3832|       |                           rewind_depth<Options>(ctx, copy_depth);
 3833|       |                           if (non_const_idx + 1 < non_const_count && not exhausted &&
 3834|       |                               not variant_alternative_exhausted(ctx)) {
 3835|       |                              ctx.error = error_code::none;
 3836|       |                           }
 3837|       |                        }
 3838|       |                     }
 3839|       |                     else {
 3840|       |                        it = copy_it;
 3841|       |                        rewind_depth<Options>(ctx, copy_depth);
 3842|       |                        if (non_const_idx + 1 < non_const_count && not exhausted &&
 3843|       |                            not variant_alternative_exhausted(ctx)) {
 3844|       |                           ctx.error = error_code::none;
 3845|       |                        }
 3846|       |                     }
 3847|       |                     ++non_const_idx;
 3848|       |                  }
 3849|       |               });
 3850|       |               if (!found_match) {
 3851|       |                  if constexpr (non_const_count == 1) {
 3852|       |                     // Keep the specific error from the single type we tried
 3853|       |                  }
 3854|       |                  else if (not exhausted && not variant_alternative_exhausted(ctx)) {
 3855|       |                     // Over-nested input is not a failure of the alternative set; keep saying so.
 3856|       |                     ctx.error = error_code::no_matching_variant_type;
 3857|       |                  }
 3858|       |               }
 3859|       |            }
 3860|       |            else {
 3861|       |               ctx.error = error_code::no_matching_variant_type;
 3862|       |            }
 3863|       |         }
 3864|  2.95k|      }
_ZN3glz28process_variant_alternativesINSt3__17variantIJDnNS1_17basic_string_viewIcNS1_11char_traitsIcEEEElEEENS_14is_variant_numEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS7_TkNS_10is_contextERNS_7contextERPKcSG_EEvOT0_OT1_OT2_T3_:
 3725|  86.1k|      {
 3726|  86.1k|         constexpr auto category_count = variant_count_v<Variant, Trait>;
 3727|       |
 3728|       |         if constexpr (category_count == 0) {
 3729|       |            ctx.error = error_code::no_matching_variant_type;
 3730|       |         }
 3731|  86.1k|         else {
 3732|  86.1k|            constexpr auto N = std::variant_size_v<Variant>;
 3733|  86.1k|            constexpr auto const_count = variant_filtered_count_v<Variant, Trait, true>;
 3734|  86.1k|            constexpr auto non_const_count = variant_filtered_count_v<Variant, Trait, false>;
 3735|       |
 3736|  86.1k|            bool found_match{};
 3737|       |            // Set when the speculative parsing budget runs out; see charge_speculation. An ambiguous
 3738|       |            // nest re-parses the same subtree per alternative at every level, which is exponential,
 3739|       |            // so the budget stops it and the failure already in hand is reported.
 3740|  86.1k|            bool exhausted{};
 3741|       |
 3742|       |            // First pass: const glaze types in this category
 3743|       |            if constexpr (const_count > 0) {
 3744|       |               for_each<N>([&]<size_t I>() {
 3745|       |                  if (found_match || exhausted || variant_alternative_exhausted(ctx)) {
 3746|       |                     return;
 3747|       |                  }
 3748|       |                  using V = std::variant_alternative_t<I, Variant>;
 3749|       |                  if constexpr (Trait<V>::value && glaze_const_value_t<V>) {
 3750|       |                     // run time substitute to compare to const value
 3751|       |                     std::remove_const_t<std::remove_pointer_t<std::remove_const_t<meta_wrapper_t<V>>>> substitute{};
 3752|       |                     auto copy_it{it};
 3753|       |                     // A rejected alternative may have bailed out inside a container, which leaves its
 3754|       |                     // nesting level counted (see enter_depth). Rewind the depth with the iterator so
 3755|       |                     // trying N alternatives cannot spend N levels of the recursion budget.
 3756|       |                     const auto copy_depth{ctx.depth};
 3757|       |                     parse<JSON>::op<ws_handled<Options>()>(substitute, ctx, it, end);
 3758|       |                     static constexpr auto const_value{*meta_wrapper_v<V>};
 3759|       |                     if (substitute == const_value) {
 3760|       |                        found_match = true;
 3761|       |                        if (!std::holds_alternative<V>(value)) {
 3762|       |                           value = V{};
 3763|       |                        }
 3764|       |                     }
 3765|       |                     else {
 3766|       |                        // Rejected: charge the bytes it parsed before we rewind. See charge_speculation.
 3767|       |                        if (!charge_speculation(ctx, size_t(it - copy_it))) {
 3768|       |                           exhausted = true;
 3769|       |                        }
 3770|       |                        if constexpr (not Options.null_terminated) {
 3771|       |                           if (ctx.error == error_code::end_reached && not exhausted) {
 3772|       |                              ctx.error = error_code::none;
 3773|       |                           }
 3774|       |                        }
 3775|       |                        it = copy_it;
 3776|       |                        rewind_depth<Options>(ctx, copy_depth);
 3777|       |                     }
 3778|       |                  }
 3779|       |               });
 3780|       |               if (found_match) {
 3781|       |                  return;
 3782|       |               }
 3783|       |            }
 3784|       |
 3785|       |            // Second pass: non-const types in this category
 3786|  86.1k|            if constexpr (non_const_count > 0) {
 3787|       |               // Track position within matching types for "is last" check.
 3788|       |               // We iterate over all variant indices but only process matching types,
 3789|       |               // so we need runtime tracking (vs the old tuple-based approach where
 3790|       |               // the loop index directly corresponded to position in filtered set).
 3791|       |               // This has negligible cost: one increment per matching type.
 3792|  86.1k|               size_t non_const_idx = 0;
 3793|       |
 3794|  86.1k|               for_each<N>([&]<size_t I>() {
 3795|  86.1k|                  if (found_match || exhausted || variant_alternative_exhausted(ctx)) {
 3796|  86.1k|                     return;
 3797|  86.1k|                  }
 3798|  86.1k|                  using V = std::variant_alternative_t<I, Variant>;
 3799|  86.1k|                  if constexpr (Trait<V>::value && !glaze_const_value_t<V>) {
 3800|  86.1k|                     auto copy_it{it};
 3801|  86.1k|                     const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above
 3802|  86.1k|                     if (!std::holds_alternative<V>(value)) {
 3803|  86.1k|                        value = V{};
 3804|  86.1k|                     }
 3805|  86.1k|                     parse<JSON>::op<ws_handled<Options>()>(std::get<V>(value), ctx, it, end);
 3806|  86.1k|                     if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) {
 3807|  86.1k|                        exhausted = true; // only rejected attempts are charged; see charge_speculation
 3808|  86.1k|                     }
 3809|  86.1k|                     if (!bool(ctx.error)) {
 3810|  86.1k|                        found_match = true;
 3811|  86.1k|                     }
 3812|  86.1k|                     else if constexpr (not Options.null_terminated) {
 3813|  86.1k|                        constexpr bool is_complete_type =
 3814|  86.1k|                           num_t<V> || bool_t<V> || string_t<V> || std::is_enum_v<V> || tuple_t<V> || is_std_tuple<V>;
 3815|       |
 3816|  86.1k|                        if constexpr (is_complete_type) {
 3817|  86.1k|                           if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) {
 3818|  86.1k|                              found_match = true;
 3819|  86.1k|                              ctx.error = error_code::none;
 3820|  86.1k|                           }
 3821|  86.1k|                           else {
 3822|  86.1k|                              it = copy_it;
 3823|  86.1k|                              rewind_depth<Options>(ctx, copy_depth);
 3824|  86.1k|                              if (non_const_idx + 1 < non_const_count && not exhausted &&
 3825|  86.1k|                                  not variant_alternative_exhausted(ctx)) {
 3826|  86.1k|                                 ctx.error = error_code::none;
 3827|  86.1k|                              }
 3828|  86.1k|                           }
 3829|  86.1k|                        }
 3830|  86.1k|                        else {
 3831|  86.1k|                           it = copy_it;
 3832|  86.1k|                           rewind_depth<Options>(ctx, copy_depth);
 3833|  86.1k|                           if (non_const_idx + 1 < non_const_count && not exhausted &&
 3834|  86.1k|                               not variant_alternative_exhausted(ctx)) {
 3835|  86.1k|                              ctx.error = error_code::none;
 3836|  86.1k|                           }
 3837|  86.1k|                        }
 3838|  86.1k|                     }
 3839|  86.1k|                     else {
 3840|  86.1k|                        it = copy_it;
 3841|  86.1k|                        rewind_depth<Options>(ctx, copy_depth);
 3842|  86.1k|                        if (non_const_idx + 1 < non_const_count && not exhausted &&
 3843|  86.1k|                            not variant_alternative_exhausted(ctx)) {
 3844|  86.1k|                           ctx.error = error_code::none;
 3845|  86.1k|                        }
 3846|  86.1k|                     }
 3847|  86.1k|                     ++non_const_idx;
 3848|  86.1k|                  }
 3849|  86.1k|               });
 3850|  86.1k|               if (!found_match) {
  ------------------
  |  Branch (3850:20): [True: 31.2k, False: 54.8k]
  ------------------
 3851|  31.2k|                  if constexpr (non_const_count == 1) {
 3852|       |                     // Keep the specific error from the single type we tried
 3853|       |                  }
 3854|       |                  else if (not exhausted && not variant_alternative_exhausted(ctx)) {
 3855|       |                     // Over-nested input is not a failure of the alternative set; keep saying so.
 3856|       |                     ctx.error = error_code::no_matching_variant_type;
 3857|       |                  }
 3858|  31.2k|               }
 3859|       |            }
 3860|       |            else {
 3861|       |               ctx.error = error_code::no_matching_variant_type;
 3862|       |            }
 3863|  86.1k|         }
 3864|  86.1k|      }
_ZZN3glz28process_variant_alternativesINSt3__17variantIJDnNS1_17basic_string_viewIcNS1_11char_traitsIcEEEElEEENS_14is_variant_numEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS7_TkNS_10is_contextERNS_7contextERPKcSG_EEvOT0_OT1_OT2_T3_ENKUlTnmvE_clILm0EEEDav:
 3794|  86.1k|               for_each<N>([&]<size_t I>() {
 3795|  86.1k|                  if (found_match || exhausted || variant_alternative_exhausted(ctx)) {
  ------------------
  |  Branch (3795:23): [True: 0, False: 86.1k]
  |  Branch (3795:38): [True: 0, False: 86.1k]
  |  Branch (3795:51): [True: 0, False: 86.1k]
  ------------------
 3796|      0|                     return;
 3797|      0|                  }
 3798|  86.1k|                  using V = std::variant_alternative_t<I, Variant>;
 3799|       |                  if constexpr (Trait<V>::value && !glaze_const_value_t<V>) {
 3800|       |                     auto copy_it{it};
 3801|       |                     const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above
 3802|       |                     if (!std::holds_alternative<V>(value)) {
 3803|       |                        value = V{};
 3804|       |                     }
 3805|       |                     parse<JSON>::op<ws_handled<Options>()>(std::get<V>(value), ctx, it, end);
 3806|       |                     if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) {
 3807|       |                        exhausted = true; // only rejected attempts are charged; see charge_speculation
 3808|       |                     }
 3809|       |                     if (!bool(ctx.error)) {
 3810|       |                        found_match = true;
 3811|       |                     }
 3812|       |                     else if constexpr (not Options.null_terminated) {
 3813|       |                        constexpr bool is_complete_type =
 3814|       |                           num_t<V> || bool_t<V> || string_t<V> || std::is_enum_v<V> || tuple_t<V> || is_std_tuple<V>;
 3815|       |
 3816|       |                        if constexpr (is_complete_type) {
 3817|       |                           if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) {
 3818|       |                              found_match = true;
 3819|       |                              ctx.error = error_code::none;
 3820|       |                           }
 3821|       |                           else {
 3822|       |                              it = copy_it;
 3823|       |                              rewind_depth<Options>(ctx, copy_depth);
 3824|       |                              if (non_const_idx + 1 < non_const_count && not exhausted &&
 3825|       |                                  not variant_alternative_exhausted(ctx)) {
 3826|       |                                 ctx.error = error_code::none;
 3827|       |                              }
 3828|       |                           }
 3829|       |                        }
 3830|       |                        else {
 3831|       |                           it = copy_it;
 3832|       |                           rewind_depth<Options>(ctx, copy_depth);
 3833|       |                           if (non_const_idx + 1 < non_const_count && not exhausted &&
 3834|       |                               not variant_alternative_exhausted(ctx)) {
 3835|       |                              ctx.error = error_code::none;
 3836|       |                           }
 3837|       |                        }
 3838|       |                     }
 3839|       |                     else {
 3840|       |                        it = copy_it;
 3841|       |                        rewind_depth<Options>(ctx, copy_depth);
 3842|       |                        if (non_const_idx + 1 < non_const_count && not exhausted &&
 3843|       |                            not variant_alternative_exhausted(ctx)) {
 3844|       |                           ctx.error = error_code::none;
 3845|       |                        }
 3846|       |                     }
 3847|       |                     ++non_const_idx;
 3848|       |                  }
 3849|  86.1k|               });
_ZZN3glz28process_variant_alternativesINSt3__17variantIJDnNS1_17basic_string_viewIcNS1_11char_traitsIcEEEElEEENS_14is_variant_numEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS7_TkNS_10is_contextERNS_7contextERPKcSG_EEvOT0_OT1_OT2_T3_ENKUlTnmvE_clILm1EEEDav:
 3794|  86.1k|               for_each<N>([&]<size_t I>() {
 3795|  86.1k|                  if (found_match || exhausted || variant_alternative_exhausted(ctx)) {
  ------------------
  |  Branch (3795:23): [True: 0, False: 86.1k]
  |  Branch (3795:38): [True: 0, False: 86.1k]
  |  Branch (3795:51): [True: 0, False: 86.1k]
  ------------------
 3796|      0|                     return;
 3797|      0|                  }
 3798|  86.1k|                  using V = std::variant_alternative_t<I, Variant>;
 3799|       |                  if constexpr (Trait<V>::value && !glaze_const_value_t<V>) {
 3800|       |                     auto copy_it{it};
 3801|       |                     const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above
 3802|       |                     if (!std::holds_alternative<V>(value)) {
 3803|       |                        value = V{};
 3804|       |                     }
 3805|       |                     parse<JSON>::op<ws_handled<Options>()>(std::get<V>(value), ctx, it, end);
 3806|       |                     if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) {
 3807|       |                        exhausted = true; // only rejected attempts are charged; see charge_speculation
 3808|       |                     }
 3809|       |                     if (!bool(ctx.error)) {
 3810|       |                        found_match = true;
 3811|       |                     }
 3812|       |                     else if constexpr (not Options.null_terminated) {
 3813|       |                        constexpr bool is_complete_type =
 3814|       |                           num_t<V> || bool_t<V> || string_t<V> || std::is_enum_v<V> || tuple_t<V> || is_std_tuple<V>;
 3815|       |
 3816|       |                        if constexpr (is_complete_type) {
 3817|       |                           if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) {
 3818|       |                              found_match = true;
 3819|       |                              ctx.error = error_code::none;
 3820|       |                           }
 3821|       |                           else {
 3822|       |                              it = copy_it;
 3823|       |                              rewind_depth<Options>(ctx, copy_depth);
 3824|       |                              if (non_const_idx + 1 < non_const_count && not exhausted &&
 3825|       |                                  not variant_alternative_exhausted(ctx)) {
 3826|       |                                 ctx.error = error_code::none;
 3827|       |                              }
 3828|       |                           }
 3829|       |                        }
 3830|       |                        else {
 3831|       |                           it = copy_it;
 3832|       |                           rewind_depth<Options>(ctx, copy_depth);
 3833|       |                           if (non_const_idx + 1 < non_const_count && not exhausted &&
 3834|       |                               not variant_alternative_exhausted(ctx)) {
 3835|       |                              ctx.error = error_code::none;
 3836|       |                           }
 3837|       |                        }
 3838|       |                     }
 3839|       |                     else {
 3840|       |                        it = copy_it;
 3841|       |                        rewind_depth<Options>(ctx, copy_depth);
 3842|       |                        if (non_const_idx + 1 < non_const_count && not exhausted &&
 3843|       |                            not variant_alternative_exhausted(ctx)) {
 3844|       |                           ctx.error = error_code::none;
 3845|       |                        }
 3846|       |                     }
 3847|       |                     ++non_const_idx;
 3848|       |                  }
 3849|  86.1k|               });
_ZZN3glz28process_variant_alternativesINSt3__17variantIJDnNS1_17basic_string_viewIcNS1_11char_traitsIcEEEElEEENS_14is_variant_numEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS7_TkNS_10is_contextERNS_7contextERPKcSG_EEvOT0_OT1_OT2_T3_ENKUlTnmvE_clILm2EEEDav:
 3794|  86.1k|               for_each<N>([&]<size_t I>() {
 3795|  86.1k|                  if (found_match || exhausted || variant_alternative_exhausted(ctx)) {
  ------------------
  |  Branch (3795:23): [True: 0, False: 86.1k]
  |  Branch (3795:38): [True: 0, False: 86.1k]
  |  Branch (3795:51): [True: 0, False: 86.1k]
  ------------------
 3796|      0|                     return;
 3797|      0|                  }
 3798|  86.1k|                  using V = std::variant_alternative_t<I, Variant>;
 3799|  86.1k|                  if constexpr (Trait<V>::value && !glaze_const_value_t<V>) {
 3800|  86.1k|                     auto copy_it{it};
 3801|  86.1k|                     const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above
 3802|  86.1k|                     if (!std::holds_alternative<V>(value)) {
  ------------------
  |  Branch (3802:26): [True: 73.4k, False: 12.7k]
  ------------------
 3803|  73.4k|                        value = V{};
 3804|  73.4k|                     }
 3805|  86.1k|                     parse<JSON>::op<ws_handled<Options>()>(std::get<V>(value), ctx, it, end);
 3806|  86.1k|                     if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) {
  ------------------
  |  Branch (3806:26): [True: 33.0k, False: 53.0k]
  |  Branch (3806:45): [True: 0, False: 33.0k]
  ------------------
 3807|      0|                        exhausted = true; // only rejected attempts are charged; see charge_speculation
 3808|      0|                     }
 3809|  86.1k|                     if (!bool(ctx.error)) {
  ------------------
  |  Branch (3809:26): [True: 53.0k, False: 33.0k]
  ------------------
 3810|  53.0k|                        found_match = true;
 3811|  53.0k|                     }
 3812|  33.0k|                     else if constexpr (not Options.null_terminated) {
 3813|  33.0k|                        constexpr bool is_complete_type =
 3814|  33.0k|                           num_t<V> || bool_t<V> || string_t<V> || std::is_enum_v<V> || tuple_t<V> || is_std_tuple<V>;
  ------------------
  |  Branch (3814:28): [True: 33.0k, Folded]
  |  Branch (3814:40): [Folded, False: 0]
  |  Branch (3814:53): [Folded, False: 0]
  |  Branch (3814:68): [Folded, False: 0]
  |  Branch (3814:89): [Folded, False: 0]
  |  Branch (3814:103): [Folded, False: 0]
  ------------------
 3815|       |
 3816|  33.0k|                        if constexpr (is_complete_type) {
 3817|  33.0k|                           if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) {
  ------------------
  |  Branch (3817:32): [True: 1.81k, False: 31.2k]
  |  Branch (3817:72): [True: 1.81k, False: 0]
  |  Branch (3817:88): [True: 1.81k, False: 0]
  ------------------
 3818|  1.81k|                              found_match = true;
 3819|  1.81k|                              ctx.error = error_code::none;
 3820|  1.81k|                           }
 3821|  31.2k|                           else {
 3822|  31.2k|                              it = copy_it;
 3823|  31.2k|                              rewind_depth<Options>(ctx, copy_depth);
 3824|  31.2k|                              if (non_const_idx + 1 < non_const_count && not exhausted &&
  ------------------
  |  Branch (3824:35): [True: 0, False: 31.2k]
  |  Branch (3824:74): [True: 0, False: 0]
  ------------------
 3825|      0|                                  not variant_alternative_exhausted(ctx)) {
  ------------------
  |  Branch (3825:35): [True: 0, False: 0]
  ------------------
 3826|      0|                                 ctx.error = error_code::none;
 3827|      0|                              }
 3828|  31.2k|                           }
 3829|       |                        }
 3830|       |                        else {
 3831|       |                           it = copy_it;
 3832|       |                           rewind_depth<Options>(ctx, copy_depth);
 3833|       |                           if (non_const_idx + 1 < non_const_count && not exhausted &&
 3834|       |                               not variant_alternative_exhausted(ctx)) {
 3835|       |                              ctx.error = error_code::none;
 3836|       |                           }
 3837|       |                        }
 3838|       |                     }
 3839|       |                     else {
 3840|       |                        it = copy_it;
 3841|       |                        rewind_depth<Options>(ctx, copy_depth);
 3842|       |                        if (non_const_idx + 1 < non_const_count && not exhausted &&
 3843|       |                            not variant_alternative_exhausted(ctx)) {
 3844|       |                           ctx.error = error_code::none;
 3845|       |                        }
 3846|       |                     }
 3847|  86.1k|                     ++non_const_idx;
 3848|  86.1k|                  }
 3849|  86.1k|               });
_ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEERlTkNS_10is_contextERNS_7contextERPKcS8_EEvOT0_OT1_OT2_T3_:
   49|  86.1k|      {
   50|       |         if constexpr (const_value_v<T>) {
   51|       |            if constexpr (check_error_on_const_read(Opts)) {
   52|       |               ctx.error = error_code::attempt_const_read;
   53|       |            }
   54|       |            else {
   55|       |               // do not read anything into the const value
   56|       |               skip_value<JSON>::op<Opts>(std::forward<Ctx>(ctx), std::forward<It0>(it), end);
   57|       |            }
   58|       |         }
   59|  86.1k|         else {
   60|  86.1k|            using V = std::remove_cvref_t<T>;
   61|  86.1k|            from<JSON, V>::template op<Opts>(std::forward<T>(value), std::forward<Ctx>(ctx), std::forward<It0>(it),
   62|  86.1k|                                             end);
   63|  86.1k|         }
   64|  86.1k|      }
_ZN3glz4fromILj10ElE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEERPKcRlTkNS_10is_contextERNS_7contextES5_EEvOT1_OT2_OT0_T3_:
  767|  86.1k|      {
  768|       |         if constexpr (check_quoted_num(Opts)) {
  769|       |            if (skip_ws<Opts>(ctx, it, end)) {
  770|       |               return;
  771|       |            }
  772|       |            if (match_invalid_end<'"', Opts>(ctx, it, end)) {
  773|       |               return;
  774|       |            }
  775|       |         }
  776|       |
  777|       |         if constexpr (!check_ws_handled(Opts)) {
  778|       |            if (skip_ws<Opts>(ctx, it, end)) {
  779|       |               return;
  780|       |            }
  781|       |         }
  782|       |
  783|  86.1k|         using V = std::decay_t<decltype(value)>;
  784|  86.1k|         if constexpr (int_t<V>) {
  785|  86.1k|            static_assert(sizeof(*it) == sizeof(char));
  786|       |
  787|       |            if constexpr (Opts.null_terminated) {
  788|       |               if (not glz::atoi(value, it)) [[unlikely]] {
  789|       |                  ctx.error = error_code::parse_number_failure;
  790|       |                  return;
  791|       |               }
  792|       |            }
  793|  86.1k|            else {
  794|  86.1k|               if (not glz::atoi(value, it, end)) [[unlikely]] {
  ------------------
  |  Branch (794:20): [True: 31.2k, False: 54.8k]
  ------------------
  795|  31.2k|                  ctx.error = error_code::parse_number_failure;
  796|  31.2k|                  return;
  797|  31.2k|               }
  798|  86.1k|            }
  799|       |         }
  800|       |         else {
  801|       |// float128_t requires std::from_chars for floating-point, unavailable on older Apple platforms (iOS < 16.3)
  802|       |#if !defined(_LIBCPP_VERSION) || defined(_LIBCPP_AVAILABILITY_HAS_TO_CHARS_FLOATING_POINT)
  803|       |            if constexpr (is_float128<V>) {
  804|       |               auto [ptr, ec] = std::from_chars(it, end, value);
  805|       |               if (ec != std::errc()) {
  806|       |                  ctx.error = error_code::parse_number_failure;
  807|       |                  return;
  808|       |               }
  809|       |               it = ptr;
  810|       |            }
  811|       |            else
  812|       |#endif
  813|       |            {
  814|       |               if constexpr (std::is_volatile_v<std::remove_reference_t<decltype(value)>>) {
  815|       |                  // Hardware may interact with value changes, so we parse into a temporary and assign in one
  816|       |                  // place
  817|       |                  V temp;
  818|       |                  if constexpr (is_size_optimized(Opts)) {
  819|       |                     auto [ptr, ec] = simple_float::from_chars<Opts.null_terminated>(it, end, temp);
  820|       |                     if (ec != std::errc{}) [[unlikely]] {
  821|       |                        ctx.error = error_code::parse_number_failure;
  822|       |                        return;
  823|       |                     }
  824|       |                     it = ptr;
  825|       |                  }
  826|       |                  else {
  827|       |                     auto [ptr, ec] = glz::from_chars<Opts.null_terminated>(it, end, temp);
  828|       |                     if (ec != std::errc()) [[unlikely]] {
  829|       |                        ctx.error = error_code::parse_number_failure;
  830|       |                        return;
  831|       |                     }
  832|       |                     it = ptr;
  833|       |                  }
  834|       |                  value = temp;
  835|       |               }
  836|       |               else {
  837|       |                  if constexpr (is_size_optimized(Opts)) {
  838|       |                     auto [ptr, ec] = simple_float::from_chars<Opts.null_terminated>(it, end, value);
  839|       |                     if (ec != std::errc{}) [[unlikely]] {
  840|       |                        ctx.error = error_code::parse_number_failure;
  841|       |                        return;
  842|       |                     }
  843|       |                     it = ptr;
  844|       |                  }
  845|       |                  else {
  846|       |                     auto [ptr, ec] = glz::from_chars<Opts.null_terminated>(it, end, value);
  847|       |                     if (ec != std::errc()) [[unlikely]] {
  848|       |                        ctx.error = error_code::parse_number_failure;
  849|       |                        return;
  850|       |                     }
  851|       |                     it = ptr;
  852|       |                  }
  853|       |               }
  854|       |            }
  855|       |         }
  856|       |
  857|       |         if constexpr (check_quoted_num(Opts)) {
  858|       |            if constexpr (not Opts.null_terminated) {
  859|       |               if (it == end) [[unlikely]] {
  860|       |                  ctx.error = error_code::unexpected_end;
  861|       |                  return;
  862|       |               }
  863|       |            }
  864|       |            if (match<'"'>(ctx, it)) {
  865|       |               return;
  866|       |            }
  867|       |            if constexpr (not Opts.null_terminated) {
  868|       |               if (it == end) {
  869|       |                  ctx.error = error_code::end_reached;
  870|       |                  return;
  871|       |               }
  872|       |            }
  873|       |         }
  874|  86.1k|         else {
  875|  86.1k|            if constexpr (not Opts.null_terminated) {
  876|  86.1k|               if (it == end) {
  ------------------
  |  Branch (876:20): [True: 1.81k, False: 84.3k]
  ------------------
  877|  1.81k|                  ctx.error = error_code::end_reached;
  878|  1.81k|                  return;
  879|  1.81k|               }
  880|  86.1k|            }
  881|  86.1k|         }
  882|  86.1k|      }
_ZN3glz5parseILj10EE2opITnDaXtlNS_22registry_validate_optsIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEEEtlS4_Lj10ELb0ELb0ELb1ELb1EELb1ELb1EEERNS_4skipETkNS_10is_contextERNS_7contextERPKcSB_EEvOT0_OT1_OT2_T3_:
   49|   364k|      {
   50|       |         if constexpr (const_value_v<T>) {
   51|       |            if constexpr (check_error_on_const_read(Opts)) {
   52|       |               ctx.error = error_code::attempt_const_read;
   53|       |            }
   54|       |            else {
   55|       |               // do not read anything into the const value
   56|       |               skip_value<JSON>::op<Opts>(std::forward<Ctx>(ctx), std::forward<It0>(it), end);
   57|       |            }
   58|       |         }
   59|   364k|         else {
   60|   364k|            using V = std::remove_cvref_t<T>;
   61|   364k|            from<JSON, V>::template op<Opts>(std::forward<T>(value), std::forward<Ctx>(ctx), std::forward<It0>(it),
   62|   364k|                                             end);
   63|   364k|         }
   64|   364k|      }
_ZN3glz4fromILj10ENS_4skipEE2opITnDaXtlNS_22registry_validate_optsIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEEEtlS5_Lj10ELb0ELb0ELb1ELb1EELb1ELb1EEERS1_TkNS_10is_contextERNS_7contextEJRPKcSC_EEEvOT0_OT1_DpOT2_:
  564|   364k|      {
  565|   364k|         skip_value<JSON>::op<Opts>(ctx, args...);
  566|   364k|      }
_ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__17variantIJDnNS4_17basic_string_viewIcNS4_11char_traitsIcEEEElEEETkNS_10is_contextERNS_7contextERPKcSF_EEvOT0_OT1_OT2_T3_:
   49|  19.7k|      {
   50|       |         if constexpr (const_value_v<T>) {
   51|       |            if constexpr (check_error_on_const_read(Opts)) {
   52|       |               ctx.error = error_code::attempt_const_read;
   53|       |            }
   54|       |            else {
   55|       |               // do not read anything into the const value
   56|       |               skip_value<JSON>::op<Opts>(std::forward<Ctx>(ctx), std::forward<It0>(it), end);
   57|       |            }
   58|       |         }
   59|  19.7k|         else {
   60|  19.7k|            using V = std::remove_cvref_t<T>;
   61|  19.7k|            from<JSON, V>::template op<Opts>(std::forward<T>(value), std::forward<Ctx>(ctx), std::forward<It0>(it),
   62|  19.7k|                                             end);
   63|  19.7k|         }
   64|  19.7k|      }
_ZN3glz4fromILj10ENSt3__17variantIJDnNS1_17basic_string_viewIcNS1_11char_traitsIcEEEElEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS7_TkNS_10is_contextERNS_7contextERPKcSF_EEvOT0_OT1_OT2_T3_:
 4065|  19.7k|      {
 4066|       |         if constexpr (tagging == variant_tagging_kind::adjacent) {
 4067|       |            read_adjacent<Options>(value, ctx, it, end);
 4068|       |         }
 4069|  19.7k|         else {
 4070|  19.7k|            read_deduced<Options>(value, ctx, it, end);
 4071|  19.7k|         }
 4072|  19.7k|      }
_ZN3glz4fromILj10ENSt3__17variantIJDnNS1_17basic_string_viewIcNS1_11char_traitsIcEEEElEEEE12read_deducedITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS7_TkNS_10is_contextERNS_7contextERPKcSF_EEvOT0_OT1_OT2_T3_:
 4076|  19.7k|      {
 4077|  19.7k|         constexpr auto Opts = ws_handled_off<Options>();
 4078|  19.7k|         if constexpr (variant_is_auto_deducible<T>()) {
 4079|  19.7k|            if constexpr (not check_ws_handled(Options)) {
 4080|  19.7k|               if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (4080:20): [True: 0, False: 19.7k]
  ------------------
 4081|      0|                  return;
 4082|      0|               }
 4083|  19.7k|            }
 4084|       |
 4085|  19.7k|            switch (*it) {
 4086|      0|            case '\0':
  ------------------
  |  Branch (4086:13): [True: 0, False: 19.7k]
  ------------------
 4087|      0|               ctx.error = error_code::unexpected_end;
 4088|      0|               return;
 4089|  1.18k|            case '{': {
  ------------------
  |  Branch (4089:13): [True: 1.18k, False: 18.5k]
  ------------------
 4090|       |               // This branch consumes the brace itself and hands the object to a reader with
 4091|       |               // `opening_handled`, which therefore does not count the level -- but does release it at
 4092|       |               // the closing brace. So the level is taken here, in both buffer modes, and paid back by
 4093|       |               // the reader below.
 4094|  1.18k|               if (enter_depth(ctx)) [[unlikely]] {
  ------------------
  |  Branch (4094:20): [True: 0, False: 1.18k]
  ------------------
 4095|      0|                  return;
 4096|      0|               }
 4097|       |
 4098|  1.18k|               ++it;
 4099|  1.18k|               if constexpr (not Opts.null_terminated) {
 4100|  1.18k|                  if (it == end) [[unlikely]] {
  ------------------
  |  Branch (4100:23): [True: 0, False: 1.18k]
  ------------------
 4101|      0|                     ctx.error = error_code::unexpected_end;
 4102|      0|                     return;
 4103|      0|                  }
 4104|  1.18k|               }
 4105|  1.18k|               using type_counts = variant_type_count<T>;
 4106|  1.18k|               constexpr auto n_object_candidates = variant_object_candidate_count_v<Opts, T>;
 4107|  1.18k|               if constexpr (n_object_candidates < 1) {
 4108|  1.18k|                  ctx.error = error_code::no_matching_variant_type;
 4109|  1.18k|                  return;
 4110|       |               }
 4111|       |               else if constexpr (n_object_candidates == 1 && tag_v<T>.empty()) {
 4112|       |                  constexpr auto first_idx = variant_first_object_candidate_v<Opts, T>;
 4113|       |                  using V = std::variant_alternative_t<first_idx, T>;
 4114|       |                  if (!std::holds_alternative<V>(value)) value = V{};
 4115|       |                  parse<JSON>::op<opening_handled<Opts>()>(std::get<V>(value), ctx, it, end);
 4116|       |                  return;
 4117|       |               }
 4118|       |               else {
 4119|       |                  auto possible_types = bit_array<std::variant_size_v<T>>{}.flip();
 4120|       |                  static constexpr auto& deduction_bits = variant_deduction_bits<T>;
 4121|       |                  static constexpr size_t deduction_key_count = variant_deduction_key_count<T>;
 4122|       |                  static constexpr auto tag_literal = string_literal_from_view<tag_v<T>.size()>(tag_v<T>);
 4123|       |
 4124|       |                  // Track if we've encountered a tag and what value it had
 4125|       |                  std::optional<size_t> tag_specified_index{};
 4126|       |
 4127|       |                  if (skip_ws<Opts>(ctx, it, end)) {
 4128|       |                     return;
 4129|       |                  }
 4130|       |                  // Once the reader knows which alternative this object holds it may have to read
 4131|       |                  // it again from here. Anchor the position rather than keep the pointer: the scan
 4132|       |                  // below skips values, and a streaming skip refills, which moves the window out
 4133|       |                  // from under a raw pointer (see rewind_anchor).
 4134|       |                  auto start = make_rewind_anchor(ctx, it);
 4135|       |                  bool first_key = true;
 4136|       |                  // Parse bifurcation for tagged variants:
 4137|       |                  //
 4138|       |                  // Without this optimization, tagged variant parsing always uses two passes:
 4139|       |                  //   1. Scan all keys to find the tag (e.g. "type"), skipping values
 4140|       |                  //   2. Reset `it = start` and re-parse the entire object into the resolved type
 4141|       |                  //
 4142|       |                  // When the tag is the first key, the second pass redundantly re-reads every
 4143|       |                  // field that follows it. This lambda avoids that: if the tag was the first key,
 4144|       |                  // it advances past the trailing comma so the object parser picks up at the
 4145|       |                  // second field. If the tag was found later, it falls back to the full re-parse.
 4146|       |                  //
 4147|       |                  // One exception: if the tag name is also a field on the resolved struct
 4148|       |                  // (contains_tag), we must re-parse regardless so the value is stored in
 4149|       |                  // the struct field. This override is applied inside each std::visit lambda.
 4150|       |                  //
 4151|       |                  // Either way the rewind can fail under a streaming read: the window only holds so
 4152|       |                  // much, and an object wider than it has no start left to return to.
 4153|       |                  auto position_after_tag = [&] {
 4154|       |                     if (first_key) {
 4155|       |                        if (*it == ',') ++it; // skip comma; handles tag-only objects where *it == '}'
 4156|       |                        return true;
 4157|       |                     }
 4158|       |                     return start.rewind(ctx, it, end); // tag came later, re-parse from the beginning
 4159|       |                  };
 4160|       |                  // `first_key` also answers "were we reset to the object start", which is what
 4161|       |                  // position_after_tag does for every key but the first.
 4162|       |                  for (; *it != '}'; first_key = false) {
 4163|       |                     if (!first_key) {
 4164|       |                        if (match_invalid_end<',', Opts>(ctx, it, end)) {
 4165|       |                           return;
 4166|       |                        }
 4167|       |                     }
 4168|       |
 4169|       |                     if (skip_ws<Opts>(ctx, it, end)) {
 4170|       |                        return;
 4171|       |                     }
 4172|       |                     if (match_invalid_end<'"', Opts>(ctx, it, end)) {
 4173|       |                        return;
 4174|       |                     }
 4175|       |
 4176|       |                     auto* key_start = it;
 4177|       |                     skip_string_view(ctx, it, end);
 4178|       |                     if (bool(ctx.error)) [[unlikely]]
 4179|       |                        return;
 4180|       |                     if (validate_utf8_span<Opts>(ctx, key_start, it)) [[unlikely]]
 4181|       |                        return;
 4182|       |                     const sv key = {key_start, size_t(it - key_start)};
 4183|       |
 4184|       |                     if (match_invalid_end<'"', Opts>(ctx, it, end)) {
 4185|       |                        return;
 4186|       |                     }
 4187|       |
 4188|       |                     if constexpr (deduction_key_count > 0) {
 4189|       |                        // We first check if a tag is defined and see if the key matches the tag
 4190|       |                        if constexpr (not tag_v<T>.empty()) {
 4191|       |                           if (key == tag_v<T>) {
 4192|       |                              if (parse_ws_colon<Opts>(ctx, it, end)) {
 4193|       |                                 return;
 4194|       |                              }
 4195|       |
 4196|       |                              using id_type = std::decay_t<decltype(ids_v<T>[0])>;
 4197|       |
 4198|       |                              std::conditional_t<std::integral<id_type>, id_type, sv> type_id{};
 4199|       |                              if constexpr (std::integral<id_type>) {
 4200|       |                                 from<JSON, id_type>::template op<ws_handled<Opts>()>(type_id, ctx, it, end);
 4201|       |                              }
 4202|       |                              else {
 4203|       |                                 // The id is turned into an index below and never leaves this
 4204|       |                                 // reader, so the view of the window it borrows cannot outlive it.
 4205|       |                                 parse_transient_string_view<ws_handled<Opts>()>(type_id, ctx, it, end);
 4206|       |                              }
 4207|       |                              if (bool(ctx.error)) [[unlikely]]
 4208|       |                                 return;
 4209|       |                              if (skip_ws<Opts>(ctx, it, end)) {
 4210|       |                                 return;
 4211|       |                              }
 4212|       |                              if (!(*it == ',' || *it == '}')) [[unlikely]] {
 4213|       |                                 ctx.error = error_code::syntax_error;
 4214|       |                                 return;
 4215|       |                              }
 4216|       |
 4217|       |                              size_t type_index;
 4218|       |                              if constexpr (std::integral<id_type>) {
 4219|       |                                 type_index = variant_id_to_index<T>::op(type_id);
 4220|       |                              }
 4221|       |                              else {
 4222|       |                                 type_index = variant_id_to_index<T>::op(
 4223|       |                                    type_id.data(), type_id.data() + type_id.size(), type_id.size());
 4224|       |                              }
 4225|       |                              if (type_index < ids_v<T>.size()) [[likely]] {
 4226|       |                                 // Check if the deduced types include the tag-specified type
 4227|       |                                 // If not, the tag doesn't match the fields
 4228|       |                                 // We're already inside if constexpr (deduction_registry.size()), so we know deduction
 4229|       |                                 // is happening. At this point, possible_types has been narrowed by field deduction.
 4230|       |                                 // Check if the tag-specified type is still possible
 4231|       |                                 const bool type_is_possible = possible_types[type_index];
 4232|       |                                 if (!type_is_possible) {
 4233|       |                                    // Tag specifies a type that doesn't match the fields seen so far
 4234|       |                                    ctx.error = error_code::no_matching_variant_type;
 4235|       |                                    return;
 4236|       |                                 }
 4237|       |
 4238|       |                                 if (!position_after_tag()) return;
 4239|       |                                 tag_specified_index = type_index; // Store the tag-specified type
 4240|       |                                 if (value.index() != type_index) emplace_runtime_variant(value, type_index);
 4241|       |                                 std::visit(
 4242|       |                                    [&](auto&& v) {
 4243|       |                                       using V = std::decay_t<decltype(v)>;
 4244|       |                                       constexpr bool is_object =
 4245|       |                                          (glaze_object_t<V> || reflectable<V>) && not custom_read<V>;
 4246|       |                                       if constexpr (variant_unit_alternative<V>) {
 4247|       |                                          // A unit alternative carries no data; its object holds only the
 4248|       |                                          // discriminator. Consume that body through an empty reflected object so
 4249|       |                                          // unknown-key policy and terminator handling match every other alternative.
 4250|       |                                          detail::variant_unit_body unit_body{};
 4251|       |                                          from<JSON, detail::variant_unit_body>::template op<opening_handled<Opts>(),
 4252|       |                                                                                             tag_literal>(unit_body,
 4253|       |                                                                                                          ctx, it, end);
 4254|       |                                       }
 4255|       |                                       else if constexpr (is_object) {
 4256|       |                                          if constexpr (contains_tag<V, tag_literal>()) {
 4257|       |                                             // tag is a struct field, must re-parse
 4258|       |                                             if (!start.rewind(ctx, it, end)) return;
 4259|       |                                          }
 4260|       |                                          from<JSON, V>::template op<opening_handled<Opts>(), tag_literal>(v, ctx, it,
 4261|       |                                                                                                           end);
 4262|       |                                       }
 4263|       |                                       else if constexpr (is_memory_object<V>) {
 4264|       |                                          if (!v) {
 4265|       |                                             if constexpr (is_specialization_v<V, std::optional>) {
 4266|       |                                                if constexpr (requires { v.emplace(); }) {
 4267|       |                                                   v.emplace();
 4268|       |                                                }
 4269|       |                                                else {
 4270|       |                                                   v = typename V::value_type{};
 4271|       |                                                }
 4272|       |                                             }
 4273|       |                                             else if constexpr (is_specialization_v<V, std::unique_ptr>)
 4274|       |                                                v = std::make_unique<typename V::element_type>();
 4275|       |                                             else if constexpr (is_specialization_v<V, std::shared_ptr>)
 4276|       |                                                v = std::make_shared<typename V::element_type>();
 4277|       |                                             else if constexpr (constructible<V>) {
 4278|       |                                                v = meta_construct_v<V>();
 4279|       |                                             }
 4280|       |                                             else if constexpr (std::is_pointer_v<V> &&
 4281|       |                                                                can_allocate_raw_pointer<Opts,
 4282|       |                                                                                         std::decay_t<decltype(ctx)>>) {
 4283|       |                                                if (!try_allocate_raw_pointer<Opts>(v, ctx)) {
 4284|       |                                                   return;
 4285|       |                                                }
 4286|       |                                             }
 4287|       |                                             else {
 4288|       |                                                ctx.error = error_code::invalid_nullable_read;
 4289|       |                                                return;
 4290|       |                                                // Cannot read into unset nullable that is not std::optional,
 4291|       |                                                // std::unique_ptr, or std::shared_ptr
 4292|       |                                             }
 4293|       |                                          }
 4294|       |                                          if constexpr (contains_tag<memory_type<V>, tag_literal>()) {
 4295|       |                                             // tag is a struct field, must re-parse
 4296|       |                                             if (!start.rewind(ctx, it, end)) return;
 4297|       |                                          }
 4298|       |                                          from<JSON, memory_type<V>>::template op<opening_handled<Opts>(), tag_literal>(
 4299|       |                                             *v, ctx, it, end);
 4300|       |                                       }
 4301|       |                                       else if constexpr (custom_read<V>) {
 4302|       |                                          // Custom handlers parse the remaining body themselves and do not
 4303|       |                                          // accept the tag template parameter; the tag was already consumed.
 4304|       |                                          // This only works when the tag was the first key. If it came later,
 4305|       |                                          // we were reset to the object start and the custom handler would
 4306|       |                                          // absorb the tag, so error rather than corrupt the value.
 4307|       |                                          if (!first_key) {
 4308|       |                                             ctx.error = error_code::feature_not_supported;
 4309|       |                                             ctx.custom_error_message =
 4310|       |                                                "the tag must be the first key for a custom variant alternative";
 4311|       |                                             return;
 4312|       |                                          }
 4313|       |                                          from<JSON, V>::template op<opening_handled<Opts>()>(v, ctx, it, end);
 4314|       |                                       }
 4315|       |                                    },
 4316|       |                                    value);
 4317|       |
 4318|       |                                 return; // we've decoded our target type
 4319|       |                              }
 4320|       |                              else [[unlikely]] {
 4321|       |                                 // Check if we have a default type (ids array shorter than variant)
 4322|       |                                 constexpr auto ids_size = ids_v<T>.size();
 4323|       |                                 constexpr auto variant_size = std::variant_size_v<T>;
 4324|       |                                 if constexpr (ids_size < variant_size) {
 4325|       |                                    // Use the first unlabeled type as the default
 4326|       |                                    const auto default_type_index = ids_size;
 4327|       |
 4328|       |                                    if (!position_after_tag()) return;
 4329|       |                                    tag_specified_index = default_type_index; // Store the default type index
 4330|       |                                    if (value.index() != default_type_index)
 4331|       |                                       emplace_runtime_variant(value, default_type_index);
 4332|       |                                    std::visit(
 4333|       |                                       [&](auto&& v) {
 4334|       |                                          using V = std::decay_t<decltype(v)>;
 4335|       |                                          constexpr bool is_object =
 4336|       |                                             (glaze_object_t<V> || reflectable<V>) && not custom_read<V>;
 4337|       |                                          if constexpr (variant_unit_alternative<V>) {
 4338|       |                                             // A unit alternative carries no data; its object holds only the
 4339|       |                                             // discriminator. Consume that body through an empty reflected object so
 4340|       |                                             // unknown-key policy and terminator handling match every other
 4341|       |                                             // alternative.
 4342|       |                                             detail::variant_unit_body unit_body{};
 4343|       |                                             from<JSON, detail::variant_unit_body>::template op<opening_handled<Opts>(),
 4344|       |                                                                                                tag_literal>(
 4345|       |                                                unit_body, ctx, it, end);
 4346|       |                                          }
 4347|       |                                          else if constexpr (is_object) {
 4348|       |                                             if constexpr (contains_tag<V, tag_literal>()) {
 4349|       |                                                // tag is a struct field, must re-parse
 4350|       |                                                if (!start.rewind(ctx, it, end)) return;
 4351|       |                                             }
 4352|       |                                             from<JSON, V>::template op<opening_handled<Opts>()>(v, ctx, it, end);
 4353|       |                                          }
 4354|       |                                          else if constexpr (is_memory_object<V>) {
 4355|       |                                             if (!v) {
 4356|       |                                                if constexpr (is_specialization_v<V, std::optional>) {
 4357|       |                                                   if constexpr (requires { v.emplace(); }) {
 4358|       |                                                      v.emplace();
 4359|       |                                                   }
 4360|       |                                                   else {
 4361|       |                                                      v = typename V::value_type{};
 4362|       |                                                   }
 4363|       |                                                }
 4364|       |                                                else if constexpr (is_specialization_v<V, std::unique_ptr>)
 4365|       |                                                   v = std::make_unique<typename V::element_type>();
 4366|       |                                                else if constexpr (is_specialization_v<V, std::shared_ptr>)
 4367|       |                                                   v = std::make_shared<typename V::element_type>();
 4368|       |                                                else if constexpr (constructible<V>) {
 4369|       |                                                   v = meta_construct_v<V>();
 4370|       |                                                }
 4371|       |                                                else if constexpr (std::is_pointer_v<V> &&
 4372|       |                                                                   can_allocate_raw_pointer<
 4373|       |                                                                      Opts, std::decay_t<decltype(ctx)>>) {
 4374|       |                                                   if (!try_allocate_raw_pointer<Opts>(v, ctx)) {
 4375|       |                                                      return;
 4376|       |                                                   }
 4377|       |                                                }
 4378|       |                                                else {
 4379|       |                                                   ctx.error = error_code::invalid_nullable_read;
 4380|       |                                                   return;
 4381|       |                                                }
 4382|       |                                             }
 4383|       |                                             if constexpr (contains_tag<memory_type<V>, tag_literal>()) {
 4384|       |                                                // tag is a struct field, must re-parse
 4385|       |                                                if (!start.rewind(ctx, it, end)) return;
 4386|       |                                             }
 4387|       |                                             from<JSON, memory_type<V>>::template op<opening_handled<Opts>()>(*v, ctx,
 4388|       |                                                                                                              it, end);
 4389|       |                                          }
 4390|       |                                          else if constexpr (custom_read<V>) {
 4391|       |                                             // Custom handlers parse the remaining body themselves; this only
 4392|       |                                             // works when the tag was the first key (see above). If it came
 4393|       |                                             // later we were reset to the object start, so error rather than
 4394|       |                                             // let the custom handler absorb the tag.
 4395|       |                                             if (!first_key) {
 4396|       |                                                ctx.error = error_code::feature_not_supported;
 4397|       |                                                ctx.custom_error_message =
 4398|       |                                                   "the tag must be the first key for a custom variant alternative";
 4399|       |                                                return;
 4400|       |                                             }
 4401|       |                                             from<JSON, V>::template op<opening_handled<Opts>()>(v, ctx, it, end);
 4402|       |                                          }
 4403|       |                                       },
 4404|       |                                       value);
 4405|       |
 4406|       |                                    return;
 4407|       |                                 }
 4408|       |                                 else {
 4409|       |                                    ctx.error = error_code::no_matching_variant_type;
 4410|       |                                    ctx.custom_error_message = variant_ids_string_v<T>;
 4411|       |                                    return;
 4412|       |                                 }
 4413|       |                              }
 4414|       |                           }
 4415|       |                        }
 4416|       |
 4417|       |                        // Inline decode_hash lookup for variant deduction
 4418|       |                        using deduction_keys_t = keys_wrapper<variant_deduction_keys<T>>;
 4419|       |                        constexpr auto& DeductionHashInfo = hash_info<deduction_keys_t>;
 4420|       |                        const auto deduction_index =
 4421|       |                           decode_hash_with_size<JSON, deduction_keys_t, DeductionHashInfo, DeductionHashInfo.type>::op(
 4422|       |                              key.data(), key.data() + key.size(), key.size());
 4423|       |                        if (deduction_index < deduction_key_count && variant_deduction_keys<T>[deduction_index] == key)
 4424|       |                           [[likely]] {
 4425|       |                           possible_types &= deduction_bits[deduction_index];
 4426|       |                        }
 4427|       |                        else if constexpr (Opts.error_on_unknown_keys) {
 4428|       |                           ctx.error = error_code::unknown_key;
 4429|       |                           return;
 4430|       |                        }
 4431|       |                     }
 4432|       |                     else if constexpr (not tag_v<T>.empty()) {
 4433|       |                        // empty object case for variant, if there are no normal elements
 4434|       |                        if (key == tag_v<T>) {
 4435|       |                           if (parse_ws_colon<Opts>(ctx, it, end)) {
 4436|       |                              return;
 4437|       |                           }
 4438|       |
 4439|       |                           // The id is turned into an index below and never leaves this reader,
 4440|       |                           // so the view of the window it borrows cannot outlive that window.
 4441|       |                           std::string_view type_id{};
 4442|       |                           parse_transient_string_view<ws_handled<Opts>()>(type_id, ctx, it, end);
 4443|       |                           if (bool(ctx.error)) [[unlikely]]
 4444|       |                              return;
 4445|       |                           if (skip_ws<Opts>(ctx, it, end)) {
 4446|       |                              return;
 4447|       |                           }
 4448|       |
 4449|       |                           const auto type_index = variant_id_to_index<T>::op(
 4450|       |                              type_id.data(), type_id.data() + type_id.size(), type_id.size());
 4451|       |                           if (type_index < ids_v<T>.size()) [[likely]] {
 4452|       |                              if (!position_after_tag()) return;
 4453|       |                              tag_specified_index = type_index; // Store the tag-specified type
 4454|       |                              if (value.index() != type_index) emplace_runtime_variant(value, type_index);
 4455|       |                           }
 4456|       |                           else {
 4457|       |                              // Check if we have a default type (ids array shorter than variant)
 4458|       |                              constexpr auto ids_size = ids_v<T>.size();
 4459|       |                              constexpr auto variant_size = std::variant_size_v<T>;
 4460|       |                              if constexpr (ids_size < variant_size) {
 4461|       |                                 // Use the first unlabeled type as the default
 4462|       |                                 if (!position_after_tag()) return;
 4463|       |                                 const auto default_index = ids_size;
 4464|       |                                 tag_specified_index = default_index; // Store the default type index
 4465|       |                                 if (value.index() != default_index) emplace_runtime_variant(value, default_index);
 4466|       |                              }
 4467|       |                              else {
 4468|       |                                 ctx.error = error_code::no_matching_variant_type;
 4469|       |                                 ctx.custom_error_message = variant_ids_string_v<T>;
 4470|       |                                 return;
 4471|       |                              }
 4472|       |                           }
 4473|       |                           // Parse the type (handles tag skipping and unknown keys)
 4474|       |                           std::visit(
 4475|       |                              [&](auto&& v) {
 4476|       |                                 using V = std::decay_t<decltype(v)>;
 4477|       |                                 if constexpr (custom_read<V>) {
 4478|       |                                    // Custom handlers parse the remaining object body themselves and do not
 4479|       |                                    // accept the tag template parameter that reflected objects use to skip an
 4480|       |                                    // interior tag key. That only works when the tag is the first key (it was
 4481|       |                                    // just consumed). If the tag came after other keys, position_after_tag()
 4482|       |                                    // reset us to the object start and the custom handler would absorb the tag
 4483|       |                                    // into its value, so error here rather than corrupt the result.
 4484|       |                                    if (!first_key) {
 4485|       |                                       ctx.error = error_code::feature_not_supported;
 4486|       |                                       ctx.custom_error_message =
 4487|       |                                          "the tag must be the first key for a custom variant alternative";
 4488|       |                                       return;
 4489|       |                                    }
 4490|       |                                    from<JSON, V>::template op<opening_handled<Opts>()>(v, ctx, it, end);
 4491|       |                                 }
 4492|       |                                 else {
 4493|       |                                    if constexpr (contains_tag<V, tag_literal>()) {
 4494|       |                                       // tag is a struct field, must re-parse
 4495|       |                                       if (!start.rewind(ctx, it, end)) return;
 4496|       |                                    }
 4497|       |                                    from<JSON, V>::template op<opening_handled<Opts>(), tag_literal>(v, ctx, it, end);
 4498|       |                                 }
 4499|       |                              },
 4500|       |                              value);
 4501|       |                           return;
 4502|       |                        }
 4503|       |                        else if constexpr (Opts.error_on_unknown_keys) {
 4504|       |                           ctx.error = error_code::unknown_key;
 4505|       |                           return;
 4506|       |                        }
 4507|       |                        else {
 4508|       |                           // Skip unknown key's value (non-tag key in empty variant)
 4509|       |                           if (parse_ws_colon<Opts>(ctx, it, end)) {
 4510|       |                              return;
 4511|       |                           }
 4512|       |                           skip_value<JSON>::op<Opts>(ctx, it, end);
 4513|       |                           if (bool(ctx.error)) [[unlikely]]
 4514|       |                              return;
 4515|       |                           resync_window_end(ctx, end); // a streaming skip refills
 4516|       |                           if (skip_ws<Opts>(ctx, it, end)) {
 4517|       |                              return;
 4518|       |                           }
 4519|       |                           continue; // Continue loop to find the tag
 4520|       |                        }
 4521|       |                     }
 4522|       |                     else if constexpr (Opts.error_on_unknown_keys) {
 4523|       |                        ctx.error = error_code::unknown_key;
 4524|       |                        return;
 4525|       |                     }
 4526|       |
 4527|       |                     auto matching_types = possible_types.popcount();
 4528|       |                     if (matching_types == 0) {
 4529|       |                        ctx.error = error_code::no_matching_variant_type;
 4530|       |                        return;
 4531|       |                     }
 4532|       |                     // Only short-circuit for variants without tags
 4533|       |                     else if constexpr (tag_v<T>.empty()) {
 4534|       |                        if (matching_types == 1) {
 4535|       |                           if (!start.rewind(ctx, it, end)) return;
 4536|       |                           const auto type_index = possible_types.countr_zero();
 4537|       |
 4538|       |                           if (value.index() != static_cast<size_t>(type_index))
 4539|       |                              emplace_runtime_variant(value, type_index);
 4540|       |                           std::visit(
 4541|       |                              [&](auto&& v) {
 4542|       |                                 using V = std::decay_t<decltype(v)>;
 4543|       |                                 constexpr bool is_object = (glaze_object_t<V> || reflectable<V>) && not custom_read<V>;
 4544|       |                                 if constexpr (variant_unit_alternative<V>) {
 4545|       |                                    // A unit alternative carries no data; its object holds only the discriminator.
 4546|       |                                    // Consume that body through an empty reflected object so unknown-key policy and
 4547|       |                                    // terminator handling match every other alternative.
 4548|       |                                    detail::variant_unit_body unit_body{};
 4549|       |                                    from<JSON, detail::variant_unit_body>::template op<opening_handled<Opts>(),
 4550|       |                                                                                       tag_literal>(unit_body, ctx, it,
 4551|       |                                                                                                    end);
 4552|       |                                 }
 4553|       |                                 else if constexpr (is_object) {
 4554|       |                                    from<JSON, V>::template op<opening_handled<Opts>(), tag_literal>(v, ctx, it, end);
 4555|       |                                 }
 4556|       |                                 else if constexpr (is_memory_object<V>) {
 4557|       |                                    if (!v) {
 4558|       |                                       if constexpr (is_specialization_v<V, std::optional>) {
 4559|       |                                          if constexpr (requires { v.emplace(); }) {
 4560|       |                                             v.emplace();
 4561|       |                                          }
 4562|       |                                          else {
 4563|       |                                             v = typename V::value_type{};
 4564|       |                                          }
 4565|       |                                       }
 4566|       |                                       else if constexpr (is_specialization_v<V, std::unique_ptr>)
 4567|       |                                          v = std::make_unique<typename V::element_type>();
 4568|       |                                       else if constexpr (is_specialization_v<V, std::shared_ptr>)
 4569|       |                                          v = std::make_shared<typename V::element_type>();
 4570|       |                                       else if constexpr (constructible<V>) {
 4571|       |                                          v = meta_construct_v<V>();
 4572|       |                                       }
 4573|       |                                       else if constexpr (std::is_pointer_v<V> &&
 4574|       |                                                          can_allocate_raw_pointer<Opts, std::decay_t<decltype(ctx)>>) {
 4575|       |                                          if (!try_allocate_raw_pointer<Opts>(v, ctx)) {
 4576|       |                                             return;
 4577|       |                                          }
 4578|       |                                       }
 4579|       |                                       else {
 4580|       |                                          ctx.error = error_code::invalid_nullable_read;
 4581|       |                                          return;
 4582|       |                                          // Cannot read into unset nullable that is not std::optional,
 4583|       |                                          // std::unique_ptr, or std::shared_ptr
 4584|       |                                       }
 4585|       |                                    }
 4586|       |                                    from<JSON, memory_type<V>>::template op<opening_handled<Opts>(), tag_literal>(
 4587|       |                                       *v, ctx, it, end);
 4588|       |                                 }
 4589|       |                                 else if constexpr (custom_read<V>) {
 4590|       |                                    // Custom handlers parse the remaining body themselves.
 4591|       |                                    from<JSON, V>::template op<opening_handled<Opts>()>(v, ctx, it, end);
 4592|       |                                 }
 4593|       |                              },
 4594|       |                              value);
 4595|       |
 4596|       |                           return; // we've decoded our target type
 4597|       |                        }
 4598|       |                     }
 4599|       |                     // For tagged variants, continue processing to validate tags
 4600|       |                     if (parse_ws_colon<Opts>(ctx, it, end)) {
 4601|       |                        return;
 4602|       |                     }
 4603|       |
 4604|       |                     skip_value<JSON>::op<Opts>(ctx, it, end);
 4605|       |                     if (bool(ctx.error)) [[unlikely]]
 4606|       |                        return;
 4607|       |                     resync_window_end(ctx, end); // a streaming skip refills
 4608|       |                     if (skip_ws<Opts>(ctx, it, end)) {
 4609|       |                        return;
 4610|       |                     }
 4611|       |                  }
 4612|       |                  // Only apply ambiguous variant resolution if we have multiple object types
 4613|       |                  if constexpr ((type_counts::n_object + type_counts::n_nullable_object) > 1) {
 4614|       |                     // After parsing all keys, check if we have multiple matching types
 4615|       |                     // If so, choose the one with the fewest fields
 4616|       |                     auto final_matching = possible_types.popcount();
 4617|       |                     if (final_matching == 0) {
 4618|       |                        ctx.error = error_code::no_matching_variant_type;
 4619|       |                     }
 4620|       |                     else if (final_matching == 1) {
 4621|       |                        // Single type remains after field deduction
 4622|       |                        const auto type_index = possible_types.countr_zero();
 4623|       |
 4624|       |                        // Validate against tag if one was specified
 4625|       |                        if (tag_specified_index.has_value() &&
 4626|       |                            tag_specified_index.value() != static_cast<size_t>(type_index)) {
 4627|       |                           ctx.error = error_code::no_matching_variant_type;
 4628|       |                           return;
 4629|       |                        }
 4630|       |
 4631|       |                        if (!start.rewind(ctx, it, end)) return;
 4632|       |                        if (value.index() != static_cast<size_t>(type_index))
 4633|       |                           emplace_runtime_variant(value, type_index);
 4634|       |                        std::visit(
 4635|       |                           [&](auto&& v) {
 4636|       |                              using V = std::decay_t<decltype(v)>;
 4637|       |                              constexpr bool is_object = (glaze_object_t<V> || reflectable<V>) && not custom_read<V>;
 4638|       |                              if constexpr (variant_unit_alternative<V>) {
 4639|       |                                 // A unit alternative carries no data; its object holds only the discriminator.
 4640|       |                                 // Consume that body through an empty reflected object so unknown-key policy and
 4641|       |                                 // terminator handling match every other alternative.
 4642|       |                                 detail::variant_unit_body unit_body{};
 4643|       |                                 from<JSON, detail::variant_unit_body>::template op<opening_handled<Opts>(),
 4644|       |                                                                                    tag_literal>(unit_body, ctx, it,
 4645|       |                                                                                                 end);
 4646|       |                              }
 4647|       |                              else if constexpr (is_object) {
 4648|       |                                 from<JSON, V>::template op<opening_handled<Opts>(), tag_literal>(v, ctx, it, end);
 4649|       |                              }
 4650|       |                              else if constexpr (is_memory_object<V>) {
 4651|       |                                 if (!v) {
 4652|       |                                    if constexpr (is_specialization_v<V, std::optional>) {
 4653|       |                                       if constexpr (requires { v.emplace(); }) {
 4654|       |                                          v.emplace();
 4655|       |                                       }
 4656|       |                                       else {
 4657|       |                                          v = typename V::value_type{};
 4658|       |                                       }
 4659|       |                                    }
 4660|       |                                    else if constexpr (is_specialization_v<V, std::unique_ptr>)
 4661|       |                                       v = std::make_unique<typename V::element_type>();
 4662|       |                                    else if constexpr (is_specialization_v<V, std::shared_ptr>)
 4663|       |                                       v = std::make_shared<typename V::element_type>();
 4664|       |                                    else if constexpr (constructible<V>) {
 4665|       |                                       v = meta_construct_v<V>();
 4666|       |                                    }
 4667|       |                                    else if constexpr (std::is_pointer_v<V> &&
 4668|       |                                                       can_allocate_raw_pointer<Opts, std::decay_t<decltype(ctx)>>) {
 4669|       |                                       if (!try_allocate_raw_pointer<Opts>(v, ctx)) {
 4670|       |                                          return;
 4671|       |                                       }
 4672|       |                                    }
 4673|       |                                    else {
 4674|       |                                       ctx.error = error_code::invalid_nullable_read;
 4675|       |                                       return;
 4676|       |                                    }
 4677|       |                                 }
 4678|       |                                 from<JSON, memory_type<V>>::template op<opening_handled<Opts>(), tag_literal>(*v, ctx,
 4679|       |                                                                                                               it, end);
 4680|       |                              }
 4681|       |                              else if constexpr (custom_read<V>) {
 4682|       |                                 // Custom handlers parse the remaining body themselves.
 4683|       |                                 from<JSON, V>::template op<opening_handled<Opts>()>(v, ctx, it, end);
 4684|       |                              }
 4685|       |                           },
 4686|       |                           value);
 4687|       |                     }
 4688|       |                     else if (final_matching > 1) {
 4689|       |                        constexpr auto N = std::variant_size_v<T>;
 4690|       |
 4691|       |                        // Compile-time array of field counts for each variant type
 4692|       |                        constexpr auto field_counts = []<size_t... I>(std::index_sequence<I...>) {
 4693|       |                           return std::array<size_t, N> {
 4694|       |                              ([]<size_t J = I>() -> size_t {
 4695|       |                                 using V = std::decay_t<std::variant_alternative_t<J, T>>;
 4696|       |                                 if constexpr (glaze_object_t<V> || reflectable<V>) {
 4697|       |                                    return reflect<V>::size;
 4698|       |                                 }
 4699|       |                                 else if constexpr (is_memory_object<V>) {
 4700|       |                                    using X = memory_type<V>;
 4701|       |                                    if constexpr (glaze_object_t<X> || reflectable<X>) {
 4702|       |                                       return reflect<X>::size;
 4703|       |                                    }
 4704|       |                                    else {
 4705|       |                                       return (std::numeric_limits<size_t>::max)();
 4706|       |                                    }
 4707|       |                                 }
 4708|       |                                 else {
 4709|       |                                    return (std::numeric_limits<size_t>::max)();
 4710|       |                                 }
 4711|       |                              }.template operator()<I>())...
 4712|       |                           };
 4713|       |                        }(std::make_index_sequence<N>{});
 4714|       |
 4715|       |                        // Find the type with minimum field count among the possible types
 4716|       |                        size_t min_fields = (std::numeric_limits<size_t>::max)();
 4717|       |                        size_t chosen_index = N; // Invalid index initially
 4718|       |
 4719|       |                        for (size_t i = 0; i < N; ++i) {
 4720|       |                           if (possible_types[i] && field_counts[i] < min_fields) {
 4721|       |                              min_fields = field_counts[i];
 4722|       |                              chosen_index = i;
 4723|       |                           }
 4724|       |                        }
 4725|       |
 4726|       |                        if (chosen_index < N) {
 4727|       |                           // Validate against tag if one was specified
 4728|       |                           if (tag_specified_index.has_value() && tag_specified_index.value() != chosen_index) {
 4729|       |                              ctx.error = error_code::no_matching_variant_type;
 4730|       |                              return;
 4731|       |                           }
 4732|       |
 4733|       |                           if (!start.rewind(ctx, it, end)) return;
 4734|       |                           if (value.index() != chosen_index) emplace_runtime_variant(value, chosen_index);
 4735|       |                           std::visit(
 4736|       |                              [&](auto&& v) {
 4737|       |                                 using V = std::decay_t<decltype(v)>;
 4738|       |                                 constexpr bool is_object = (glaze_object_t<V> || reflectable<V>) && not custom_read<V>;
 4739|       |                                 if constexpr (variant_unit_alternative<V>) {
 4740|       |                                    // A unit alternative carries no data; its object holds only the discriminator.
 4741|       |                                    // Consume that body through an empty reflected object so unknown-key policy and
 4742|       |                                    // terminator handling match every other alternative.
 4743|       |                                    detail::variant_unit_body unit_body{};
 4744|       |                                    from<JSON, detail::variant_unit_body>::template op<opening_handled<Opts>(),
 4745|       |                                                                                       tag_literal>(unit_body, ctx, it,
 4746|       |                                                                                                    end);
 4747|       |                                 }
 4748|       |                                 else if constexpr (is_object) {
 4749|       |                                    from<JSON, V>::template op<opening_handled<Opts>(), tag_literal>(v, ctx, it, end);
 4750|       |                                 }
 4751|       |                                 else if constexpr (is_memory_object<V>) {
 4752|       |                                    if (!v) {
 4753|       |                                       if constexpr (is_specialization_v<V, std::optional>) {
 4754|       |                                          if constexpr (requires { v.emplace(); }) {
 4755|       |                                             v.emplace();
 4756|       |                                          }
 4757|       |                                          else {
 4758|       |                                             v = typename V::value_type{};
 4759|       |                                          }
 4760|       |                                       }
 4761|       |                                       else if constexpr (is_specialization_v<V, std::unique_ptr>)
 4762|       |                                          v = std::make_unique<typename V::element_type>();
 4763|       |                                       else if constexpr (is_specialization_v<V, std::shared_ptr>)
 4764|       |                                          v = std::make_shared<typename V::element_type>();
 4765|       |                                       else if constexpr (constructible<V>) {
 4766|       |                                          v = meta_construct_v<V>();
 4767|       |                                       }
 4768|       |                                       else if constexpr (std::is_pointer_v<V> &&
 4769|       |                                                          can_allocate_raw_pointer<Opts, std::decay_t<decltype(ctx)>>) {
 4770|       |                                          if (!try_allocate_raw_pointer<Opts>(v, ctx)) {
 4771|       |                                             return;
 4772|       |                                          }
 4773|       |                                       }
 4774|       |                                       else {
 4775|       |                                          ctx.error = error_code::invalid_nullable_read;
 4776|       |                                          return;
 4777|       |                                       }
 4778|       |                                    }
 4779|       |                                    from<JSON, memory_type<V>>::template op<opening_handled<Opts>(), tag_literal>(
 4780|       |                                       *v, ctx, it, end);
 4781|       |                                 }
 4782|       |                                 else if constexpr (custom_read<V>) {
 4783|       |                                    // Custom handlers parse the remaining body themselves.
 4784|       |                                    from<JSON, V>::template op<opening_handled<Opts>()>(v, ctx, it, end);
 4785|       |                                 }
 4786|       |                              },
 4787|       |                              value);
 4788|       |                        }
 4789|       |                        else {
 4790|       |                           ctx.error = error_code::no_matching_variant_type;
 4791|       |                        }
 4792|       |                     }
 4793|       |                  }
 4794|       |                  else {
 4795|       |                     // For variants with 0 or 1 object types, use the original error handling
 4796|       |                     ctx.error = error_code::no_matching_variant_type;
 4797|       |                  }
 4798|       |               }
 4799|      0|               break;
 4800|  1.18k|            }
 4801|  2.30k|            case '[':
  ------------------
  |  Branch (4801:13): [True: 2.30k, False: 17.4k]
  ------------------
 4802|       |               // As with '{' above: the array reader each alternative goes through counts the level.
 4803|  2.30k|               process_variant_alternatives<T, is_variant_array>::template op<Opts>(value, ctx, it, end);
 4804|  2.30k|               break;
 4805|    963|            case '"': {
  ------------------
  |  Branch (4805:13): [True: 963, False: 18.7k]
  ------------------
 4806|    963|               process_variant_alternatives<T, is_variant_str>::template op<Opts>(value, ctx, it, end);
 4807|    963|               break;
 4808|  1.18k|            }
 4809|    328|            case 't':
  ------------------
  |  Branch (4809:13): [True: 328, False: 19.3k]
  ------------------
 4810|    768|            case 'f': {
  ------------------
  |  Branch (4810:13): [True: 440, False: 19.2k]
  ------------------
 4811|    768|               process_variant_alternatives<T, is_variant_bool>::template op<Opts>(value, ctx, it, end);
 4812|    768|               break;
 4813|    328|            }
 4814|    268|            case 'n':
  ------------------
  |  Branch (4814:13): [True: 268, False: 19.4k]
  ------------------
 4815|       |               if constexpr (variant_count_v<T, is_variant_null> == 0) {
 4816|       |                  ctx.error = error_code::no_matching_variant_type;
 4817|       |               }
 4818|    268|               else {
 4819|    268|                  constexpr auto first_idx = variant_first_index_v<T, is_variant_null>;
 4820|    268|                  using V = std::variant_alternative_t<first_idx, T>;
 4821|    268|                  if (!std::holds_alternative<V>(value)) value = V{};
  ------------------
  |  Branch (4821:23): [True: 0, False: 268]
  ------------------
 4822|    268|                  match<"null", Opts>(ctx, it, end);
 4823|    268|               }
 4824|    268|               break;
 4825|  14.2k|            default: {
  ------------------
  |  Branch (4825:13): [True: 14.2k, False: 5.48k]
  ------------------
 4826|       |               // Not bool, string, object, or array so must be number or null
 4827|  14.2k|               process_variant_alternatives<T, is_variant_num>::template op<Opts>(value, ctx, it, end);
 4828|  14.2k|            }
 4829|  19.7k|            }
 4830|       |         }
 4831|       |         else {
 4832|       |            // For non-auto-deducible variants, try each type until one succeeds
 4833|       |            constexpr auto N = std::variant_size_v<T>;
 4834|       |            bool parsed = false;
 4835|       |            bool exhausted = false; // speculation budget spent; see charge_speculation
 4836|       |
 4837|       |            for_each<N>([&]<size_t I>() {
 4838|       |               if (parsed || exhausted || variant_alternative_exhausted(ctx)) return;
 4839|       |
 4840|       |               auto copy_it = it;
 4841|       |               // A rejected alternative may have bailed out inside a container, which leaves its
 4842|       |               // nesting level counted (see enter_depth), so the depth rewinds with the iterator.
 4843|       |               const auto copy_depth = ctx.depth;
 4844|       |
 4845|       |               // Try parsing as this type
 4846|       |               if (value.index() != I) {
 4847|       |                  emplace_runtime_variant(value, I);
 4848|       |               }
 4849|       |
 4850|       |               std::visit([&](auto&& v) { parse<JSON>::op<Options>(v, ctx, it, end); }, value);
 4851|       |               if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) {
 4852|       |                  exhausted = true; // only rejected attempts are charged; see charge_speculation
 4853|       |               }
 4854|       |
 4855|       |               if (!bool(ctx.error)) {
 4856|       |                  parsed = true;
 4857|       |               }
 4858|       |               else if constexpr (not Options.null_terminated) {
 4859|       |                  // In non-null-terminated mode, if we hit end_reached after advancing the iterator,
 4860|       |                  // it means we successfully parsed the value but couldn't skip trailing whitespace
 4861|       |                  if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) {
 4862|       |                     // We advanced the iterator, so we did parse something -- unless what advanced it
 4863|       |                     // was an abandoned attempt, which is what a spent speculation budget means.
 4864|       |                     parsed = true;
 4865|       |                     ctx.error = error_code::none;
 4866|       |                  }
 4867|       |                  else {
 4868|       |                     // Reset for next attempt (unless this is the last type)
 4869|       |                     it = copy_it;
 4870|       |                     rewind_depth<Options>(ctx, copy_depth);
 4871|       |                     if constexpr (I + 1 < N) {
 4872|       |                        if (not exhausted && not variant_alternative_exhausted(ctx)) {
 4873|       |                           ctx.error = error_code::none; // Clear error for next attempt
 4874|       |                        }
 4875|       |                     }
 4876|       |                  }
 4877|       |               }
 4878|       |               else {
 4879|       |                  // Reset for next attempt (unless this is the last type)
 4880|       |                  it = copy_it;
 4881|       |                  rewind_depth<Options>(ctx, copy_depth);
 4882|       |                  if constexpr (I + 1 < N) {
 4883|       |                     if (not exhausted && not variant_alternative_exhausted(ctx)) {
 4884|       |                        ctx.error = error_code::none; // Clear error for next attempt
 4885|       |                     }
 4886|       |                  }
 4887|       |               }
 4888|       |            });
 4889|       |         }
 4890|  19.7k|      }
_ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNS_12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEETkNS_10is_contextERNS_7contextERPKcSC_EEvOT0_OT1_OT2_T3_:
   49|  58.0k|      {
   50|       |         if constexpr (const_value_v<T>) {
   51|       |            if constexpr (check_error_on_const_read(Opts)) {
   52|       |               ctx.error = error_code::attempt_const_read;
   53|       |            }
   54|       |            else {
   55|       |               // do not read anything into the const value
   56|       |               skip_value<JSON>::op<Opts>(std::forward<Ctx>(ctx), std::forward<It0>(it), end);
   57|       |            }
   58|       |         }
   59|  58.0k|         else {
   60|  58.0k|            using V = std::remove_cvref_t<T>;
   61|  58.0k|            from<JSON, V>::template op<Opts>(std::forward<T>(value), std::forward<Ctx>(ctx), std::forward<It0>(it),
   62|  58.0k|                                             end);
   63|  58.0k|         }
   64|  58.0k|      }
_ZN3glz4fromILj10ENS_12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS4_TkNS_10is_contextERNS_7contextERPKcSC_EEvOT0_OT1_OT2_T3_:
  150|  58.0k|      {
  151|  58.0k|         using V = std::decay_t<decltype(get_member(std::declval<Value>(), meta_wrapper_v<T>))>;
  152|  58.0k|         from<JSON, V>::template op<Opts>(get_member(std::forward<Value>(value), meta_wrapper_v<T>),
  153|  58.0k|                                          std::forward<Ctx>(ctx), std::forward<It0>(it), end);
  154|  58.0k|      }
_ZN3glz4fromILj10ENSt3__17variantIJDndNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEbNS1_6vectorINS_12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEENS6_ISD_EEEENSC_ISD_EEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSH_TkNS_10is_contextERNS_7contextERPKcSP_EEvOT0_OT1_OT2_T3_:
 4065|  58.0k|      {
 4066|       |         if constexpr (tagging == variant_tagging_kind::adjacent) {
 4067|       |            read_adjacent<Options>(value, ctx, it, end);
 4068|       |         }
 4069|  58.0k|         else {
 4070|  58.0k|            read_deduced<Options>(value, ctx, it, end);
 4071|  58.0k|         }
 4072|  58.0k|      }
_ZN3glz4fromILj10ENSt3__17variantIJDndNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEbNS1_6vectorINS_12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEENS6_ISD_EEEENSC_ISD_EEEEEE12read_deducedITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSH_TkNS_10is_contextERNS_7contextERPKcSP_EEvOT0_OT1_OT2_T3_:
 4076|  58.0k|      {
 4077|  58.0k|         constexpr auto Opts = ws_handled_off<Options>();
 4078|  58.0k|         if constexpr (variant_is_auto_deducible<T>()) {
 4079|  58.0k|            if constexpr (not check_ws_handled(Options)) {
 4080|  58.0k|               if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (4080:20): [True: 0, False: 58.0k]
  ------------------
 4081|      0|                  return;
 4082|      0|               }
 4083|  58.0k|            }
 4084|       |
 4085|  58.0k|            switch (*it) {
 4086|      0|            case '\0':
  ------------------
  |  Branch (4086:13): [True: 0, False: 58.0k]
  ------------------
 4087|      0|               ctx.error = error_code::unexpected_end;
 4088|      0|               return;
 4089|  41.4k|            case '{': {
  ------------------
  |  Branch (4089:13): [True: 41.4k, False: 16.5k]
  ------------------
 4090|       |               // This branch consumes the brace itself and hands the object to a reader with
 4091|       |               // `opening_handled`, which therefore does not count the level -- but does release it at
 4092|       |               // the closing brace. So the level is taken here, in both buffer modes, and paid back by
 4093|       |               // the reader below.
 4094|  41.4k|               if (enter_depth(ctx)) [[unlikely]] {
  ------------------
  |  Branch (4094:20): [True: 0, False: 41.4k]
  ------------------
 4095|      0|                  return;
 4096|      0|               }
 4097|       |
 4098|  41.4k|               ++it;
 4099|  41.4k|               if constexpr (not Opts.null_terminated) {
 4100|  41.4k|                  if (it == end) [[unlikely]] {
  ------------------
  |  Branch (4100:23): [True: 0, False: 41.4k]
  ------------------
 4101|      0|                     ctx.error = error_code::unexpected_end;
 4102|      0|                     return;
 4103|      0|                  }
 4104|  41.4k|               }
 4105|  41.4k|               using type_counts = variant_type_count<T>;
 4106|  41.4k|               constexpr auto n_object_candidates = variant_object_candidate_count_v<Opts, T>;
 4107|       |               if constexpr (n_object_candidates < 1) {
 4108|       |                  ctx.error = error_code::no_matching_variant_type;
 4109|       |                  return;
 4110|       |               }
 4111|  41.4k|               else if constexpr (n_object_candidates == 1 && tag_v<T>.empty()) {
 4112|  41.4k|                  constexpr auto first_idx = variant_first_object_candidate_v<Opts, T>;
 4113|  41.4k|                  using V = std::variant_alternative_t<first_idx, T>;
 4114|  41.4k|                  if (!std::holds_alternative<V>(value)) value = V{};
  ------------------
  |  Branch (4114:23): [True: 41.4k, False: 0]
  ------------------
 4115|  41.4k|                  parse<JSON>::op<opening_handled<Opts>()>(std::get<V>(value), ctx, it, end);
 4116|  41.4k|                  return;
 4117|       |               }
 4118|       |               else {
 4119|       |                  auto possible_types = bit_array<std::variant_size_v<T>>{}.flip();
 4120|       |                  static constexpr auto& deduction_bits = variant_deduction_bits<T>;
 4121|       |                  static constexpr size_t deduction_key_count = variant_deduction_key_count<T>;
 4122|       |                  static constexpr auto tag_literal = string_literal_from_view<tag_v<T>.size()>(tag_v<T>);
 4123|       |
 4124|       |                  // Track if we've encountered a tag and what value it had
 4125|       |                  std::optional<size_t> tag_specified_index{};
 4126|       |
 4127|       |                  if (skip_ws<Opts>(ctx, it, end)) {
 4128|       |                     return;
 4129|       |                  }
 4130|       |                  // Once the reader knows which alternative this object holds it may have to read
 4131|       |                  // it again from here. Anchor the position rather than keep the pointer: the scan
 4132|       |                  // below skips values, and a streaming skip refills, which moves the window out
 4133|       |                  // from under a raw pointer (see rewind_anchor).
 4134|       |                  auto start = make_rewind_anchor(ctx, it);
 4135|       |                  bool first_key = true;
 4136|       |                  // Parse bifurcation for tagged variants:
 4137|       |                  //
 4138|       |                  // Without this optimization, tagged variant parsing always uses two passes:
 4139|       |                  //   1. Scan all keys to find the tag (e.g. "type"), skipping values
 4140|       |                  //   2. Reset `it = start` and re-parse the entire object into the resolved type
 4141|       |                  //
 4142|       |                  // When the tag is the first key, the second pass redundantly re-reads every
 4143|       |                  // field that follows it. This lambda avoids that: if the tag was the first key,
 4144|       |                  // it advances past the trailing comma so the object parser picks up at the
 4145|       |                  // second field. If the tag was found later, it falls back to the full re-parse.
 4146|       |                  //
 4147|       |                  // One exception: if the tag name is also a field on the resolved struct
 4148|       |                  // (contains_tag), we must re-parse regardless so the value is stored in
 4149|       |                  // the struct field. This override is applied inside each std::visit lambda.
 4150|       |                  //
 4151|       |                  // Either way the rewind can fail under a streaming read: the window only holds so
 4152|       |                  // much, and an object wider than it has no start left to return to.
 4153|       |                  auto position_after_tag = [&] {
 4154|       |                     if (first_key) {
 4155|       |                        if (*it == ',') ++it; // skip comma; handles tag-only objects where *it == '}'
 4156|       |                        return true;
 4157|       |                     }
 4158|       |                     return start.rewind(ctx, it, end); // tag came later, re-parse from the beginning
 4159|       |                  };
 4160|       |                  // `first_key` also answers "were we reset to the object start", which is what
 4161|       |                  // position_after_tag does for every key but the first.
 4162|       |                  for (; *it != '}'; first_key = false) {
 4163|       |                     if (!first_key) {
 4164|       |                        if (match_invalid_end<',', Opts>(ctx, it, end)) {
 4165|       |                           return;
 4166|       |                        }
 4167|       |                     }
 4168|       |
 4169|       |                     if (skip_ws<Opts>(ctx, it, end)) {
 4170|       |                        return;
 4171|       |                     }
 4172|       |                     if (match_invalid_end<'"', Opts>(ctx, it, end)) {
 4173|       |                        return;
 4174|       |                     }
 4175|       |
 4176|       |                     auto* key_start = it;
 4177|       |                     skip_string_view(ctx, it, end);
 4178|       |                     if (bool(ctx.error)) [[unlikely]]
 4179|       |                        return;
 4180|       |                     if (validate_utf8_span<Opts>(ctx, key_start, it)) [[unlikely]]
 4181|       |                        return;
 4182|       |                     const sv key = {key_start, size_t(it - key_start)};
 4183|       |
 4184|       |                     if (match_invalid_end<'"', Opts>(ctx, it, end)) {
 4185|       |                        return;
 4186|       |                     }
 4187|       |
 4188|       |                     if constexpr (deduction_key_count > 0) {
 4189|       |                        // We first check if a tag is defined and see if the key matches the tag
 4190|       |                        if constexpr (not tag_v<T>.empty()) {
 4191|       |                           if (key == tag_v<T>) {
 4192|       |                              if (parse_ws_colon<Opts>(ctx, it, end)) {
 4193|       |                                 return;
 4194|       |                              }
 4195|       |
 4196|       |                              using id_type = std::decay_t<decltype(ids_v<T>[0])>;
 4197|       |
 4198|       |                              std::conditional_t<std::integral<id_type>, id_type, sv> type_id{};
 4199|       |                              if constexpr (std::integral<id_type>) {
 4200|       |                                 from<JSON, id_type>::template op<ws_handled<Opts>()>(type_id, ctx, it, end);
 4201|       |                              }
 4202|       |                              else {
 4203|       |                                 // The id is turned into an index below and never leaves this
 4204|       |                                 // reader, so the view of the window it borrows cannot outlive it.
 4205|       |                                 parse_transient_string_view<ws_handled<Opts>()>(type_id, ctx, it, end);
 4206|       |                              }
 4207|       |                              if (bool(ctx.error)) [[unlikely]]
 4208|       |                                 return;
 4209|       |                              if (skip_ws<Opts>(ctx, it, end)) {
 4210|       |                                 return;
 4211|       |                              }
 4212|       |                              if (!(*it == ',' || *it == '}')) [[unlikely]] {
 4213|       |                                 ctx.error = error_code::syntax_error;
 4214|       |                                 return;
 4215|       |                              }
 4216|       |
 4217|       |                              size_t type_index;
 4218|       |                              if constexpr (std::integral<id_type>) {
 4219|       |                                 type_index = variant_id_to_index<T>::op(type_id);
 4220|       |                              }
 4221|       |                              else {
 4222|       |                                 type_index = variant_id_to_index<T>::op(
 4223|       |                                    type_id.data(), type_id.data() + type_id.size(), type_id.size());
 4224|       |                              }
 4225|       |                              if (type_index < ids_v<T>.size()) [[likely]] {
 4226|       |                                 // Check if the deduced types include the tag-specified type
 4227|       |                                 // If not, the tag doesn't match the fields
 4228|       |                                 // We're already inside if constexpr (deduction_registry.size()), so we know deduction
 4229|       |                                 // is happening. At this point, possible_types has been narrowed by field deduction.
 4230|       |                                 // Check if the tag-specified type is still possible
 4231|       |                                 const bool type_is_possible = possible_types[type_index];
 4232|       |                                 if (!type_is_possible) {
 4233|       |                                    // Tag specifies a type that doesn't match the fields seen so far
 4234|       |                                    ctx.error = error_code::no_matching_variant_type;
 4235|       |                                    return;
 4236|       |                                 }
 4237|       |
 4238|       |                                 if (!position_after_tag()) return;
 4239|       |                                 tag_specified_index = type_index; // Store the tag-specified type
 4240|       |                                 if (value.index() != type_index) emplace_runtime_variant(value, type_index);
 4241|       |                                 std::visit(
 4242|       |                                    [&](auto&& v) {
 4243|       |                                       using V = std::decay_t<decltype(v)>;
 4244|       |                                       constexpr bool is_object =
 4245|       |                                          (glaze_object_t<V> || reflectable<V>) && not custom_read<V>;
 4246|       |                                       if constexpr (variant_unit_alternative<V>) {
 4247|       |                                          // A unit alternative carries no data; its object holds only the
 4248|       |                                          // discriminator. Consume that body through an empty reflected object so
 4249|       |                                          // unknown-key policy and terminator handling match every other alternative.
 4250|       |                                          detail::variant_unit_body unit_body{};
 4251|       |                                          from<JSON, detail::variant_unit_body>::template op<opening_handled<Opts>(),
 4252|       |                                                                                             tag_literal>(unit_body,
 4253|       |                                                                                                          ctx, it, end);
 4254|       |                                       }
 4255|       |                                       else if constexpr (is_object) {
 4256|       |                                          if constexpr (contains_tag<V, tag_literal>()) {
 4257|       |                                             // tag is a struct field, must re-parse
 4258|       |                                             if (!start.rewind(ctx, it, end)) return;
 4259|       |                                          }
 4260|       |                                          from<JSON, V>::template op<opening_handled<Opts>(), tag_literal>(v, ctx, it,
 4261|       |                                                                                                           end);
 4262|       |                                       }
 4263|       |                                       else if constexpr (is_memory_object<V>) {
 4264|       |                                          if (!v) {
 4265|       |                                             if constexpr (is_specialization_v<V, std::optional>) {
 4266|       |                                                if constexpr (requires { v.emplace(); }) {
 4267|       |                                                   v.emplace();
 4268|       |                                                }
 4269|       |                                                else {
 4270|       |                                                   v = typename V::value_type{};
 4271|       |                                                }
 4272|       |                                             }
 4273|       |                                             else if constexpr (is_specialization_v<V, std::unique_ptr>)
 4274|       |                                                v = std::make_unique<typename V::element_type>();
 4275|       |                                             else if constexpr (is_specialization_v<V, std::shared_ptr>)
 4276|       |                                                v = std::make_shared<typename V::element_type>();
 4277|       |                                             else if constexpr (constructible<V>) {
 4278|       |                                                v = meta_construct_v<V>();
 4279|       |                                             }
 4280|       |                                             else if constexpr (std::is_pointer_v<V> &&
 4281|       |                                                                can_allocate_raw_pointer<Opts,
 4282|       |                                                                                         std::decay_t<decltype(ctx)>>) {
 4283|       |                                                if (!try_allocate_raw_pointer<Opts>(v, ctx)) {
 4284|       |                                                   return;
 4285|       |                                                }
 4286|       |                                             }
 4287|       |                                             else {
 4288|       |                                                ctx.error = error_code::invalid_nullable_read;
 4289|       |                                                return;
 4290|       |                                                // Cannot read into unset nullable that is not std::optional,
 4291|       |                                                // std::unique_ptr, or std::shared_ptr
 4292|       |                                             }
 4293|       |                                          }
 4294|       |                                          if constexpr (contains_tag<memory_type<V>, tag_literal>()) {
 4295|       |                                             // tag is a struct field, must re-parse
 4296|       |                                             if (!start.rewind(ctx, it, end)) return;
 4297|       |                                          }
 4298|       |                                          from<JSON, memory_type<V>>::template op<opening_handled<Opts>(), tag_literal>(
 4299|       |                                             *v, ctx, it, end);
 4300|       |                                       }
 4301|       |                                       else if constexpr (custom_read<V>) {
 4302|       |                                          // Custom handlers parse the remaining body themselves and do not
 4303|       |                                          // accept the tag template parameter; the tag was already consumed.
 4304|       |                                          // This only works when the tag was the first key. If it came later,
 4305|       |                                          // we were reset to the object start and the custom handler would
 4306|       |                                          // absorb the tag, so error rather than corrupt the value.
 4307|       |                                          if (!first_key) {
 4308|       |                                             ctx.error = error_code::feature_not_supported;
 4309|       |                                             ctx.custom_error_message =
 4310|       |                                                "the tag must be the first key for a custom variant alternative";
 4311|       |                                             return;
 4312|       |                                          }
 4313|       |                                          from<JSON, V>::template op<opening_handled<Opts>()>(v, ctx, it, end);
 4314|       |                                       }
 4315|       |                                    },
 4316|       |                                    value);
 4317|       |
 4318|       |                                 return; // we've decoded our target type
 4319|       |                              }
 4320|       |                              else [[unlikely]] {
 4321|       |                                 // Check if we have a default type (ids array shorter than variant)
 4322|       |                                 constexpr auto ids_size = ids_v<T>.size();
 4323|       |                                 constexpr auto variant_size = std::variant_size_v<T>;
 4324|       |                                 if constexpr (ids_size < variant_size) {
 4325|       |                                    // Use the first unlabeled type as the default
 4326|       |                                    const auto default_type_index = ids_size;
 4327|       |
 4328|       |                                    if (!position_after_tag()) return;
 4329|       |                                    tag_specified_index = default_type_index; // Store the default type index
 4330|       |                                    if (value.index() != default_type_index)
 4331|       |                                       emplace_runtime_variant(value, default_type_index);
 4332|       |                                    std::visit(
 4333|       |                                       [&](auto&& v) {
 4334|       |                                          using V = std::decay_t<decltype(v)>;
 4335|       |                                          constexpr bool is_object =
 4336|       |                                             (glaze_object_t<V> || reflectable<V>) && not custom_read<V>;
 4337|       |                                          if constexpr (variant_unit_alternative<V>) {
 4338|       |                                             // A unit alternative carries no data; its object holds only the
 4339|       |                                             // discriminator. Consume that body through an empty reflected object so
 4340|       |                                             // unknown-key policy and terminator handling match every other
 4341|       |                                             // alternative.
 4342|       |                                             detail::variant_unit_body unit_body{};
 4343|       |                                             from<JSON, detail::variant_unit_body>::template op<opening_handled<Opts>(),
 4344|       |                                                                                                tag_literal>(
 4345|       |                                                unit_body, ctx, it, end);
 4346|       |                                          }
 4347|       |                                          else if constexpr (is_object) {
 4348|       |                                             if constexpr (contains_tag<V, tag_literal>()) {
 4349|       |                                                // tag is a struct field, must re-parse
 4350|       |                                                if (!start.rewind(ctx, it, end)) return;
 4351|       |                                             }
 4352|       |                                             from<JSON, V>::template op<opening_handled<Opts>()>(v, ctx, it, end);
 4353|       |                                          }
 4354|       |                                          else if constexpr (is_memory_object<V>) {
 4355|       |                                             if (!v) {
 4356|       |                                                if constexpr (is_specialization_v<V, std::optional>) {
 4357|       |                                                   if constexpr (requires { v.emplace(); }) {
 4358|       |                                                      v.emplace();
 4359|       |                                                   }
 4360|       |                                                   else {
 4361|       |                                                      v = typename V::value_type{};
 4362|       |                                                   }
 4363|       |                                                }
 4364|       |                                                else if constexpr (is_specialization_v<V, std::unique_ptr>)
 4365|       |                                                   v = std::make_unique<typename V::element_type>();
 4366|       |                                                else if constexpr (is_specialization_v<V, std::shared_ptr>)
 4367|       |                                                   v = std::make_shared<typename V::element_type>();
 4368|       |                                                else if constexpr (constructible<V>) {
 4369|       |                                                   v = meta_construct_v<V>();
 4370|       |                                                }
 4371|       |                                                else if constexpr (std::is_pointer_v<V> &&
 4372|       |                                                                   can_allocate_raw_pointer<
 4373|       |                                                                      Opts, std::decay_t<decltype(ctx)>>) {
 4374|       |                                                   if (!try_allocate_raw_pointer<Opts>(v, ctx)) {
 4375|       |                                                      return;
 4376|       |                                                   }
 4377|       |                                                }
 4378|       |                                                else {
 4379|       |                                                   ctx.error = error_code::invalid_nullable_read;
 4380|       |                                                   return;
 4381|       |                                                }
 4382|       |                                             }
 4383|       |                                             if constexpr (contains_tag<memory_type<V>, tag_literal>()) {
 4384|       |                                                // tag is a struct field, must re-parse
 4385|       |                                                if (!start.rewind(ctx, it, end)) return;
 4386|       |                                             }
 4387|       |                                             from<JSON, memory_type<V>>::template op<opening_handled<Opts>()>(*v, ctx,
 4388|       |                                                                                                              it, end);
 4389|       |                                          }
 4390|       |                                          else if constexpr (custom_read<V>) {
 4391|       |                                             // Custom handlers parse the remaining body themselves; this only
 4392|       |                                             // works when the tag was the first key (see above). If it came
 4393|       |                                             // later we were reset to the object start, so error rather than
 4394|       |                                             // let the custom handler absorb the tag.
 4395|       |                                             if (!first_key) {
 4396|       |                                                ctx.error = error_code::feature_not_supported;
 4397|       |                                                ctx.custom_error_message =
 4398|       |                                                   "the tag must be the first key for a custom variant alternative";
 4399|       |                                                return;
 4400|       |                                             }
 4401|       |                                             from<JSON, V>::template op<opening_handled<Opts>()>(v, ctx, it, end);
 4402|       |                                          }
 4403|       |                                       },
 4404|       |                                       value);
 4405|       |
 4406|       |                                    return;
 4407|       |                                 }
 4408|       |                                 else {
 4409|       |                                    ctx.error = error_code::no_matching_variant_type;
 4410|       |                                    ctx.custom_error_message = variant_ids_string_v<T>;
 4411|       |                                    return;
 4412|       |                                 }
 4413|       |                              }
 4414|       |                           }
 4415|       |                        }
 4416|       |
 4417|       |                        // Inline decode_hash lookup for variant deduction
 4418|       |                        using deduction_keys_t = keys_wrapper<variant_deduction_keys<T>>;
 4419|       |                        constexpr auto& DeductionHashInfo = hash_info<deduction_keys_t>;
 4420|       |                        const auto deduction_index =
 4421|       |                           decode_hash_with_size<JSON, deduction_keys_t, DeductionHashInfo, DeductionHashInfo.type>::op(
 4422|       |                              key.data(), key.data() + key.size(), key.size());
 4423|       |                        if (deduction_index < deduction_key_count && variant_deduction_keys<T>[deduction_index] == key)
 4424|       |                           [[likely]] {
 4425|       |                           possible_types &= deduction_bits[deduction_index];
 4426|       |                        }
 4427|       |                        else if constexpr (Opts.error_on_unknown_keys) {
 4428|       |                           ctx.error = error_code::unknown_key;
 4429|       |                           return;
 4430|       |                        }
 4431|       |                     }
 4432|       |                     else if constexpr (not tag_v<T>.empty()) {
 4433|       |                        // empty object case for variant, if there are no normal elements
 4434|       |                        if (key == tag_v<T>) {
 4435|       |                           if (parse_ws_colon<Opts>(ctx, it, end)) {
 4436|       |                              return;
 4437|       |                           }
 4438|       |
 4439|       |                           // The id is turned into an index below and never leaves this reader,
 4440|       |                           // so the view of the window it borrows cannot outlive that window.
 4441|       |                           std::string_view type_id{};
 4442|       |                           parse_transient_string_view<ws_handled<Opts>()>(type_id, ctx, it, end);
 4443|       |                           if (bool(ctx.error)) [[unlikely]]
 4444|       |                              return;
 4445|       |                           if (skip_ws<Opts>(ctx, it, end)) {
 4446|       |                              return;
 4447|       |                           }
 4448|       |
 4449|       |                           const auto type_index = variant_id_to_index<T>::op(
 4450|       |                              type_id.data(), type_id.data() + type_id.size(), type_id.size());
 4451|       |                           if (type_index < ids_v<T>.size()) [[likely]] {
 4452|       |                              if (!position_after_tag()) return;
 4453|       |                              tag_specified_index = type_index; // Store the tag-specified type
 4454|       |                              if (value.index() != type_index) emplace_runtime_variant(value, type_index);
 4455|       |                           }
 4456|       |                           else {
 4457|       |                              // Check if we have a default type (ids array shorter than variant)
 4458|       |                              constexpr auto ids_size = ids_v<T>.size();
 4459|       |                              constexpr auto variant_size = std::variant_size_v<T>;
 4460|       |                              if constexpr (ids_size < variant_size) {
 4461|       |                                 // Use the first unlabeled type as the default
 4462|       |                                 if (!position_after_tag()) return;
 4463|       |                                 const auto default_index = ids_size;
 4464|       |                                 tag_specified_index = default_index; // Store the default type index
 4465|       |                                 if (value.index() != default_index) emplace_runtime_variant(value, default_index);
 4466|       |                              }
 4467|       |                              else {
 4468|       |                                 ctx.error = error_code::no_matching_variant_type;
 4469|       |                                 ctx.custom_error_message = variant_ids_string_v<T>;
 4470|       |                                 return;
 4471|       |                              }
 4472|       |                           }
 4473|       |                           // Parse the type (handles tag skipping and unknown keys)
 4474|       |                           std::visit(
 4475|       |                              [&](auto&& v) {
 4476|       |                                 using V = std::decay_t<decltype(v)>;
 4477|       |                                 if constexpr (custom_read<V>) {
 4478|       |                                    // Custom handlers parse the remaining object body themselves and do not
 4479|       |                                    // accept the tag template parameter that reflected objects use to skip an
 4480|       |                                    // interior tag key. That only works when the tag is the first key (it was
 4481|       |                                    // just consumed). If the tag came after other keys, position_after_tag()
 4482|       |                                    // reset us to the object start and the custom handler would absorb the tag
 4483|       |                                    // into its value, so error here rather than corrupt the result.
 4484|       |                                    if (!first_key) {
 4485|       |                                       ctx.error = error_code::feature_not_supported;
 4486|       |                                       ctx.custom_error_message =
 4487|       |                                          "the tag must be the first key for a custom variant alternative";
 4488|       |                                       return;
 4489|       |                                    }
 4490|       |                                    from<JSON, V>::template op<opening_handled<Opts>()>(v, ctx, it, end);
 4491|       |                                 }
 4492|       |                                 else {
 4493|       |                                    if constexpr (contains_tag<V, tag_literal>()) {
 4494|       |                                       // tag is a struct field, must re-parse
 4495|       |                                       if (!start.rewind(ctx, it, end)) return;
 4496|       |                                    }
 4497|       |                                    from<JSON, V>::template op<opening_handled<Opts>(), tag_literal>(v, ctx, it, end);
 4498|       |                                 }
 4499|       |                              },
 4500|       |                              value);
 4501|       |                           return;
 4502|       |                        }
 4503|       |                        else if constexpr (Opts.error_on_unknown_keys) {
 4504|       |                           ctx.error = error_code::unknown_key;
 4505|       |                           return;
 4506|       |                        }
 4507|       |                        else {
 4508|       |                           // Skip unknown key's value (non-tag key in empty variant)
 4509|       |                           if (parse_ws_colon<Opts>(ctx, it, end)) {
 4510|       |                              return;
 4511|       |                           }
 4512|       |                           skip_value<JSON>::op<Opts>(ctx, it, end);
 4513|       |                           if (bool(ctx.error)) [[unlikely]]
 4514|       |                              return;
 4515|       |                           resync_window_end(ctx, end); // a streaming skip refills
 4516|       |                           if (skip_ws<Opts>(ctx, it, end)) {
 4517|       |                              return;
 4518|       |                           }
 4519|       |                           continue; // Continue loop to find the tag
 4520|       |                        }
 4521|       |                     }
 4522|       |                     else if constexpr (Opts.error_on_unknown_keys) {
 4523|       |                        ctx.error = error_code::unknown_key;
 4524|       |                        return;
 4525|       |                     }
 4526|       |
 4527|       |                     auto matching_types = possible_types.popcount();
 4528|       |                     if (matching_types == 0) {
 4529|       |                        ctx.error = error_code::no_matching_variant_type;
 4530|       |                        return;
 4531|       |                     }
 4532|       |                     // Only short-circuit for variants without tags
 4533|       |                     else if constexpr (tag_v<T>.empty()) {
 4534|       |                        if (matching_types == 1) {
 4535|       |                           if (!start.rewind(ctx, it, end)) return;
 4536|       |                           const auto type_index = possible_types.countr_zero();
 4537|       |
 4538|       |                           if (value.index() != static_cast<size_t>(type_index))
 4539|       |                              emplace_runtime_variant(value, type_index);
 4540|       |                           std::visit(
 4541|       |                              [&](auto&& v) {
 4542|       |                                 using V = std::decay_t<decltype(v)>;
 4543|       |                                 constexpr bool is_object = (glaze_object_t<V> || reflectable<V>) && not custom_read<V>;
 4544|       |                                 if constexpr (variant_unit_alternative<V>) {
 4545|       |                                    // A unit alternative carries no data; its object holds only the discriminator.
 4546|       |                                    // Consume that body through an empty reflected object so unknown-key policy and
 4547|       |                                    // terminator handling match every other alternative.
 4548|       |                                    detail::variant_unit_body unit_body{};
 4549|       |                                    from<JSON, detail::variant_unit_body>::template op<opening_handled<Opts>(),
 4550|       |                                                                                       tag_literal>(unit_body, ctx, it,
 4551|       |                                                                                                    end);
 4552|       |                                 }
 4553|       |                                 else if constexpr (is_object) {
 4554|       |                                    from<JSON, V>::template op<opening_handled<Opts>(), tag_literal>(v, ctx, it, end);
 4555|       |                                 }
 4556|       |                                 else if constexpr (is_memory_object<V>) {
 4557|       |                                    if (!v) {
 4558|       |                                       if constexpr (is_specialization_v<V, std::optional>) {
 4559|       |                                          if constexpr (requires { v.emplace(); }) {
 4560|       |                                             v.emplace();
 4561|       |                                          }
 4562|       |                                          else {
 4563|       |                                             v = typename V::value_type{};
 4564|       |                                          }
 4565|       |                                       }
 4566|       |                                       else if constexpr (is_specialization_v<V, std::unique_ptr>)
 4567|       |                                          v = std::make_unique<typename V::element_type>();
 4568|       |                                       else if constexpr (is_specialization_v<V, std::shared_ptr>)
 4569|       |                                          v = std::make_shared<typename V::element_type>();
 4570|       |                                       else if constexpr (constructible<V>) {
 4571|       |                                          v = meta_construct_v<V>();
 4572|       |                                       }
 4573|       |                                       else if constexpr (std::is_pointer_v<V> &&
 4574|       |                                                          can_allocate_raw_pointer<Opts, std::decay_t<decltype(ctx)>>) {
 4575|       |                                          if (!try_allocate_raw_pointer<Opts>(v, ctx)) {
 4576|       |                                             return;
 4577|       |                                          }
 4578|       |                                       }
 4579|       |                                       else {
 4580|       |                                          ctx.error = error_code::invalid_nullable_read;
 4581|       |                                          return;
 4582|       |                                          // Cannot read into unset nullable that is not std::optional,
 4583|       |                                          // std::unique_ptr, or std::shared_ptr
 4584|       |                                       }
 4585|       |                                    }
 4586|       |                                    from<JSON, memory_type<V>>::template op<opening_handled<Opts>(), tag_literal>(
 4587|       |                                       *v, ctx, it, end);
 4588|       |                                 }
 4589|       |                                 else if constexpr (custom_read<V>) {
 4590|       |                                    // Custom handlers parse the remaining body themselves.
 4591|       |                                    from<JSON, V>::template op<opening_handled<Opts>()>(v, ctx, it, end);
 4592|       |                                 }
 4593|       |                              },
 4594|       |                              value);
 4595|       |
 4596|       |                           return; // we've decoded our target type
 4597|       |                        }
 4598|       |                     }
 4599|       |                     // For tagged variants, continue processing to validate tags
 4600|       |                     if (parse_ws_colon<Opts>(ctx, it, end)) {
 4601|       |                        return;
 4602|       |                     }
 4603|       |
 4604|       |                     skip_value<JSON>::op<Opts>(ctx, it, end);
 4605|       |                     if (bool(ctx.error)) [[unlikely]]
 4606|       |                        return;
 4607|       |                     resync_window_end(ctx, end); // a streaming skip refills
 4608|       |                     if (skip_ws<Opts>(ctx, it, end)) {
 4609|       |                        return;
 4610|       |                     }
 4611|       |                  }
 4612|       |                  // Only apply ambiguous variant resolution if we have multiple object types
 4613|       |                  if constexpr ((type_counts::n_object + type_counts::n_nullable_object) > 1) {
 4614|       |                     // After parsing all keys, check if we have multiple matching types
 4615|       |                     // If so, choose the one with the fewest fields
 4616|       |                     auto final_matching = possible_types.popcount();
 4617|       |                     if (final_matching == 0) {
 4618|       |                        ctx.error = error_code::no_matching_variant_type;
 4619|       |                     }
 4620|       |                     else if (final_matching == 1) {
 4621|       |                        // Single type remains after field deduction
 4622|       |                        const auto type_index = possible_types.countr_zero();
 4623|       |
 4624|       |                        // Validate against tag if one was specified
 4625|       |                        if (tag_specified_index.has_value() &&
 4626|       |                            tag_specified_index.value() != static_cast<size_t>(type_index)) {
 4627|       |                           ctx.error = error_code::no_matching_variant_type;
 4628|       |                           return;
 4629|       |                        }
 4630|       |
 4631|       |                        if (!start.rewind(ctx, it, end)) return;
 4632|       |                        if (value.index() != static_cast<size_t>(type_index))
 4633|       |                           emplace_runtime_variant(value, type_index);
 4634|       |                        std::visit(
 4635|       |                           [&](auto&& v) {
 4636|       |                              using V = std::decay_t<decltype(v)>;
 4637|       |                              constexpr bool is_object = (glaze_object_t<V> || reflectable<V>) && not custom_read<V>;
 4638|       |                              if constexpr (variant_unit_alternative<V>) {
 4639|       |                                 // A unit alternative carries no data; its object holds only the discriminator.
 4640|       |                                 // Consume that body through an empty reflected object so unknown-key policy and
 4641|       |                                 // terminator handling match every other alternative.
 4642|       |                                 detail::variant_unit_body unit_body{};
 4643|       |                                 from<JSON, detail::variant_unit_body>::template op<opening_handled<Opts>(),
 4644|       |                                                                                    tag_literal>(unit_body, ctx, it,
 4645|       |                                                                                                 end);
 4646|       |                              }
 4647|       |                              else if constexpr (is_object) {
 4648|       |                                 from<JSON, V>::template op<opening_handled<Opts>(), tag_literal>(v, ctx, it, end);
 4649|       |                              }
 4650|       |                              else if constexpr (is_memory_object<V>) {
 4651|       |                                 if (!v) {
 4652|       |                                    if constexpr (is_specialization_v<V, std::optional>) {
 4653|       |                                       if constexpr (requires { v.emplace(); }) {
 4654|       |                                          v.emplace();
 4655|       |                                       }
 4656|       |                                       else {
 4657|       |                                          v = typename V::value_type{};
 4658|       |                                       }
 4659|       |                                    }
 4660|       |                                    else if constexpr (is_specialization_v<V, std::unique_ptr>)
 4661|       |                                       v = std::make_unique<typename V::element_type>();
 4662|       |                                    else if constexpr (is_specialization_v<V, std::shared_ptr>)
 4663|       |                                       v = std::make_shared<typename V::element_type>();
 4664|       |                                    else if constexpr (constructible<V>) {
 4665|       |                                       v = meta_construct_v<V>();
 4666|       |                                    }
 4667|       |                                    else if constexpr (std::is_pointer_v<V> &&
 4668|       |                                                       can_allocate_raw_pointer<Opts, std::decay_t<decltype(ctx)>>) {
 4669|       |                                       if (!try_allocate_raw_pointer<Opts>(v, ctx)) {
 4670|       |                                          return;
 4671|       |                                       }
 4672|       |                                    }
 4673|       |                                    else {
 4674|       |                                       ctx.error = error_code::invalid_nullable_read;
 4675|       |                                       return;
 4676|       |                                    }
 4677|       |                                 }
 4678|       |                                 from<JSON, memory_type<V>>::template op<opening_handled<Opts>(), tag_literal>(*v, ctx,
 4679|       |                                                                                                               it, end);
 4680|       |                              }
 4681|       |                              else if constexpr (custom_read<V>) {
 4682|       |                                 // Custom handlers parse the remaining body themselves.
 4683|       |                                 from<JSON, V>::template op<opening_handled<Opts>()>(v, ctx, it, end);
 4684|       |                              }
 4685|       |                           },
 4686|       |                           value);
 4687|       |                     }
 4688|       |                     else if (final_matching > 1) {
 4689|       |                        constexpr auto N = std::variant_size_v<T>;
 4690|       |
 4691|       |                        // Compile-time array of field counts for each variant type
 4692|       |                        constexpr auto field_counts = []<size_t... I>(std::index_sequence<I...>) {
 4693|       |                           return std::array<size_t, N> {
 4694|       |                              ([]<size_t J = I>() -> size_t {
 4695|       |                                 using V = std::decay_t<std::variant_alternative_t<J, T>>;
 4696|       |                                 if constexpr (glaze_object_t<V> || reflectable<V>) {
 4697|       |                                    return reflect<V>::size;
 4698|       |                                 }
 4699|       |                                 else if constexpr (is_memory_object<V>) {
 4700|       |                                    using X = memory_type<V>;
 4701|       |                                    if constexpr (glaze_object_t<X> || reflectable<X>) {
 4702|       |                                       return reflect<X>::size;
 4703|       |                                    }
 4704|       |                                    else {
 4705|       |                                       return (std::numeric_limits<size_t>::max)();
 4706|       |                                    }
 4707|       |                                 }
 4708|       |                                 else {
 4709|       |                                    return (std::numeric_limits<size_t>::max)();
 4710|       |                                 }
 4711|       |                              }.template operator()<I>())...
 4712|       |                           };
 4713|       |                        }(std::make_index_sequence<N>{});
 4714|       |
 4715|       |                        // Find the type with minimum field count among the possible types
 4716|       |                        size_t min_fields = (std::numeric_limits<size_t>::max)();
 4717|       |                        size_t chosen_index = N; // Invalid index initially
 4718|       |
 4719|       |                        for (size_t i = 0; i < N; ++i) {
 4720|       |                           if (possible_types[i] && field_counts[i] < min_fields) {
 4721|       |                              min_fields = field_counts[i];
 4722|       |                              chosen_index = i;
 4723|       |                           }
 4724|       |                        }
 4725|       |
 4726|       |                        if (chosen_index < N) {
 4727|       |                           // Validate against tag if one was specified
 4728|       |                           if (tag_specified_index.has_value() && tag_specified_index.value() != chosen_index) {
 4729|       |                              ctx.error = error_code::no_matching_variant_type;
 4730|       |                              return;
 4731|       |                           }
 4732|       |
 4733|       |                           if (!start.rewind(ctx, it, end)) return;
 4734|       |                           if (value.index() != chosen_index) emplace_runtime_variant(value, chosen_index);
 4735|       |                           std::visit(
 4736|       |                              [&](auto&& v) {
 4737|       |                                 using V = std::decay_t<decltype(v)>;
 4738|       |                                 constexpr bool is_object = (glaze_object_t<V> || reflectable<V>) && not custom_read<V>;
 4739|       |                                 if constexpr (variant_unit_alternative<V>) {
 4740|       |                                    // A unit alternative carries no data; its object holds only the discriminator.
 4741|       |                                    // Consume that body through an empty reflected object so unknown-key policy and
 4742|       |                                    // terminator handling match every other alternative.
 4743|       |                                    detail::variant_unit_body unit_body{};
 4744|       |                                    from<JSON, detail::variant_unit_body>::template op<opening_handled<Opts>(),
 4745|       |                                                                                       tag_literal>(unit_body, ctx, it,
 4746|       |                                                                                                    end);
 4747|       |                                 }
 4748|       |                                 else if constexpr (is_object) {
 4749|       |                                    from<JSON, V>::template op<opening_handled<Opts>(), tag_literal>(v, ctx, it, end);
 4750|       |                                 }
 4751|       |                                 else if constexpr (is_memory_object<V>) {
 4752|       |                                    if (!v) {
 4753|       |                                       if constexpr (is_specialization_v<V, std::optional>) {
 4754|       |                                          if constexpr (requires { v.emplace(); }) {
 4755|       |                                             v.emplace();
 4756|       |                                          }
 4757|       |                                          else {
 4758|       |                                             v = typename V::value_type{};
 4759|       |                                          }
 4760|       |                                       }
 4761|       |                                       else if constexpr (is_specialization_v<V, std::unique_ptr>)
 4762|       |                                          v = std::make_unique<typename V::element_type>();
 4763|       |                                       else if constexpr (is_specialization_v<V, std::shared_ptr>)
 4764|       |                                          v = std::make_shared<typename V::element_type>();
 4765|       |                                       else if constexpr (constructible<V>) {
 4766|       |                                          v = meta_construct_v<V>();
 4767|       |                                       }
 4768|       |                                       else if constexpr (std::is_pointer_v<V> &&
 4769|       |                                                          can_allocate_raw_pointer<Opts, std::decay_t<decltype(ctx)>>) {
 4770|       |                                          if (!try_allocate_raw_pointer<Opts>(v, ctx)) {
 4771|       |                                             return;
 4772|       |                                          }
 4773|       |                                       }
 4774|       |                                       else {
 4775|       |                                          ctx.error = error_code::invalid_nullable_read;
 4776|       |                                          return;
 4777|       |                                       }
 4778|       |                                    }
 4779|       |                                    from<JSON, memory_type<V>>::template op<opening_handled<Opts>(), tag_literal>(
 4780|       |                                       *v, ctx, it, end);
 4781|       |                                 }
 4782|       |                                 else if constexpr (custom_read<V>) {
 4783|       |                                    // Custom handlers parse the remaining body themselves.
 4784|       |                                    from<JSON, V>::template op<opening_handled<Opts>()>(v, ctx, it, end);
 4785|       |                                 }
 4786|       |                              },
 4787|       |                              value);
 4788|       |                        }
 4789|       |                        else {
 4790|       |                           ctx.error = error_code::no_matching_variant_type;
 4791|       |                        }
 4792|       |                     }
 4793|       |                  }
 4794|       |                  else {
 4795|       |                     // For variants with 0 or 1 object types, use the original error handling
 4796|       |                     ctx.error = error_code::no_matching_variant_type;
 4797|       |                  }
 4798|       |               }
 4799|      0|               break;
 4800|  41.4k|            }
 4801|  16.5k|            case '[':
  ------------------
  |  Branch (4801:13): [True: 16.5k, False: 41.4k]
  ------------------
 4802|       |               // As with '{' above: the array reader each alternative goes through counts the level.
 4803|  16.5k|               process_variant_alternatives<T, is_variant_array>::template op<Opts>(value, ctx, it, end);
 4804|  16.5k|               break;
 4805|      0|            case '"': {
  ------------------
  |  Branch (4805:13): [True: 0, False: 58.0k]
  ------------------
 4806|      0|               process_variant_alternatives<T, is_variant_str>::template op<Opts>(value, ctx, it, end);
 4807|      0|               break;
 4808|  41.4k|            }
 4809|      0|            case 't':
  ------------------
  |  Branch (4809:13): [True: 0, False: 58.0k]
  ------------------
 4810|      0|            case 'f': {
  ------------------
  |  Branch (4810:13): [True: 0, False: 58.0k]
  ------------------
 4811|      0|               process_variant_alternatives<T, is_variant_bool>::template op<Opts>(value, ctx, it, end);
 4812|      0|               break;
 4813|      0|            }
 4814|      0|            case 'n':
  ------------------
  |  Branch (4814:13): [True: 0, False: 58.0k]
  ------------------
 4815|       |               if constexpr (variant_count_v<T, is_variant_null> == 0) {
 4816|       |                  ctx.error = error_code::no_matching_variant_type;
 4817|       |               }
 4818|      0|               else {
 4819|      0|                  constexpr auto first_idx = variant_first_index_v<T, is_variant_null>;
 4820|      0|                  using V = std::variant_alternative_t<first_idx, T>;
 4821|      0|                  if (!std::holds_alternative<V>(value)) value = V{};
  ------------------
  |  Branch (4821:23): [True: 0, False: 0]
  ------------------
 4822|      0|                  match<"null", Opts>(ctx, it, end);
 4823|      0|               }
 4824|      0|               break;
 4825|      0|            default: {
  ------------------
  |  Branch (4825:13): [True: 0, False: 58.0k]
  ------------------
 4826|       |               // Not bool, string, object, or array so must be number or null
 4827|      0|               process_variant_alternatives<T, is_variant_num>::template op<Opts>(value, ctx, it, end);
 4828|      0|            }
 4829|  58.0k|            }
 4830|       |         }
 4831|       |         else {
 4832|       |            // For non-auto-deducible variants, try each type until one succeeds
 4833|       |            constexpr auto N = std::variant_size_v<T>;
 4834|       |            bool parsed = false;
 4835|       |            bool exhausted = false; // speculation budget spent; see charge_speculation
 4836|       |
 4837|       |            for_each<N>([&]<size_t I>() {
 4838|       |               if (parsed || exhausted || variant_alternative_exhausted(ctx)) return;
 4839|       |
 4840|       |               auto copy_it = it;
 4841|       |               // A rejected alternative may have bailed out inside a container, which leaves its
 4842|       |               // nesting level counted (see enter_depth), so the depth rewinds with the iterator.
 4843|       |               const auto copy_depth = ctx.depth;
 4844|       |
 4845|       |               // Try parsing as this type
 4846|       |               if (value.index() != I) {
 4847|       |                  emplace_runtime_variant(value, I);
 4848|       |               }
 4849|       |
 4850|       |               std::visit([&](auto&& v) { parse<JSON>::op<Options>(v, ctx, it, end); }, value);
 4851|       |               if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) {
 4852|       |                  exhausted = true; // only rejected attempts are charged; see charge_speculation
 4853|       |               }
 4854|       |
 4855|       |               if (!bool(ctx.error)) {
 4856|       |                  parsed = true;
 4857|       |               }
 4858|       |               else if constexpr (not Options.null_terminated) {
 4859|       |                  // In non-null-terminated mode, if we hit end_reached after advancing the iterator,
 4860|       |                  // it means we successfully parsed the value but couldn't skip trailing whitespace
 4861|       |                  if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) {
 4862|       |                     // We advanced the iterator, so we did parse something -- unless what advanced it
 4863|       |                     // was an abandoned attempt, which is what a spent speculation budget means.
 4864|       |                     parsed = true;
 4865|       |                     ctx.error = error_code::none;
 4866|       |                  }
 4867|       |                  else {
 4868|       |                     // Reset for next attempt (unless this is the last type)
 4869|       |                     it = copy_it;
 4870|       |                     rewind_depth<Options>(ctx, copy_depth);
 4871|       |                     if constexpr (I + 1 < N) {
 4872|       |                        if (not exhausted && not variant_alternative_exhausted(ctx)) {
 4873|       |                           ctx.error = error_code::none; // Clear error for next attempt
 4874|       |                        }
 4875|       |                     }
 4876|       |                  }
 4877|       |               }
 4878|       |               else {
 4879|       |                  // Reset for next attempt (unless this is the last type)
 4880|       |                  it = copy_it;
 4881|       |                  rewind_depth<Options>(ctx, copy_depth);
 4882|       |                  if constexpr (I + 1 < N) {
 4883|       |                     if (not exhausted && not variant_alternative_exhausted(ctx)) {
 4884|       |                        ctx.error = error_code::none; // Clear error for next attempt
 4885|       |                     }
 4886|       |                  }
 4887|       |               }
 4888|       |            });
 4889|       |         }
 4890|  58.0k|      }
_ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj1EEERNS_17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES4_EEEETkNS_10is_contextERNS_7contextERPKcSD_EEvOT0_OT1_OT2_T3_:
   49|   507k|      {
   50|       |         if constexpr (const_value_v<T>) {
   51|       |            if constexpr (check_error_on_const_read(Opts)) {
   52|       |               ctx.error = error_code::attempt_const_read;
   53|       |            }
   54|       |            else {
   55|       |               // do not read anything into the const value
   56|       |               skip_value<JSON>::op<Opts>(std::forward<Ctx>(ctx), std::forward<It0>(it), end);
   57|       |            }
   58|       |         }
   59|   507k|         else {
   60|   507k|            using V = std::remove_cvref_t<T>;
   61|   507k|            from<JSON, V>::template op<Opts>(std::forward<T>(value), std::forward<Ctx>(ctx), std::forward<It0>(it),
   62|   507k|                                             end);
   63|   507k|         }
   64|   507k|      }
_ZN3glz4fromILj10ENS_17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES1_EEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj1EEETnNS_14string_literalEXtlNS9_ILm1EEEEERS5_TkNS_10is_contextERNS_7contextERPKcSF_EEvOT1_OT2_OT3_T4_:
 3044|   507k|      {
 3045|   507k|         static constexpr auto num_members = reflect<T>::size;
 3046|       |
 3047|   507k|         static constexpr auto Opts = opening_handled_off<ws_handled_off<Options>()>();
 3048|       |         if constexpr (!check_opening_handled(Options)) {
 3049|       |            if constexpr (!check_ws_handled(Options)) {
 3050|       |               if (skip_ws<Opts>(ctx, it, end)) {
 3051|       |                  return;
 3052|       |               }
 3053|       |            }
 3054|       |            if (match_invalid_end<'{', Opts>(ctx, it, end)) {
 3055|       |               return;
 3056|       |            }
 3057|       |            if constexpr (not Opts.null_terminated) {
 3058|       |               if (it == end) [[unlikely]] {
 3059|       |                  ctx.error = error_code::unexpected_end;
 3060|       |                  return;
 3061|       |               }
 3062|       |            }
 3063|       |            // one nesting level (see enter_depth): counted in both modes so the limit binds,
 3064|       |            // released at each syntactic close below
 3065|       |            if (enter_depth(ctx)) [[unlikely]] {
 3066|       |               return;
 3067|       |            }
 3068|       |         }
 3069|   507k|         const auto ws_start = it;
 3070|   507k|         if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (3070:14): [True: 0, False: 507k]
  ------------------
 3071|      0|            return;
 3072|      0|         }
 3073|   507k|         const size_t ws_size = size_t(it - ws_start);
 3074|       |
 3075|       |         if constexpr ((glaze_object_t<T> || reflectable<T>) && num_members == 0 && Opts.error_on_unknown_keys) {
 3076|       |            if constexpr (not tag.sv().empty()) {
 3077|       |               if (*it == '"') {
 3078|       |                  ++it;
 3079|       |                  if constexpr (not Opts.null_terminated) {
 3080|       |                     if (it == end) [[unlikely]] {
 3081|       |                        ctx.error = error_code::unexpected_end;
 3082|       |                        return;
 3083|       |                     }
 3084|       |                  }
 3085|       |
 3086|       |                  const auto start = it;
 3087|       |                  skip_string_view(ctx, it, end);
 3088|       |                  if (bool(ctx.error)) [[unlikely]]
 3089|       |                     return;
 3090|       |                  if (validate_utf8_span<Opts>(ctx, start, it)) [[unlikely]]
 3091|       |                     return;
 3092|       |                  const sv key{start, size_t(it - start)};
 3093|       |                  ++it;
 3094|       |                  if constexpr (not Opts.null_terminated) {
 3095|       |                     if (it == end) [[unlikely]] {
 3096|       |                        ctx.error = error_code::unexpected_end;
 3097|       |                        return;
 3098|       |                     }
 3099|       |                  }
 3100|       |
 3101|       |                  if (key == tag.sv()) {
 3102|       |                     if (parse_ws_colon<Opts>(ctx, it, end)) {
 3103|       |                        return;
 3104|       |                     }
 3105|       |
 3106|       |                     parse<JSON>::handle_unknown<Opts>(key, value, ctx, it, end);
 3107|       |                     if (bool(ctx.error)) [[unlikely]]
 3108|       |                        return;
 3109|       |
 3110|       |                     if (skip_ws<Opts>(ctx, it, end)) {
 3111|       |                        return;
 3112|       |                     }
 3113|       |                  }
 3114|       |                  else {
 3115|       |                     ctx.error = error_code::unknown_key;
 3116|       |                     return;
 3117|       |                  }
 3118|       |               }
 3119|       |            }
 3120|       |
 3121|       |            if (*it == '}') [[likely]] {
 3122|       |               --ctx.depth;
 3123|       |               if constexpr (glaze_object_t<T> || reflectable<T>) {
 3124|       |                  if constexpr (has_self_constraint_v<T> && !check_skip_self_constraint(Opts)) {
 3125|       |                     auto wrapper = self_constraint_v<T>(value);
 3126|       |                     from<JSON, decltype(wrapper)>::template op<ws_handled<Opts>()>(wrapper, ctx, it, end);
 3127|       |                     if (bool(ctx.error)) {
 3128|       |                        return;
 3129|       |                     }
 3130|       |                  }
 3131|       |               }
 3132|       |               ++it;
 3133|       |               if constexpr (not Opts.null_terminated) {
 3134|       |                  if (it == end) {
 3135|       |                     ctx.error = error_code::end_reached;
 3136|       |                     return;
 3137|       |                  }
 3138|       |               }
 3139|       |               if constexpr (Opts.partial_read) {
 3140|       |                  ctx.error = error_code::partial_read_complete;
 3141|       |               }
 3142|       |               return;
 3143|       |            }
 3144|       |            ctx.error = error_code::unknown_key;
 3145|       |            return;
 3146|       |         }
 3147|   507k|         else {
 3148|   507k|            decltype(auto) fields = [&]() -> decltype(auto) {
 3149|   507k|               if constexpr ((glaze_object_t<T> || reflectable<T>) &&
 3150|   507k|                             (Opts.error_on_missing_keys || Opts.partial_read)) {
 3151|   507k|                  return bit_array<num_members>{};
 3152|   507k|               }
 3153|   507k|               else {
 3154|   507k|                  return nullptr;
 3155|   507k|               }
 3156|   507k|            }();
 3157|       |
 3158|   507k|            size_t read_count{}; // for partial_read
 3159|       |
 3160|   507k|            bool first = true;
 3161|  2.00M|            while (true) {
  ------------------
  |  Branch (3161:20): [True: 1.96M, Folded]
  ------------------
 3162|       |               if constexpr ((glaze_object_t<T> || reflectable<T>) && Opts.partial_read) {
 3163|       |                  static constexpr bit_array<num_members> all_fields = [] {
 3164|       |                     bit_array<num_members> arr{};
 3165|       |                     for (size_t i = 0; i < num_members; ++i) {
 3166|       |                        arr[i] = true;
 3167|       |                     }
 3168|       |                     return arr;
 3169|       |                  }();
 3170|       |
 3171|       |                  if ((all_fields & fields) == all_fields) {
 3172|       |                     ctx.error = error_code::partial_read_complete;
 3173|       |                     --ctx.depth; // as above: an early success still closes this level
 3174|       |                     return;
 3175|       |                  }
 3176|       |               }
 3177|       |
 3178|       |               // Streaming refill point: at start of each iteration, ensure buffer has data
 3179|       |               if constexpr (has_streaming_state<decltype(ctx)>) {
 3180|       |                  if (ctx.stream.enabled()) {
 3181|       |                     const size_t consumed = static_cast<size_t>(it - ctx.stream.data());
 3182|       |                     const size_t remaining = ctx.stream.size() - consumed;
 3183|       |                     // Refill when less than half of buffer remains to ensure space for next key-value pair
 3184|       |                     if (remaining <= ctx.stream.size() / 2 || it >= end) {
 3185|       |                        const char* new_it;
 3186|       |                        const char* new_end;
 3187|       |                        ctx.stream.consume_and_refill(consumed, new_it, new_end);
 3188|       |                        it = new_it;
 3189|       |                        end = new_end;
 3190|       |                        if (it >= end && ctx.stream.at_eof()) {
 3191|       |                           ctx.error = error_code::unexpected_end;
 3192|       |                           return;
 3193|       |                        }
 3194|       |                     }
 3195|       |                  }
 3196|       |               }
 3197|       |
 3198|  1.96M|               if (*it == '}') {
  ------------------
  |  Branch (3198:20): [True: 464k, False: 1.50M]
  ------------------
 3199|   464k|                  --ctx.depth;
 3200|       |                  if constexpr ((glaze_object_t<T> || reflectable<T>) && Opts.error_on_missing_keys) {
 3201|       |                     constexpr auto req_fields = required_fields<T, Opts>();
 3202|       |                     if ((req_fields & fields) != req_fields) {
 3203|       |                        for (size_t i = 0; i < num_members; ++i) {
 3204|       |                           if (not fields[i] && req_fields[i]) {
 3205|       |                              ctx.custom_error_message = reflect<T>::keys[i];
 3206|       |                              // We just return the first missing key in order to avoid heap allocations
 3207|       |                              break;
 3208|       |                           }
 3209|       |                        }
 3210|       |
 3211|       |                        ctx.error = error_code::missing_key;
 3212|       |                        return;
 3213|       |                     }
 3214|       |                  }
 3215|       |                  if constexpr (glaze_object_t<T> || reflectable<T>) {
 3216|       |                     if constexpr (has_self_constraint_v<T> && !check_skip_self_constraint(Opts)) {
 3217|       |                        auto wrapper = self_constraint_v<T>(value);
 3218|       |                        from<JSON, decltype(wrapper)>::template op<ws_handled<Opts>()>(wrapper, ctx, it, end);
 3219|       |                        if (bool(ctx.error)) {
 3220|       |                           return;
 3221|       |                        }
 3222|       |                     }
 3223|       |                  }
 3224|   464k|                  ++it; // Increment after checking for missing keys so errors are within buffer bounds
 3225|   464k|                  if constexpr (not Opts.null_terminated) {
 3226|   464k|                     if (it == end) {
  ------------------
  |  Branch (3226:26): [True: 25.0k, False: 438k]
  ------------------
 3227|  25.0k|                        ctx.error = error_code::end_reached;
 3228|  25.0k|                        return;
 3229|  25.0k|                     }
 3230|   464k|                  }
 3231|   438k|                  return;
 3232|   464k|               }
 3233|  1.50M|               else if (first) {
  ------------------
  |  Branch (3233:25): [True: 507k, False: 993k]
  ------------------
 3234|   507k|                  first = false;
 3235|   507k|               }
 3236|   993k|               else {
 3237|   993k|                  if (match_invalid_end<',', Opts>(ctx, it, end)) {
  ------------------
  |  Branch (3237:23): [True: 0, False: 993k]
  ------------------
 3238|      0|                     return;
 3239|      0|                  }
 3240|   993k|                  if constexpr (not Opts.null_terminated) {
 3241|   993k|                     if (it == end) [[unlikely]] {
  ------------------
  |  Branch (3241:26): [True: 0, False: 993k]
  ------------------
 3242|      0|                        ctx.error = error_code::unexpected_end;
 3243|      0|                        return;
 3244|      0|                     }
 3245|   993k|                  }
 3246|       |
 3247|       |                  if constexpr ((not Opts.minified) && (num_members > 1 || not Opts.error_on_unknown_keys) &&
 3248|       |                                (!Opts.comments)) {
 3249|       |                     if (ws_size && ws_size < size_t(end - it)) {
 3250|       |                        skip_matching_ws(ws_start, it, ws_size);
 3251|       |                     }
 3252|       |                  }
 3253|       |
 3254|   993k|                  if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (3254:23): [True: 0, False: 993k]
  ------------------
 3255|      0|                     return;
 3256|      0|                  }
 3257|   993k|               }
 3258|       |
 3259|  1.50M|               constexpr auto reflection_type = glaze_object_t<T> || reflectable<T>;
  ------------------
  |  Branch (3259:49): [Folded, False: 0]
  |  Branch (3259:70): [Folded, False: 0]
  ------------------
 3260|       |
 3261|       |               if constexpr (reflection_type && (num_members == 0)) {
 3262|       |                  if constexpr (Opts.error_on_unknown_keys) {
 3263|       |                     static_assert(false_v<T>, "This should be unreachable");
 3264|       |                  }
 3265|       |                  else {
 3266|       |                     if (match_invalid_end<'"', Opts>(ctx, it, end)) {
 3267|       |                        return;
 3268|       |                     }
 3269|       |
 3270|       |                     // parsing to an empty object, but at this point the JSON presents keys
 3271|       |
 3272|       |                     // Unknown key handler does not unescape keys. Unknown escaped keys are
 3273|       |                     // handled by the user.
 3274|       |
 3275|       |                     const auto start = it;
 3276|       |                     skip_string_view(ctx, it, end);
 3277|       |                     if (bool(ctx.error)) [[unlikely]]
 3278|       |                        return;
 3279|       |                     if (validate_utf8_span<Opts>(ctx, start, it)) [[unlikely]]
 3280|       |                        return;
 3281|       |                     const sv key{start, size_t(it - start)};
 3282|       |                     ++it;
 3283|       |                     if constexpr (not Opts.null_terminated) {
 3284|       |                        if (it == end) [[unlikely]] {
 3285|       |                           ctx.error = error_code::unexpected_end;
 3286|       |                           return;
 3287|       |                        }
 3288|       |                     }
 3289|       |
 3290|       |                     if (parse_ws_colon<Opts>(ctx, it, end)) {
 3291|       |                        return;
 3292|       |                     }
 3293|       |
 3294|       |                     // Check if this key is the variant tag that should be skipped
 3295|       |                     if constexpr (not tag.sv().empty()) {
 3296|       |                        if (key == tag.sv()) {
 3297|       |                           // Skip the tag value
 3298|       |                           skip_value<JSON>::op<Opts>(ctx, it, end);
 3299|       |                           if (bool(ctx.error)) [[unlikely]]
 3300|       |                              return;
 3301|       |                           resync_window_end(ctx, end); // a streaming skip refills
 3302|       |                           if (skip_ws<Opts>(ctx, it, end)) {
 3303|       |                              return;
 3304|       |                           }
 3305|       |                           continue;
 3306|       |                        }
 3307|       |                     }
 3308|       |
 3309|       |                     parse<JSON>::handle_unknown<Opts>(key, value, ctx, it, end);
 3310|       |                     if (bool(ctx.error)) [[unlikely]]
 3311|       |                        return;
 3312|       |                     if constexpr (not Opts.null_terminated) {
 3313|       |                        if (it == end) [[unlikely]] {
 3314|       |                           ctx.error = error_code::unexpected_end;
 3315|       |                           return;
 3316|       |                        }
 3317|       |                     }
 3318|       |                     if (skip_ws<Opts>(ctx, it, end)) {
 3319|       |                        return;
 3320|       |                     }
 3321|       |                  }
 3322|       |               }
 3323|       |               else if constexpr (reflection_type) {
 3324|       |                  static_assert(bool(hash_info<T>.type));
 3325|       |
 3326|       |                  if (*it != '"') [[unlikely]] {
 3327|       |                     ctx.error = error_code::expected_quote;
 3328|       |                     return;
 3329|       |                  }
 3330|       |                  ++it;
 3331|       |                  if constexpr (not Opts.null_terminated) {
 3332|       |                     if (it == end) [[unlikely]] {
 3333|       |                        ctx.error = error_code::unexpected_end;
 3334|       |                        return;
 3335|       |                     }
 3336|       |                  }
 3337|       |
 3338|       |                  if constexpr (not tag.sv().empty() && not contains_tag<T, tag>()) {
 3339|       |                     // For tagged variants we first check to see if the key matches the tag
 3340|       |                     // We only need to do this if the tag is not part of the keys
 3341|       |
 3342|       |                     const auto start = it;
 3343|       |                     skip_string_view(ctx, it, end);
 3344|       |                     if (bool(ctx.error)) [[unlikely]]
 3345|       |                        return;
 3346|       |                     if (validate_utf8_span<Opts>(ctx, start, it)) [[unlikely]]
 3347|       |                        return;
 3348|       |                     const sv key{start, size_t(it - start)};
 3349|       |                     ++it;
 3350|       |                     if constexpr (not Opts.null_terminated) {
 3351|       |                        if (it == end) [[unlikely]] {
 3352|       |                           ctx.error = error_code::unexpected_end;
 3353|       |                           return;
 3354|       |                        }
 3355|       |                     }
 3356|       |
 3357|       |                     if (key == tag.sv()) {
 3358|       |                        if (parse_ws_colon<Opts>(ctx, it, end)) {
 3359|       |                           return;
 3360|       |                        }
 3361|       |
 3362|       |                        parse<JSON>::handle_unknown<Opts>(key, value, ctx, it, end);
 3363|       |                        if (bool(ctx.error)) [[unlikely]]
 3364|       |                           return;
 3365|       |
 3366|       |                        if (skip_ws<Opts>(ctx, it, end)) {
 3367|       |                           return;
 3368|       |                        }
 3369|       |                        continue;
 3370|       |                     }
 3371|       |                     else {
 3372|       |                        it = start; // reset the iterator
 3373|       |                     }
 3374|       |                  }
 3375|       |
 3376|       |                  if constexpr (Opts.error_on_missing_keys || Opts.partial_read) {
 3377|       |                     size_t index = num_members;
 3378|       |                     parse_and_invoke<Opts, T>(value, ctx, it, end, index);
 3379|       |                     if (bool(ctx.error)) [[unlikely]]
 3380|       |                        return;
 3381|       |                     if (index < num_members) {
 3382|       |                        fields[index] = true;
 3383|       |                     }
 3384|       |                  }
 3385|       |                  else {
 3386|       |                     parse_and_invoke<Opts, T>(value, ctx, it, end);
 3387|       |                     if (bool(ctx.error)) [[unlikely]]
 3388|       |                        return;
 3389|       |                  }
 3390|       |               }
 3391|  1.50M|               else {
 3392|       |                  // For types like std::map, std::unordered_map
 3393|       |
 3394|  1.50M|                  auto reading = [&](auto&& key) {
 3395|  1.50M|                     if constexpr (Opts.partial_read) {
 3396|  1.50M|                        if (auto element = value.find(key); element != value.end()) {
 3397|  1.50M|                           ++read_count;
 3398|  1.50M|                           parse<JSON>::op<ws_handled<Opts>()>(element->second, ctx, it, end);
 3399|  1.50M|                        }
 3400|  1.50M|                        else {
 3401|  1.50M|                           skip_value<JSON>::op<Opts>(ctx, it, end);
 3402|  1.50M|                        }
 3403|  1.50M|                     }
 3404|  1.50M|                     else {
 3405|  1.50M|                        parse<JSON>::op<ws_handled<Opts>()>(value[key], ctx, it, end);
 3406|  1.50M|                     }
 3407|  1.50M|                  };
 3408|       |
 3409|       |                  // using Key = std::conditional_t<heterogeneous_map<T>, sv, typename T::key_type>;
 3410|  1.50M|                  using Key = typename T::key_type;
 3411|  1.50M|                  if constexpr (std::is_same_v<Key, std::string>) {
 3412|  1.50M|                     ctx.scratch.clear();
 3413|  1.50M|                     parse<JSON>::op<Opts>(ctx.scratch, ctx, it, end);
 3414|  1.50M|                     if (bool(ctx.error)) [[unlikely]]
  ------------------
  |  Branch (3414:26): [True: 0, False: 1.50M]
  ------------------
 3415|      0|                        return;
 3416|       |
 3417|  1.50M|                     if (parse_ws_colon<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (3417:26): [True: 0, False: 1.50M]
  ------------------
 3418|      0|                        return;
 3419|      0|                     }
 3420|       |
 3421|  1.50M|                     reading(ctx.scratch);
 3422|       |                     if constexpr (Opts.partial_read) {
 3423|       |                        if (read_count == value.size()) {
 3424|       |                           return;
 3425|       |                        }
 3426|       |                     }
 3427|  1.50M|                     if (bool(ctx.error)) [[unlikely]]
  ------------------
  |  Branch (3427:26): [True: 43.8k, False: 1.45M]
  ------------------
 3428|  43.8k|                        return;
 3429|       |                  }
 3430|       |                  else if constexpr (str_t<Key>) {
 3431|       |                     Key key;
 3432|       |                     parse<JSON>::op<Opts>(key, ctx, it, end);
 3433|       |                     if (bool(ctx.error)) [[unlikely]]
 3434|       |                        return;
 3435|       |
 3436|       |                     if (parse_ws_colon<Opts>(ctx, it, end)) {
 3437|       |                        return;
 3438|       |                     }
 3439|       |
 3440|       |                     reading(key);
 3441|       |                     if constexpr (Opts.partial_read) {
 3442|       |                        if (read_count == value.size()) {
 3443|       |                           return;
 3444|       |                        }
 3445|       |                     }
 3446|       |                     if (bool(ctx.error)) [[unlikely]]
 3447|       |                        return;
 3448|       |                  }
 3449|       |                  else {
 3450|       |                     Key key_value{};
 3451|       |                     if constexpr (is_named_enum<Key> || mimics_str_t<Key>) {
 3452|       |                        parse<JSON>::op<Opts>(key_value, ctx, it, end);
 3453|       |                     }
 3454|       |                     else if constexpr (std::is_arithmetic_v<Key>) {
 3455|       |                        // prefer over quoted_t below to avoid double parsing of quoted_t
 3456|       |                        parse<JSON>::op<opt_true<Opts, quoted_num_opt_tag{}>>(key_value, ctx, it, end);
 3457|       |                     }
 3458|       |                     else {
 3459|       |                        parse<JSON>::op<opt_false<Opts, raw_string_opt_tag{}>>(quoted_t<Key>{key_value}, ctx, it, end);
 3460|       |                     }
 3461|       |                     if (bool(ctx.error)) [[unlikely]]
 3462|       |                        return;
 3463|       |
 3464|       |                     if (parse_ws_colon<Opts>(ctx, it, end)) {
 3465|       |                        return;
 3466|       |                     }
 3467|       |
 3468|       |                     reading(key_value);
 3469|       |                     if constexpr (Opts.partial_read) {
 3470|       |                        if (read_count == value.size()) {
 3471|       |                           return;
 3472|       |                        }
 3473|       |                     }
 3474|       |                     if (bool(ctx.error)) [[unlikely]]
 3475|       |                        return;
 3476|       |                  }
 3477|  1.50M|               }
 3478|       |
 3479|       |               // Streaming refill point: after parsing each key-value pair, refill if buffer is low
 3480|       |               if constexpr (has_streaming_state<decltype(ctx)>) {
 3481|       |                  if (ctx.stream.enabled()) {
 3482|       |                     const size_t consumed = static_cast<size_t>(it - ctx.stream.data());
 3483|       |                     // Refill when less than 25% of buffer remains to ensure enough space for next element
 3484|       |                     if (ctx.stream.size() - consumed <= ctx.stream.size() / 4 || it >= end) {
 3485|       |                        const char* new_it;
 3486|       |                        const char* new_end;
 3487|       |                        ctx.stream.consume_and_refill(consumed, new_it, new_end);
 3488|       |                        it = new_it;
 3489|       |                        end = new_end;
 3490|       |                        if (it >= end && ctx.stream.at_eof()) {
 3491|       |                           ctx.error = error_code::unexpected_end;
 3492|       |                           return;
 3493|       |                        }
 3494|       |                     }
 3495|       |                  }
 3496|       |               }
 3497|       |
 3498|  1.50M|               if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (3498:20): [True: 0, False: 1.50M]
  ------------------
 3499|      0|                  return;
 3500|      0|               }
 3501|  1.50M|            }
 3502|   507k|         }
 3503|   507k|      }
_ZZN3glz4fromILj10ENS_17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES1_EEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj1EEETnNS_14string_literalEXtlNS9_ILm1EEEEERS5_TkNS_10is_contextERNS_7contextERPKcSF_EEvOT1_OT2_OT3_T4_ENKUlvE_clEv:
 3148|   507k|            decltype(auto) fields = [&]() -> decltype(auto) {
 3149|       |               if constexpr ((glaze_object_t<T> || reflectable<T>) &&
 3150|       |                             (Opts.error_on_missing_keys || Opts.partial_read)) {
 3151|       |                  return bit_array<num_members>{};
 3152|       |               }
 3153|   507k|               else {
 3154|   507k|                  return nullptr;
 3155|   507k|               }
 3156|   507k|            }();
_ZZN3glz4fromILj10ENS_17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES1_EEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj1EEETnNS_14string_literalEXtlNS9_ILm1EEEEERS5_TkNS_10is_contextERNS_7contextERPKcSF_EEvOT1_OT2_OT3_T4_ENKUlOT_E_clIRNSt3__112basic_stringIcNSS_11char_traitsIcEENSS_9allocatorIcEEEEEEDaSP_:
 3394|  1.50M|                  auto reading = [&](auto&& key) {
 3395|       |                     if constexpr (Opts.partial_read) {
 3396|       |                        if (auto element = value.find(key); element != value.end()) {
 3397|       |                           ++read_count;
 3398|       |                           parse<JSON>::op<ws_handled<Opts>()>(element->second, ctx, it, end);
 3399|       |                        }
 3400|       |                        else {
 3401|       |                           skip_value<JSON>::op<Opts>(ctx, it, end);
 3402|       |                        }
 3403|       |                     }
 3404|  1.50M|                     else {
 3405|  1.50M|                        parse<JSON>::op<ws_handled<Opts>()>(value[key], ctx, it, end);
 3406|  1.50M|                     }
 3407|  1.50M|                  };
_ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEERNS_12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEETkNS_10is_contextERNS_7contextERPKcSC_EEvOT0_OT1_OT2_T3_:
   49|  1.71M|      {
   50|       |         if constexpr (const_value_v<T>) {
   51|       |            if constexpr (check_error_on_const_read(Opts)) {
   52|       |               ctx.error = error_code::attempt_const_read;
   53|       |            }
   54|       |            else {
   55|       |               // do not read anything into the const value
   56|       |               skip_value<JSON>::op<Opts>(std::forward<Ctx>(ctx), std::forward<It0>(it), end);
   57|       |            }
   58|       |         }
   59|  1.71M|         else {
   60|  1.71M|            using V = std::remove_cvref_t<T>;
   61|  1.71M|            from<JSON, V>::template op<Opts>(std::forward<T>(value), std::forward<Ctx>(ctx), std::forward<It0>(it),
   62|  1.71M|                                             end);
   63|  1.71M|         }
   64|  1.71M|      }
_ZN3glz4fromILj10ENS_12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEERS4_TkNS_10is_contextERNS_7contextERPKcSC_EEvOT0_OT1_OT2_T3_:
  150|  1.71M|      {
  151|  1.71M|         using V = std::decay_t<decltype(get_member(std::declval<Value>(), meta_wrapper_v<T>))>;
  152|  1.71M|         from<JSON, V>::template op<Opts>(get_member(std::forward<Value>(value), meta_wrapper_v<T>),
  153|  1.71M|                                          std::forward<Ctx>(ctx), std::forward<It0>(it), end);
  154|  1.71M|      }
_ZN3glz4fromILj10ENSt3__17variantIJDndNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEbNS1_6vectorINS_12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEENS6_ISD_EEEENSC_ISD_EEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEERSH_TkNS_10is_contextERNS_7contextERPKcSP_EEvOT0_OT1_OT2_T3_:
 4065|  1.71M|      {
 4066|       |         if constexpr (tagging == variant_tagging_kind::adjacent) {
 4067|       |            read_adjacent<Options>(value, ctx, it, end);
 4068|       |         }
 4069|  1.71M|         else {
 4070|  1.71M|            read_deduced<Options>(value, ctx, it, end);
 4071|  1.71M|         }
 4072|  1.71M|      }
_ZN3glz4fromILj10ENSt3__17variantIJDndNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEbNS1_6vectorINS_12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEENS6_ISD_EEEENSC_ISD_EEEEEE12read_deducedITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEERSH_TkNS_10is_contextERNS_7contextERPKcSP_EEvOT0_OT1_OT2_T3_:
 4076|  1.71M|      {
 4077|  1.71M|         constexpr auto Opts = ws_handled_off<Options>();
 4078|  1.71M|         if constexpr (variant_is_auto_deducible<T>()) {
 4079|       |            if constexpr (not check_ws_handled(Options)) {
 4080|       |               if (skip_ws<Opts>(ctx, it, end)) {
 4081|       |                  return;
 4082|       |               }
 4083|       |            }
 4084|       |
 4085|  1.71M|            switch (*it) {
 4086|      0|            case '\0':
  ------------------
  |  Branch (4086:13): [True: 0, False: 1.71M]
  ------------------
 4087|      0|               ctx.error = error_code::unexpected_end;
 4088|      0|               return;
 4089|   466k|            case '{': {
  ------------------
  |  Branch (4089:13): [True: 466k, False: 1.25M]
  ------------------
 4090|       |               // This branch consumes the brace itself and hands the object to a reader with
 4091|       |               // `opening_handled`, which therefore does not count the level -- but does release it at
 4092|       |               // the closing brace. So the level is taken here, in both buffer modes, and paid back by
 4093|       |               // the reader below.
 4094|   466k|               if (enter_depth(ctx)) [[unlikely]] {
  ------------------
  |  Branch (4094:20): [True: 0, False: 466k]
  ------------------
 4095|      0|                  return;
 4096|      0|               }
 4097|       |
 4098|   466k|               ++it;
 4099|   466k|               if constexpr (not Opts.null_terminated) {
 4100|   466k|                  if (it == end) [[unlikely]] {
  ------------------
  |  Branch (4100:23): [True: 0, False: 466k]
  ------------------
 4101|      0|                     ctx.error = error_code::unexpected_end;
 4102|      0|                     return;
 4103|      0|                  }
 4104|   466k|               }
 4105|   466k|               using type_counts = variant_type_count<T>;
 4106|   466k|               constexpr auto n_object_candidates = variant_object_candidate_count_v<Opts, T>;
 4107|       |               if constexpr (n_object_candidates < 1) {
 4108|       |                  ctx.error = error_code::no_matching_variant_type;
 4109|       |                  return;
 4110|       |               }
 4111|   466k|               else if constexpr (n_object_candidates == 1 && tag_v<T>.empty()) {
 4112|   466k|                  constexpr auto first_idx = variant_first_object_candidate_v<Opts, T>;
 4113|   466k|                  using V = std::variant_alternative_t<first_idx, T>;
 4114|   466k|                  if (!std::holds_alternative<V>(value)) value = V{};
  ------------------
  |  Branch (4114:23): [True: 466k, False: 0]
  ------------------
 4115|   466k|                  parse<JSON>::op<opening_handled<Opts>()>(std::get<V>(value), ctx, it, end);
 4116|   466k|                  return;
 4117|       |               }
 4118|       |               else {
 4119|       |                  auto possible_types = bit_array<std::variant_size_v<T>>{}.flip();
 4120|       |                  static constexpr auto& deduction_bits = variant_deduction_bits<T>;
 4121|       |                  static constexpr size_t deduction_key_count = variant_deduction_key_count<T>;
 4122|       |                  static constexpr auto tag_literal = string_literal_from_view<tag_v<T>.size()>(tag_v<T>);
 4123|       |
 4124|       |                  // Track if we've encountered a tag and what value it had
 4125|       |                  std::optional<size_t> tag_specified_index{};
 4126|       |
 4127|       |                  if (skip_ws<Opts>(ctx, it, end)) {
 4128|       |                     return;
 4129|       |                  }
 4130|       |                  // Once the reader knows which alternative this object holds it may have to read
 4131|       |                  // it again from here. Anchor the position rather than keep the pointer: the scan
 4132|       |                  // below skips values, and a streaming skip refills, which moves the window out
 4133|       |                  // from under a raw pointer (see rewind_anchor).
 4134|       |                  auto start = make_rewind_anchor(ctx, it);
 4135|       |                  bool first_key = true;
 4136|       |                  // Parse bifurcation for tagged variants:
 4137|       |                  //
 4138|       |                  // Without this optimization, tagged variant parsing always uses two passes:
 4139|       |                  //   1. Scan all keys to find the tag (e.g. "type"), skipping values
 4140|       |                  //   2. Reset `it = start` and re-parse the entire object into the resolved type
 4141|       |                  //
 4142|       |                  // When the tag is the first key, the second pass redundantly re-reads every
 4143|       |                  // field that follows it. This lambda avoids that: if the tag was the first key,
 4144|       |                  // it advances past the trailing comma so the object parser picks up at the
 4145|       |                  // second field. If the tag was found later, it falls back to the full re-parse.
 4146|       |                  //
 4147|       |                  // One exception: if the tag name is also a field on the resolved struct
 4148|       |                  // (contains_tag), we must re-parse regardless so the value is stored in
 4149|       |                  // the struct field. This override is applied inside each std::visit lambda.
 4150|       |                  //
 4151|       |                  // Either way the rewind can fail under a streaming read: the window only holds so
 4152|       |                  // much, and an object wider than it has no start left to return to.
 4153|       |                  auto position_after_tag = [&] {
 4154|       |                     if (first_key) {
 4155|       |                        if (*it == ',') ++it; // skip comma; handles tag-only objects where *it == '}'
 4156|       |                        return true;
 4157|       |                     }
 4158|       |                     return start.rewind(ctx, it, end); // tag came later, re-parse from the beginning
 4159|       |                  };
 4160|       |                  // `first_key` also answers "were we reset to the object start", which is what
 4161|       |                  // position_after_tag does for every key but the first.
 4162|       |                  for (; *it != '}'; first_key = false) {
 4163|       |                     if (!first_key) {
 4164|       |                        if (match_invalid_end<',', Opts>(ctx, it, end)) {
 4165|       |                           return;
 4166|       |                        }
 4167|       |                     }
 4168|       |
 4169|       |                     if (skip_ws<Opts>(ctx, it, end)) {
 4170|       |                        return;
 4171|       |                     }
 4172|       |                     if (match_invalid_end<'"', Opts>(ctx, it, end)) {
 4173|       |                        return;
 4174|       |                     }
 4175|       |
 4176|       |                     auto* key_start = it;
 4177|       |                     skip_string_view(ctx, it, end);
 4178|       |                     if (bool(ctx.error)) [[unlikely]]
 4179|       |                        return;
 4180|       |                     if (validate_utf8_span<Opts>(ctx, key_start, it)) [[unlikely]]
 4181|       |                        return;
 4182|       |                     const sv key = {key_start, size_t(it - key_start)};
 4183|       |
 4184|       |                     if (match_invalid_end<'"', Opts>(ctx, it, end)) {
 4185|       |                        return;
 4186|       |                     }
 4187|       |
 4188|       |                     if constexpr (deduction_key_count > 0) {
 4189|       |                        // We first check if a tag is defined and see if the key matches the tag
 4190|       |                        if constexpr (not tag_v<T>.empty()) {
 4191|       |                           if (key == tag_v<T>) {
 4192|       |                              if (parse_ws_colon<Opts>(ctx, it, end)) {
 4193|       |                                 return;
 4194|       |                              }
 4195|       |
 4196|       |                              using id_type = std::decay_t<decltype(ids_v<T>[0])>;
 4197|       |
 4198|       |                              std::conditional_t<std::integral<id_type>, id_type, sv> type_id{};
 4199|       |                              if constexpr (std::integral<id_type>) {
 4200|       |                                 from<JSON, id_type>::template op<ws_handled<Opts>()>(type_id, ctx, it, end);
 4201|       |                              }
 4202|       |                              else {
 4203|       |                                 // The id is turned into an index below and never leaves this
 4204|       |                                 // reader, so the view of the window it borrows cannot outlive it.
 4205|       |                                 parse_transient_string_view<ws_handled<Opts>()>(type_id, ctx, it, end);
 4206|       |                              }
 4207|       |                              if (bool(ctx.error)) [[unlikely]]
 4208|       |                                 return;
 4209|       |                              if (skip_ws<Opts>(ctx, it, end)) {
 4210|       |                                 return;
 4211|       |                              }
 4212|       |                              if (!(*it == ',' || *it == '}')) [[unlikely]] {
 4213|       |                                 ctx.error = error_code::syntax_error;
 4214|       |                                 return;
 4215|       |                              }
 4216|       |
 4217|       |                              size_t type_index;
 4218|       |                              if constexpr (std::integral<id_type>) {
 4219|       |                                 type_index = variant_id_to_index<T>::op(type_id);
 4220|       |                              }
 4221|       |                              else {
 4222|       |                                 type_index = variant_id_to_index<T>::op(
 4223|       |                                    type_id.data(), type_id.data() + type_id.size(), type_id.size());
 4224|       |                              }
 4225|       |                              if (type_index < ids_v<T>.size()) [[likely]] {
 4226|       |                                 // Check if the deduced types include the tag-specified type
 4227|       |                                 // If not, the tag doesn't match the fields
 4228|       |                                 // We're already inside if constexpr (deduction_registry.size()), so we know deduction
 4229|       |                                 // is happening. At this point, possible_types has been narrowed by field deduction.
 4230|       |                                 // Check if the tag-specified type is still possible
 4231|       |                                 const bool type_is_possible = possible_types[type_index];
 4232|       |                                 if (!type_is_possible) {
 4233|       |                                    // Tag specifies a type that doesn't match the fields seen so far
 4234|       |                                    ctx.error = error_code::no_matching_variant_type;
 4235|       |                                    return;
 4236|       |                                 }
 4237|       |
 4238|       |                                 if (!position_after_tag()) return;
 4239|       |                                 tag_specified_index = type_index; // Store the tag-specified type
 4240|       |                                 if (value.index() != type_index) emplace_runtime_variant(value, type_index);
 4241|       |                                 std::visit(
 4242|       |                                    [&](auto&& v) {
 4243|       |                                       using V = std::decay_t<decltype(v)>;
 4244|       |                                       constexpr bool is_object =
 4245|       |                                          (glaze_object_t<V> || reflectable<V>) && not custom_read<V>;
 4246|       |                                       if constexpr (variant_unit_alternative<V>) {
 4247|       |                                          // A unit alternative carries no data; its object holds only the
 4248|       |                                          // discriminator. Consume that body through an empty reflected object so
 4249|       |                                          // unknown-key policy and terminator handling match every other alternative.
 4250|       |                                          detail::variant_unit_body unit_body{};
 4251|       |                                          from<JSON, detail::variant_unit_body>::template op<opening_handled<Opts>(),
 4252|       |                                                                                             tag_literal>(unit_body,
 4253|       |                                                                                                          ctx, it, end);
 4254|       |                                       }
 4255|       |                                       else if constexpr (is_object) {
 4256|       |                                          if constexpr (contains_tag<V, tag_literal>()) {
 4257|       |                                             // tag is a struct field, must re-parse
 4258|       |                                             if (!start.rewind(ctx, it, end)) return;
 4259|       |                                          }
 4260|       |                                          from<JSON, V>::template op<opening_handled<Opts>(), tag_literal>(v, ctx, it,
 4261|       |                                                                                                           end);
 4262|       |                                       }
 4263|       |                                       else if constexpr (is_memory_object<V>) {
 4264|       |                                          if (!v) {
 4265|       |                                             if constexpr (is_specialization_v<V, std::optional>) {
 4266|       |                                                if constexpr (requires { v.emplace(); }) {
 4267|       |                                                   v.emplace();
 4268|       |                                                }
 4269|       |                                                else {
 4270|       |                                                   v = typename V::value_type{};
 4271|       |                                                }
 4272|       |                                             }
 4273|       |                                             else if constexpr (is_specialization_v<V, std::unique_ptr>)
 4274|       |                                                v = std::make_unique<typename V::element_type>();
 4275|       |                                             else if constexpr (is_specialization_v<V, std::shared_ptr>)
 4276|       |                                                v = std::make_shared<typename V::element_type>();
 4277|       |                                             else if constexpr (constructible<V>) {
 4278|       |                                                v = meta_construct_v<V>();
 4279|       |                                             }
 4280|       |                                             else if constexpr (std::is_pointer_v<V> &&
 4281|       |                                                                can_allocate_raw_pointer<Opts,
 4282|       |                                                                                         std::decay_t<decltype(ctx)>>) {
 4283|       |                                                if (!try_allocate_raw_pointer<Opts>(v, ctx)) {
 4284|       |                                                   return;
 4285|       |                                                }
 4286|       |                                             }
 4287|       |                                             else {
 4288|       |                                                ctx.error = error_code::invalid_nullable_read;
 4289|       |                                                return;
 4290|       |                                                // Cannot read into unset nullable that is not std::optional,
 4291|       |                                                // std::unique_ptr, or std::shared_ptr
 4292|       |                                             }
 4293|       |                                          }
 4294|       |                                          if constexpr (contains_tag<memory_type<V>, tag_literal>()) {
 4295|       |                                             // tag is a struct field, must re-parse
 4296|       |                                             if (!start.rewind(ctx, it, end)) return;
 4297|       |                                          }
 4298|       |                                          from<JSON, memory_type<V>>::template op<opening_handled<Opts>(), tag_literal>(
 4299|       |                                             *v, ctx, it, end);
 4300|       |                                       }
 4301|       |                                       else if constexpr (custom_read<V>) {
 4302|       |                                          // Custom handlers parse the remaining body themselves and do not
 4303|       |                                          // accept the tag template parameter; the tag was already consumed.
 4304|       |                                          // This only works when the tag was the first key. If it came later,
 4305|       |                                          // we were reset to the object start and the custom handler would
 4306|       |                                          // absorb the tag, so error rather than corrupt the value.
 4307|       |                                          if (!first_key) {
 4308|       |                                             ctx.error = error_code::feature_not_supported;
 4309|       |                                             ctx.custom_error_message =
 4310|       |                                                "the tag must be the first key for a custom variant alternative";
 4311|       |                                             return;
 4312|       |                                          }
 4313|       |                                          from<JSON, V>::template op<opening_handled<Opts>()>(v, ctx, it, end);
 4314|       |                                       }
 4315|       |                                    },
 4316|       |                                    value);
 4317|       |
 4318|       |                                 return; // we've decoded our target type
 4319|       |                              }
 4320|       |                              else [[unlikely]] {
 4321|       |                                 // Check if we have a default type (ids array shorter than variant)
 4322|       |                                 constexpr auto ids_size = ids_v<T>.size();
 4323|       |                                 constexpr auto variant_size = std::variant_size_v<T>;
 4324|       |                                 if constexpr (ids_size < variant_size) {
 4325|       |                                    // Use the first unlabeled type as the default
 4326|       |                                    const auto default_type_index = ids_size;
 4327|       |
 4328|       |                                    if (!position_after_tag()) return;
 4329|       |                                    tag_specified_index = default_type_index; // Store the default type index
 4330|       |                                    if (value.index() != default_type_index)
 4331|       |                                       emplace_runtime_variant(value, default_type_index);
 4332|       |                                    std::visit(
 4333|       |                                       [&](auto&& v) {
 4334|       |                                          using V = std::decay_t<decltype(v)>;
 4335|       |                                          constexpr bool is_object =
 4336|       |                                             (glaze_object_t<V> || reflectable<V>) && not custom_read<V>;
 4337|       |                                          if constexpr (variant_unit_alternative<V>) {
 4338|       |                                             // A unit alternative carries no data; its object holds only the
 4339|       |                                             // discriminator. Consume that body through an empty reflected object so
 4340|       |                                             // unknown-key policy and terminator handling match every other
 4341|       |                                             // alternative.
 4342|       |                                             detail::variant_unit_body unit_body{};
 4343|       |                                             from<JSON, detail::variant_unit_body>::template op<opening_handled<Opts>(),
 4344|       |                                                                                                tag_literal>(
 4345|       |                                                unit_body, ctx, it, end);
 4346|       |                                          }
 4347|       |                                          else if constexpr (is_object) {
 4348|       |                                             if constexpr (contains_tag<V, tag_literal>()) {
 4349|       |                                                // tag is a struct field, must re-parse
 4350|       |                                                if (!start.rewind(ctx, it, end)) return;
 4351|       |                                             }
 4352|       |                                             from<JSON, V>::template op<opening_handled<Opts>()>(v, ctx, it, end);
 4353|       |                                          }
 4354|       |                                          else if constexpr (is_memory_object<V>) {
 4355|       |                                             if (!v) {
 4356|       |                                                if constexpr (is_specialization_v<V, std::optional>) {
 4357|       |                                                   if constexpr (requires { v.emplace(); }) {
 4358|       |                                                      v.emplace();
 4359|       |                                                   }
 4360|       |                                                   else {
 4361|       |                                                      v = typename V::value_type{};
 4362|       |                                                   }
 4363|       |                                                }
 4364|       |                                                else if constexpr (is_specialization_v<V, std::unique_ptr>)
 4365|       |                                                   v = std::make_unique<typename V::element_type>();
 4366|       |                                                else if constexpr (is_specialization_v<V, std::shared_ptr>)
 4367|       |                                                   v = std::make_shared<typename V::element_type>();
 4368|       |                                                else if constexpr (constructible<V>) {
 4369|       |                                                   v = meta_construct_v<V>();
 4370|       |                                                }
 4371|       |                                                else if constexpr (std::is_pointer_v<V> &&
 4372|       |                                                                   can_allocate_raw_pointer<
 4373|       |                                                                      Opts, std::decay_t<decltype(ctx)>>) {
 4374|       |                                                   if (!try_allocate_raw_pointer<Opts>(v, ctx)) {
 4375|       |                                                      return;
 4376|       |                                                   }
 4377|       |                                                }
 4378|       |                                                else {
 4379|       |                                                   ctx.error = error_code::invalid_nullable_read;
 4380|       |                                                   return;
 4381|       |                                                }
 4382|       |                                             }
 4383|       |                                             if constexpr (contains_tag<memory_type<V>, tag_literal>()) {
 4384|       |                                                // tag is a struct field, must re-parse
 4385|       |                                                if (!start.rewind(ctx, it, end)) return;
 4386|       |                                             }
 4387|       |                                             from<JSON, memory_type<V>>::template op<opening_handled<Opts>()>(*v, ctx,
 4388|       |                                                                                                              it, end);
 4389|       |                                          }
 4390|       |                                          else if constexpr (custom_read<V>) {
 4391|       |                                             // Custom handlers parse the remaining body themselves; this only
 4392|       |                                             // works when the tag was the first key (see above). If it came
 4393|       |                                             // later we were reset to the object start, so error rather than
 4394|       |                                             // let the custom handler absorb the tag.
 4395|       |                                             if (!first_key) {
 4396|       |                                                ctx.error = error_code::feature_not_supported;
 4397|       |                                                ctx.custom_error_message =
 4398|       |                                                   "the tag must be the first key for a custom variant alternative";
 4399|       |                                                return;
 4400|       |                                             }
 4401|       |                                             from<JSON, V>::template op<opening_handled<Opts>()>(v, ctx, it, end);
 4402|       |                                          }
 4403|       |                                       },
 4404|       |                                       value);
 4405|       |
 4406|       |                                    return;
 4407|       |                                 }
 4408|       |                                 else {
 4409|       |                                    ctx.error = error_code::no_matching_variant_type;
 4410|       |                                    ctx.custom_error_message = variant_ids_string_v<T>;
 4411|       |                                    return;
 4412|       |                                 }
 4413|       |                              }
 4414|       |                           }
 4415|       |                        }
 4416|       |
 4417|       |                        // Inline decode_hash lookup for variant deduction
 4418|       |                        using deduction_keys_t = keys_wrapper<variant_deduction_keys<T>>;
 4419|       |                        constexpr auto& DeductionHashInfo = hash_info<deduction_keys_t>;
 4420|       |                        const auto deduction_index =
 4421|       |                           decode_hash_with_size<JSON, deduction_keys_t, DeductionHashInfo, DeductionHashInfo.type>::op(
 4422|       |                              key.data(), key.data() + key.size(), key.size());
 4423|       |                        if (deduction_index < deduction_key_count && variant_deduction_keys<T>[deduction_index] == key)
 4424|       |                           [[likely]] {
 4425|       |                           possible_types &= deduction_bits[deduction_index];
 4426|       |                        }
 4427|       |                        else if constexpr (Opts.error_on_unknown_keys) {
 4428|       |                           ctx.error = error_code::unknown_key;
 4429|       |                           return;
 4430|       |                        }
 4431|       |                     }
 4432|       |                     else if constexpr (not tag_v<T>.empty()) {
 4433|       |                        // empty object case for variant, if there are no normal elements
 4434|       |                        if (key == tag_v<T>) {
 4435|       |                           if (parse_ws_colon<Opts>(ctx, it, end)) {
 4436|       |                              return;
 4437|       |                           }
 4438|       |
 4439|       |                           // The id is turned into an index below and never leaves this reader,
 4440|       |                           // so the view of the window it borrows cannot outlive that window.
 4441|       |                           std::string_view type_id{};
 4442|       |                           parse_transient_string_view<ws_handled<Opts>()>(type_id, ctx, it, end);
 4443|       |                           if (bool(ctx.error)) [[unlikely]]
 4444|       |                              return;
 4445|       |                           if (skip_ws<Opts>(ctx, it, end)) {
 4446|       |                              return;
 4447|       |                           }
 4448|       |
 4449|       |                           const auto type_index = variant_id_to_index<T>::op(
 4450|       |                              type_id.data(), type_id.data() + type_id.size(), type_id.size());
 4451|       |                           if (type_index < ids_v<T>.size()) [[likely]] {
 4452|       |                              if (!position_after_tag()) return;
 4453|       |                              tag_specified_index = type_index; // Store the tag-specified type
 4454|       |                              if (value.index() != type_index) emplace_runtime_variant(value, type_index);
 4455|       |                           }
 4456|       |                           else {
 4457|       |                              // Check if we have a default type (ids array shorter than variant)
 4458|       |                              constexpr auto ids_size = ids_v<T>.size();
 4459|       |                              constexpr auto variant_size = std::variant_size_v<T>;
 4460|       |                              if constexpr (ids_size < variant_size) {
 4461|       |                                 // Use the first unlabeled type as the default
 4462|       |                                 if (!position_after_tag()) return;
 4463|       |                                 const auto default_index = ids_size;
 4464|       |                                 tag_specified_index = default_index; // Store the default type index
 4465|       |                                 if (value.index() != default_index) emplace_runtime_variant(value, default_index);
 4466|       |                              }
 4467|       |                              else {
 4468|       |                                 ctx.error = error_code::no_matching_variant_type;
 4469|       |                                 ctx.custom_error_message = variant_ids_string_v<T>;
 4470|       |                                 return;
 4471|       |                              }
 4472|       |                           }
 4473|       |                           // Parse the type (handles tag skipping and unknown keys)
 4474|       |                           std::visit(
 4475|       |                              [&](auto&& v) {
 4476|       |                                 using V = std::decay_t<decltype(v)>;
 4477|       |                                 if constexpr (custom_read<V>) {
 4478|       |                                    // Custom handlers parse the remaining object body themselves and do not
 4479|       |                                    // accept the tag template parameter that reflected objects use to skip an
 4480|       |                                    // interior tag key. That only works when the tag is the first key (it was
 4481|       |                                    // just consumed). If the tag came after other keys, position_after_tag()
 4482|       |                                    // reset us to the object start and the custom handler would absorb the tag
 4483|       |                                    // into its value, so error here rather than corrupt the result.
 4484|       |                                    if (!first_key) {
 4485|       |                                       ctx.error = error_code::feature_not_supported;
 4486|       |                                       ctx.custom_error_message =
 4487|       |                                          "the tag must be the first key for a custom variant alternative";
 4488|       |                                       return;
 4489|       |                                    }
 4490|       |                                    from<JSON, V>::template op<opening_handled<Opts>()>(v, ctx, it, end);
 4491|       |                                 }
 4492|       |                                 else {
 4493|       |                                    if constexpr (contains_tag<V, tag_literal>()) {
 4494|       |                                       // tag is a struct field, must re-parse
 4495|       |                                       if (!start.rewind(ctx, it, end)) return;
 4496|       |                                    }
 4497|       |                                    from<JSON, V>::template op<opening_handled<Opts>(), tag_literal>(v, ctx, it, end);
 4498|       |                                 }
 4499|       |                              },
 4500|       |                              value);
 4501|       |                           return;
 4502|       |                        }
 4503|       |                        else if constexpr (Opts.error_on_unknown_keys) {
 4504|       |                           ctx.error = error_code::unknown_key;
 4505|       |                           return;
 4506|       |                        }
 4507|       |                        else {
 4508|       |                           // Skip unknown key's value (non-tag key in empty variant)
 4509|       |                           if (parse_ws_colon<Opts>(ctx, it, end)) {
 4510|       |                              return;
 4511|       |                           }
 4512|       |                           skip_value<JSON>::op<Opts>(ctx, it, end);
 4513|       |                           if (bool(ctx.error)) [[unlikely]]
 4514|       |                              return;
 4515|       |                           resync_window_end(ctx, end); // a streaming skip refills
 4516|       |                           if (skip_ws<Opts>(ctx, it, end)) {
 4517|       |                              return;
 4518|       |                           }
 4519|       |                           continue; // Continue loop to find the tag
 4520|       |                        }
 4521|       |                     }
 4522|       |                     else if constexpr (Opts.error_on_unknown_keys) {
 4523|       |                        ctx.error = error_code::unknown_key;
 4524|       |                        return;
 4525|       |                     }
 4526|       |
 4527|       |                     auto matching_types = possible_types.popcount();
 4528|       |                     if (matching_types == 0) {
 4529|       |                        ctx.error = error_code::no_matching_variant_type;
 4530|       |                        return;
 4531|       |                     }
 4532|       |                     // Only short-circuit for variants without tags
 4533|       |                     else if constexpr (tag_v<T>.empty()) {
 4534|       |                        if (matching_types == 1) {
 4535|       |                           if (!start.rewind(ctx, it, end)) return;
 4536|       |                           const auto type_index = possible_types.countr_zero();
 4537|       |
 4538|       |                           if (value.index() != static_cast<size_t>(type_index))
 4539|       |                              emplace_runtime_variant(value, type_index);
 4540|       |                           std::visit(
 4541|       |                              [&](auto&& v) {
 4542|       |                                 using V = std::decay_t<decltype(v)>;
 4543|       |                                 constexpr bool is_object = (glaze_object_t<V> || reflectable<V>) && not custom_read<V>;
 4544|       |                                 if constexpr (variant_unit_alternative<V>) {
 4545|       |                                    // A unit alternative carries no data; its object holds only the discriminator.
 4546|       |                                    // Consume that body through an empty reflected object so unknown-key policy and
 4547|       |                                    // terminator handling match every other alternative.
 4548|       |                                    detail::variant_unit_body unit_body{};
 4549|       |                                    from<JSON, detail::variant_unit_body>::template op<opening_handled<Opts>(),
 4550|       |                                                                                       tag_literal>(unit_body, ctx, it,
 4551|       |                                                                                                    end);
 4552|       |                                 }
 4553|       |                                 else if constexpr (is_object) {
 4554|       |                                    from<JSON, V>::template op<opening_handled<Opts>(), tag_literal>(v, ctx, it, end);
 4555|       |                                 }
 4556|       |                                 else if constexpr (is_memory_object<V>) {
 4557|       |                                    if (!v) {
 4558|       |                                       if constexpr (is_specialization_v<V, std::optional>) {
 4559|       |                                          if constexpr (requires { v.emplace(); }) {
 4560|       |                                             v.emplace();
 4561|       |                                          }
 4562|       |                                          else {
 4563|       |                                             v = typename V::value_type{};
 4564|       |                                          }
 4565|       |                                       }
 4566|       |                                       else if constexpr (is_specialization_v<V, std::unique_ptr>)
 4567|       |                                          v = std::make_unique<typename V::element_type>();
 4568|       |                                       else if constexpr (is_specialization_v<V, std::shared_ptr>)
 4569|       |                                          v = std::make_shared<typename V::element_type>();
 4570|       |                                       else if constexpr (constructible<V>) {
 4571|       |                                          v = meta_construct_v<V>();
 4572|       |                                       }
 4573|       |                                       else if constexpr (std::is_pointer_v<V> &&
 4574|       |                                                          can_allocate_raw_pointer<Opts, std::decay_t<decltype(ctx)>>) {
 4575|       |                                          if (!try_allocate_raw_pointer<Opts>(v, ctx)) {
 4576|       |                                             return;
 4577|       |                                          }
 4578|       |                                       }
 4579|       |                                       else {
 4580|       |                                          ctx.error = error_code::invalid_nullable_read;
 4581|       |                                          return;
 4582|       |                                          // Cannot read into unset nullable that is not std::optional,
 4583|       |                                          // std::unique_ptr, or std::shared_ptr
 4584|       |                                       }
 4585|       |                                    }
 4586|       |                                    from<JSON, memory_type<V>>::template op<opening_handled<Opts>(), tag_literal>(
 4587|       |                                       *v, ctx, it, end);
 4588|       |                                 }
 4589|       |                                 else if constexpr (custom_read<V>) {
 4590|       |                                    // Custom handlers parse the remaining body themselves.
 4591|       |                                    from<JSON, V>::template op<opening_handled<Opts>()>(v, ctx, it, end);
 4592|       |                                 }
 4593|       |                              },
 4594|       |                              value);
 4595|       |
 4596|       |                           return; // we've decoded our target type
 4597|       |                        }
 4598|       |                     }
 4599|       |                     // For tagged variants, continue processing to validate tags
 4600|       |                     if (parse_ws_colon<Opts>(ctx, it, end)) {
 4601|       |                        return;
 4602|       |                     }
 4603|       |
 4604|       |                     skip_value<JSON>::op<Opts>(ctx, it, end);
 4605|       |                     if (bool(ctx.error)) [[unlikely]]
 4606|       |                        return;
 4607|       |                     resync_window_end(ctx, end); // a streaming skip refills
 4608|       |                     if (skip_ws<Opts>(ctx, it, end)) {
 4609|       |                        return;
 4610|       |                     }
 4611|       |                  }
 4612|       |                  // Only apply ambiguous variant resolution if we have multiple object types
 4613|       |                  if constexpr ((type_counts::n_object + type_counts::n_nullable_object) > 1) {
 4614|       |                     // After parsing all keys, check if we have multiple matching types
 4615|       |                     // If so, choose the one with the fewest fields
 4616|       |                     auto final_matching = possible_types.popcount();
 4617|       |                     if (final_matching == 0) {
 4618|       |                        ctx.error = error_code::no_matching_variant_type;
 4619|       |                     }
 4620|       |                     else if (final_matching == 1) {
 4621|       |                        // Single type remains after field deduction
 4622|       |                        const auto type_index = possible_types.countr_zero();
 4623|       |
 4624|       |                        // Validate against tag if one was specified
 4625|       |                        if (tag_specified_index.has_value() &&
 4626|       |                            tag_specified_index.value() != static_cast<size_t>(type_index)) {
 4627|       |                           ctx.error = error_code::no_matching_variant_type;
 4628|       |                           return;
 4629|       |                        }
 4630|       |
 4631|       |                        if (!start.rewind(ctx, it, end)) return;
 4632|       |                        if (value.index() != static_cast<size_t>(type_index))
 4633|       |                           emplace_runtime_variant(value, type_index);
 4634|       |                        std::visit(
 4635|       |                           [&](auto&& v) {
 4636|       |                              using V = std::decay_t<decltype(v)>;
 4637|       |                              constexpr bool is_object = (glaze_object_t<V> || reflectable<V>) && not custom_read<V>;
 4638|       |                              if constexpr (variant_unit_alternative<V>) {
 4639|       |                                 // A unit alternative carries no data; its object holds only the discriminator.
 4640|       |                                 // Consume that body through an empty reflected object so unknown-key policy and
 4641|       |                                 // terminator handling match every other alternative.
 4642|       |                                 detail::variant_unit_body unit_body{};
 4643|       |                                 from<JSON, detail::variant_unit_body>::template op<opening_handled<Opts>(),
 4644|       |                                                                                    tag_literal>(unit_body, ctx, it,
 4645|       |                                                                                                 end);
 4646|       |                              }
 4647|       |                              else if constexpr (is_object) {
 4648|       |                                 from<JSON, V>::template op<opening_handled<Opts>(), tag_literal>(v, ctx, it, end);
 4649|       |                              }
 4650|       |                              else if constexpr (is_memory_object<V>) {
 4651|       |                                 if (!v) {
 4652|       |                                    if constexpr (is_specialization_v<V, std::optional>) {
 4653|       |                                       if constexpr (requires { v.emplace(); }) {
 4654|       |                                          v.emplace();
 4655|       |                                       }
 4656|       |                                       else {
 4657|       |                                          v = typename V::value_type{};
 4658|       |                                       }
 4659|       |                                    }
 4660|       |                                    else if constexpr (is_specialization_v<V, std::unique_ptr>)
 4661|       |                                       v = std::make_unique<typename V::element_type>();
 4662|       |                                    else if constexpr (is_specialization_v<V, std::shared_ptr>)
 4663|       |                                       v = std::make_shared<typename V::element_type>();
 4664|       |                                    else if constexpr (constructible<V>) {
 4665|       |                                       v = meta_construct_v<V>();
 4666|       |                                    }
 4667|       |                                    else if constexpr (std::is_pointer_v<V> &&
 4668|       |                                                       can_allocate_raw_pointer<Opts, std::decay_t<decltype(ctx)>>) {
 4669|       |                                       if (!try_allocate_raw_pointer<Opts>(v, ctx)) {
 4670|       |                                          return;
 4671|       |                                       }
 4672|       |                                    }
 4673|       |                                    else {
 4674|       |                                       ctx.error = error_code::invalid_nullable_read;
 4675|       |                                       return;
 4676|       |                                    }
 4677|       |                                 }
 4678|       |                                 from<JSON, memory_type<V>>::template op<opening_handled<Opts>(), tag_literal>(*v, ctx,
 4679|       |                                                                                                               it, end);
 4680|       |                              }
 4681|       |                              else if constexpr (custom_read<V>) {
 4682|       |                                 // Custom handlers parse the remaining body themselves.
 4683|       |                                 from<JSON, V>::template op<opening_handled<Opts>()>(v, ctx, it, end);
 4684|       |                              }
 4685|       |                           },
 4686|       |                           value);
 4687|       |                     }
 4688|       |                     else if (final_matching > 1) {
 4689|       |                        constexpr auto N = std::variant_size_v<T>;
 4690|       |
 4691|       |                        // Compile-time array of field counts for each variant type
 4692|       |                        constexpr auto field_counts = []<size_t... I>(std::index_sequence<I...>) {
 4693|       |                           return std::array<size_t, N> {
 4694|       |                              ([]<size_t J = I>() -> size_t {
 4695|       |                                 using V = std::decay_t<std::variant_alternative_t<J, T>>;
 4696|       |                                 if constexpr (glaze_object_t<V> || reflectable<V>) {
 4697|       |                                    return reflect<V>::size;
 4698|       |                                 }
 4699|       |                                 else if constexpr (is_memory_object<V>) {
 4700|       |                                    using X = memory_type<V>;
 4701|       |                                    if constexpr (glaze_object_t<X> || reflectable<X>) {
 4702|       |                                       return reflect<X>::size;
 4703|       |                                    }
 4704|       |                                    else {
 4705|       |                                       return (std::numeric_limits<size_t>::max)();
 4706|       |                                    }
 4707|       |                                 }
 4708|       |                                 else {
 4709|       |                                    return (std::numeric_limits<size_t>::max)();
 4710|       |                                 }
 4711|       |                              }.template operator()<I>())...
 4712|       |                           };
 4713|       |                        }(std::make_index_sequence<N>{});
 4714|       |
 4715|       |                        // Find the type with minimum field count among the possible types
 4716|       |                        size_t min_fields = (std::numeric_limits<size_t>::max)();
 4717|       |                        size_t chosen_index = N; // Invalid index initially
 4718|       |
 4719|       |                        for (size_t i = 0; i < N; ++i) {
 4720|       |                           if (possible_types[i] && field_counts[i] < min_fields) {
 4721|       |                              min_fields = field_counts[i];
 4722|       |                              chosen_index = i;
 4723|       |                           }
 4724|       |                        }
 4725|       |
 4726|       |                        if (chosen_index < N) {
 4727|       |                           // Validate against tag if one was specified
 4728|       |                           if (tag_specified_index.has_value() && tag_specified_index.value() != chosen_index) {
 4729|       |                              ctx.error = error_code::no_matching_variant_type;
 4730|       |                              return;
 4731|       |                           }
 4732|       |
 4733|       |                           if (!start.rewind(ctx, it, end)) return;
 4734|       |                           if (value.index() != chosen_index) emplace_runtime_variant(value, chosen_index);
 4735|       |                           std::visit(
 4736|       |                              [&](auto&& v) {
 4737|       |                                 using V = std::decay_t<decltype(v)>;
 4738|       |                                 constexpr bool is_object = (glaze_object_t<V> || reflectable<V>) && not custom_read<V>;
 4739|       |                                 if constexpr (variant_unit_alternative<V>) {
 4740|       |                                    // A unit alternative carries no data; its object holds only the discriminator.
 4741|       |                                    // Consume that body through an empty reflected object so unknown-key policy and
 4742|       |                                    // terminator handling match every other alternative.
 4743|       |                                    detail::variant_unit_body unit_body{};
 4744|       |                                    from<JSON, detail::variant_unit_body>::template op<opening_handled<Opts>(),
 4745|       |                                                                                       tag_literal>(unit_body, ctx, it,
 4746|       |                                                                                                    end);
 4747|       |                                 }
 4748|       |                                 else if constexpr (is_object) {
 4749|       |                                    from<JSON, V>::template op<opening_handled<Opts>(), tag_literal>(v, ctx, it, end);
 4750|       |                                 }
 4751|       |                                 else if constexpr (is_memory_object<V>) {
 4752|       |                                    if (!v) {
 4753|       |                                       if constexpr (is_specialization_v<V, std::optional>) {
 4754|       |                                          if constexpr (requires { v.emplace(); }) {
 4755|       |                                             v.emplace();
 4756|       |                                          }
 4757|       |                                          else {
 4758|       |                                             v = typename V::value_type{};
 4759|       |                                          }
 4760|       |                                       }
 4761|       |                                       else if constexpr (is_specialization_v<V, std::unique_ptr>)
 4762|       |                                          v = std::make_unique<typename V::element_type>();
 4763|       |                                       else if constexpr (is_specialization_v<V, std::shared_ptr>)
 4764|       |                                          v = std::make_shared<typename V::element_type>();
 4765|       |                                       else if constexpr (constructible<V>) {
 4766|       |                                          v = meta_construct_v<V>();
 4767|       |                                       }
 4768|       |                                       else if constexpr (std::is_pointer_v<V> &&
 4769|       |                                                          can_allocate_raw_pointer<Opts, std::decay_t<decltype(ctx)>>) {
 4770|       |                                          if (!try_allocate_raw_pointer<Opts>(v, ctx)) {
 4771|       |                                             return;
 4772|       |                                          }
 4773|       |                                       }
 4774|       |                                       else {
 4775|       |                                          ctx.error = error_code::invalid_nullable_read;
 4776|       |                                          return;
 4777|       |                                       }
 4778|       |                                    }
 4779|       |                                    from<JSON, memory_type<V>>::template op<opening_handled<Opts>(), tag_literal>(
 4780|       |                                       *v, ctx, it, end);
 4781|       |                                 }
 4782|       |                                 else if constexpr (custom_read<V>) {
 4783|       |                                    // Custom handlers parse the remaining body themselves.
 4784|       |                                    from<JSON, V>::template op<opening_handled<Opts>()>(v, ctx, it, end);
 4785|       |                                 }
 4786|       |                              },
 4787|       |                              value);
 4788|       |                        }
 4789|       |                        else {
 4790|       |                           ctx.error = error_code::no_matching_variant_type;
 4791|       |                        }
 4792|       |                     }
 4793|       |                  }
 4794|       |                  else {
 4795|       |                     // For variants with 0 or 1 object types, use the original error handling
 4796|       |                     ctx.error = error_code::no_matching_variant_type;
 4797|       |                  }
 4798|       |               }
 4799|      0|               break;
 4800|   466k|            }
 4801|    190|            case '[':
  ------------------
  |  Branch (4801:13): [True: 190, False: 1.71M]
  ------------------
 4802|       |               // As with '{' above: the array reader each alternative goes through counts the level.
 4803|    190|               process_variant_alternatives<T, is_variant_array>::template op<Opts>(value, ctx, it, end);
 4804|    190|               break;
 4805|   759k|            case '"': {
  ------------------
  |  Branch (4805:13): [True: 759k, False: 957k]
  ------------------
 4806|   759k|               process_variant_alternatives<T, is_variant_str>::template op<Opts>(value, ctx, it, end);
 4807|   759k|               break;
 4808|   466k|            }
 4809|      0|            case 't':
  ------------------
  |  Branch (4809:13): [True: 0, False: 1.71M]
  ------------------
 4810|      0|            case 'f': {
  ------------------
  |  Branch (4810:13): [True: 0, False: 1.71M]
  ------------------
 4811|      0|               process_variant_alternatives<T, is_variant_bool>::template op<Opts>(value, ctx, it, end);
 4812|      0|               break;
 4813|      0|            }
 4814|   222k|            case 'n':
  ------------------
  |  Branch (4814:13): [True: 222k, False: 1.49M]
  ------------------
 4815|       |               if constexpr (variant_count_v<T, is_variant_null> == 0) {
 4816|       |                  ctx.error = error_code::no_matching_variant_type;
 4817|       |               }
 4818|   222k|               else {
 4819|   222k|                  constexpr auto first_idx = variant_first_index_v<T, is_variant_null>;
 4820|   222k|                  using V = std::variant_alternative_t<first_idx, T>;
 4821|   222k|                  if (!std::holds_alternative<V>(value)) value = V{};
  ------------------
  |  Branch (4821:23): [True: 0, False: 222k]
  ------------------
 4822|   222k|                  match<"null", Opts>(ctx, it, end);
 4823|   222k|               }
 4824|   222k|               break;
 4825|   268k|            default: {
  ------------------
  |  Branch (4825:13): [True: 268k, False: 1.44M]
  ------------------
 4826|       |               // Not bool, string, object, or array so must be number or null
 4827|   268k|               process_variant_alternatives<T, is_variant_num>::template op<Opts>(value, ctx, it, end);
 4828|   268k|            }
 4829|  1.71M|            }
 4830|       |         }
 4831|       |         else {
 4832|       |            // For non-auto-deducible variants, try each type until one succeeds
 4833|       |            constexpr auto N = std::variant_size_v<T>;
 4834|       |            bool parsed = false;
 4835|       |            bool exhausted = false; // speculation budget spent; see charge_speculation
 4836|       |
 4837|       |            for_each<N>([&]<size_t I>() {
 4838|       |               if (parsed || exhausted || variant_alternative_exhausted(ctx)) return;
 4839|       |
 4840|       |               auto copy_it = it;
 4841|       |               // A rejected alternative may have bailed out inside a container, which leaves its
 4842|       |               // nesting level counted (see enter_depth), so the depth rewinds with the iterator.
 4843|       |               const auto copy_depth = ctx.depth;
 4844|       |
 4845|       |               // Try parsing as this type
 4846|       |               if (value.index() != I) {
 4847|       |                  emplace_runtime_variant(value, I);
 4848|       |               }
 4849|       |
 4850|       |               std::visit([&](auto&& v) { parse<JSON>::op<Options>(v, ctx, it, end); }, value);
 4851|       |               if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) {
 4852|       |                  exhausted = true; // only rejected attempts are charged; see charge_speculation
 4853|       |               }
 4854|       |
 4855|       |               if (!bool(ctx.error)) {
 4856|       |                  parsed = true;
 4857|       |               }
 4858|       |               else if constexpr (not Options.null_terminated) {
 4859|       |                  // In non-null-terminated mode, if we hit end_reached after advancing the iterator,
 4860|       |                  // it means we successfully parsed the value but couldn't skip trailing whitespace
 4861|       |                  if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) {
 4862|       |                     // We advanced the iterator, so we did parse something -- unless what advanced it
 4863|       |                     // was an abandoned attempt, which is what a spent speculation budget means.
 4864|       |                     parsed = true;
 4865|       |                     ctx.error = error_code::none;
 4866|       |                  }
 4867|       |                  else {
 4868|       |                     // Reset for next attempt (unless this is the last type)
 4869|       |                     it = copy_it;
 4870|       |                     rewind_depth<Options>(ctx, copy_depth);
 4871|       |                     if constexpr (I + 1 < N) {
 4872|       |                        if (not exhausted && not variant_alternative_exhausted(ctx)) {
 4873|       |                           ctx.error = error_code::none; // Clear error for next attempt
 4874|       |                        }
 4875|       |                     }
 4876|       |                  }
 4877|       |               }
 4878|       |               else {
 4879|       |                  // Reset for next attempt (unless this is the last type)
 4880|       |                  it = copy_it;
 4881|       |                  rewind_depth<Options>(ctx, copy_depth);
 4882|       |                  if constexpr (I + 1 < N) {
 4883|       |                     if (not exhausted && not variant_alternative_exhausted(ctx)) {
 4884|       |                        ctx.error = error_code::none; // Clear error for next attempt
 4885|       |                     }
 4886|       |                  }
 4887|       |               }
 4888|       |            });
 4889|       |         }
 4890|  1.71M|      }
_ZN3glz28process_variant_alternativesINSt3__17variantIJDndNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEbNS1_6vectorINS_12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEENS6_ISD_EEEENSC_ISD_EEEEENS_16is_variant_arrayEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSH_TkNS_10is_contextERNS_7contextERPKcSQ_EEvOT0_OT1_OT2_T3_:
 3725|  16.7k|      {
 3726|  16.7k|         constexpr auto category_count = variant_count_v<Variant, Trait>;
 3727|       |
 3728|       |         if constexpr (category_count == 0) {
 3729|       |            ctx.error = error_code::no_matching_variant_type;
 3730|       |         }
 3731|  16.7k|         else {
 3732|  16.7k|            constexpr auto N = std::variant_size_v<Variant>;
 3733|  16.7k|            constexpr auto const_count = variant_filtered_count_v<Variant, Trait, true>;
 3734|  16.7k|            constexpr auto non_const_count = variant_filtered_count_v<Variant, Trait, false>;
 3735|       |
 3736|  16.7k|            bool found_match{};
 3737|       |            // Set when the speculative parsing budget runs out; see charge_speculation. An ambiguous
 3738|       |            // nest re-parses the same subtree per alternative at every level, which is exponential,
 3739|       |            // so the budget stops it and the failure already in hand is reported.
 3740|  16.7k|            bool exhausted{};
 3741|       |
 3742|       |            // First pass: const glaze types in this category
 3743|       |            if constexpr (const_count > 0) {
 3744|       |               for_each<N>([&]<size_t I>() {
 3745|       |                  if (found_match || exhausted || variant_alternative_exhausted(ctx)) {
 3746|       |                     return;
 3747|       |                  }
 3748|       |                  using V = std::variant_alternative_t<I, Variant>;
 3749|       |                  if constexpr (Trait<V>::value && glaze_const_value_t<V>) {
 3750|       |                     // run time substitute to compare to const value
 3751|       |                     std::remove_const_t<std::remove_pointer_t<std::remove_const_t<meta_wrapper_t<V>>>> substitute{};
 3752|       |                     auto copy_it{it};
 3753|       |                     // A rejected alternative may have bailed out inside a container, which leaves its
 3754|       |                     // nesting level counted (see enter_depth). Rewind the depth with the iterator so
 3755|       |                     // trying N alternatives cannot spend N levels of the recursion budget.
 3756|       |                     const auto copy_depth{ctx.depth};
 3757|       |                     parse<JSON>::op<ws_handled<Options>()>(substitute, ctx, it, end);
 3758|       |                     static constexpr auto const_value{*meta_wrapper_v<V>};
 3759|       |                     if (substitute == const_value) {
 3760|       |                        found_match = true;
 3761|       |                        if (!std::holds_alternative<V>(value)) {
 3762|       |                           value = V{};
 3763|       |                        }
 3764|       |                     }
 3765|       |                     else {
 3766|       |                        // Rejected: charge the bytes it parsed before we rewind. See charge_speculation.
 3767|       |                        if (!charge_speculation(ctx, size_t(it - copy_it))) {
 3768|       |                           exhausted = true;
 3769|       |                        }
 3770|       |                        if constexpr (not Options.null_terminated) {
 3771|       |                           if (ctx.error == error_code::end_reached && not exhausted) {
 3772|       |                              ctx.error = error_code::none;
 3773|       |                           }
 3774|       |                        }
 3775|       |                        it = copy_it;
 3776|       |                        rewind_depth<Options>(ctx, copy_depth);
 3777|       |                     }
 3778|       |                  }
 3779|       |               });
 3780|       |               if (found_match) {
 3781|       |                  return;
 3782|       |               }
 3783|       |            }
 3784|       |
 3785|       |            // Second pass: non-const types in this category
 3786|  16.7k|            if constexpr (non_const_count > 0) {
 3787|       |               // Track position within matching types for "is last" check.
 3788|       |               // We iterate over all variant indices but only process matching types,
 3789|       |               // so we need runtime tracking (vs the old tuple-based approach where
 3790|       |               // the loop index directly corresponded to position in filtered set).
 3791|       |               // This has negligible cost: one increment per matching type.
 3792|  16.7k|               size_t non_const_idx = 0;
 3793|       |
 3794|  16.7k|               for_each<N>([&]<size_t I>() {
 3795|  16.7k|                  if (found_match || exhausted || variant_alternative_exhausted(ctx)) {
 3796|  16.7k|                     return;
 3797|  16.7k|                  }
 3798|  16.7k|                  using V = std::variant_alternative_t<I, Variant>;
 3799|  16.7k|                  if constexpr (Trait<V>::value && !glaze_const_value_t<V>) {
 3800|  16.7k|                     auto copy_it{it};
 3801|  16.7k|                     const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above
 3802|  16.7k|                     if (!std::holds_alternative<V>(value)) {
 3803|  16.7k|                        value = V{};
 3804|  16.7k|                     }
 3805|  16.7k|                     parse<JSON>::op<ws_handled<Options>()>(std::get<V>(value), ctx, it, end);
 3806|  16.7k|                     if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) {
 3807|  16.7k|                        exhausted = true; // only rejected attempts are charged; see charge_speculation
 3808|  16.7k|                     }
 3809|  16.7k|                     if (!bool(ctx.error)) {
 3810|  16.7k|                        found_match = true;
 3811|  16.7k|                     }
 3812|  16.7k|                     else if constexpr (not Options.null_terminated) {
 3813|  16.7k|                        constexpr bool is_complete_type =
 3814|  16.7k|                           num_t<V> || bool_t<V> || string_t<V> || std::is_enum_v<V> || tuple_t<V> || is_std_tuple<V>;
 3815|       |
 3816|  16.7k|                        if constexpr (is_complete_type) {
 3817|  16.7k|                           if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) {
 3818|  16.7k|                              found_match = true;
 3819|  16.7k|                              ctx.error = error_code::none;
 3820|  16.7k|                           }
 3821|  16.7k|                           else {
 3822|  16.7k|                              it = copy_it;
 3823|  16.7k|                              rewind_depth<Options>(ctx, copy_depth);
 3824|  16.7k|                              if (non_const_idx + 1 < non_const_count && not exhausted &&
 3825|  16.7k|                                  not variant_alternative_exhausted(ctx)) {
 3826|  16.7k|                                 ctx.error = error_code::none;
 3827|  16.7k|                              }
 3828|  16.7k|                           }
 3829|  16.7k|                        }
 3830|  16.7k|                        else {
 3831|  16.7k|                           it = copy_it;
 3832|  16.7k|                           rewind_depth<Options>(ctx, copy_depth);
 3833|  16.7k|                           if (non_const_idx + 1 < non_const_count && not exhausted &&
 3834|  16.7k|                               not variant_alternative_exhausted(ctx)) {
 3835|  16.7k|                              ctx.error = error_code::none;
 3836|  16.7k|                           }
 3837|  16.7k|                        }
 3838|  16.7k|                     }
 3839|  16.7k|                     else {
 3840|  16.7k|                        it = copy_it;
 3841|  16.7k|                        rewind_depth<Options>(ctx, copy_depth);
 3842|  16.7k|                        if (non_const_idx + 1 < non_const_count && not exhausted &&
 3843|  16.7k|                            not variant_alternative_exhausted(ctx)) {
 3844|  16.7k|                           ctx.error = error_code::none;
 3845|  16.7k|                        }
 3846|  16.7k|                     }
 3847|  16.7k|                     ++non_const_idx;
 3848|  16.7k|                  }
 3849|  16.7k|               });
 3850|  16.7k|               if (!found_match) {
  ------------------
  |  Branch (3850:20): [True: 5.68k, False: 11.0k]
  ------------------
 3851|  5.68k|                  if constexpr (non_const_count == 1) {
 3852|       |                     // Keep the specific error from the single type we tried
 3853|       |                  }
 3854|       |                  else if (not exhausted && not variant_alternative_exhausted(ctx)) {
 3855|       |                     // Over-nested input is not a failure of the alternative set; keep saying so.
 3856|       |                     ctx.error = error_code::no_matching_variant_type;
 3857|       |                  }
 3858|  5.68k|               }
 3859|       |            }
 3860|       |            else {
 3861|       |               ctx.error = error_code::no_matching_variant_type;
 3862|       |            }
 3863|  16.7k|         }
 3864|  16.7k|      }
_ZZN3glz28process_variant_alternativesINSt3__17variantIJDndNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEbNS1_6vectorINS_12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEENS6_ISD_EEEENSC_ISD_EEEEENS_16is_variant_arrayEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSH_TkNS_10is_contextERNS_7contextERPKcSQ_EEvOT0_OT1_OT2_T3_ENKUlTnmvE_clILm0EEEDav:
 3794|  16.7k|               for_each<N>([&]<size_t I>() {
 3795|  16.7k|                  if (found_match || exhausted || variant_alternative_exhausted(ctx)) {
  ------------------
  |  Branch (3795:23): [True: 0, False: 16.7k]
  |  Branch (3795:38): [True: 0, False: 16.7k]
  |  Branch (3795:51): [True: 0, False: 16.7k]
  ------------------
 3796|      0|                     return;
 3797|      0|                  }
 3798|  16.7k|                  using V = std::variant_alternative_t<I, Variant>;
 3799|       |                  if constexpr (Trait<V>::value && !glaze_const_value_t<V>) {
 3800|       |                     auto copy_it{it};
 3801|       |                     const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above
 3802|       |                     if (!std::holds_alternative<V>(value)) {
 3803|       |                        value = V{};
 3804|       |                     }
 3805|       |                     parse<JSON>::op<ws_handled<Options>()>(std::get<V>(value), ctx, it, end);
 3806|       |                     if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) {
 3807|       |                        exhausted = true; // only rejected attempts are charged; see charge_speculation
 3808|       |                     }
 3809|       |                     if (!bool(ctx.error)) {
 3810|       |                        found_match = true;
 3811|       |                     }
 3812|       |                     else if constexpr (not Options.null_terminated) {
 3813|       |                        constexpr bool is_complete_type =
 3814|       |                           num_t<V> || bool_t<V> || string_t<V> || std::is_enum_v<V> || tuple_t<V> || is_std_tuple<V>;
 3815|       |
 3816|       |                        if constexpr (is_complete_type) {
 3817|       |                           if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) {
 3818|       |                              found_match = true;
 3819|       |                              ctx.error = error_code::none;
 3820|       |                           }
 3821|       |                           else {
 3822|       |                              it = copy_it;
 3823|       |                              rewind_depth<Options>(ctx, copy_depth);
 3824|       |                              if (non_const_idx + 1 < non_const_count && not exhausted &&
 3825|       |                                  not variant_alternative_exhausted(ctx)) {
 3826|       |                                 ctx.error = error_code::none;
 3827|       |                              }
 3828|       |                           }
 3829|       |                        }
 3830|       |                        else {
 3831|       |                           it = copy_it;
 3832|       |                           rewind_depth<Options>(ctx, copy_depth);
 3833|       |                           if (non_const_idx + 1 < non_const_count && not exhausted &&
 3834|       |                               not variant_alternative_exhausted(ctx)) {
 3835|       |                              ctx.error = error_code::none;
 3836|       |                           }
 3837|       |                        }
 3838|       |                     }
 3839|       |                     else {
 3840|       |                        it = copy_it;
 3841|       |                        rewind_depth<Options>(ctx, copy_depth);
 3842|       |                        if (non_const_idx + 1 < non_const_count && not exhausted &&
 3843|       |                            not variant_alternative_exhausted(ctx)) {
 3844|       |                           ctx.error = error_code::none;
 3845|       |                        }
 3846|       |                     }
 3847|       |                     ++non_const_idx;
 3848|       |                  }
 3849|  16.7k|               });
_ZZN3glz28process_variant_alternativesINSt3__17variantIJDndNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEbNS1_6vectorINS_12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEENS6_ISD_EEEENSC_ISD_EEEEENS_16is_variant_arrayEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSH_TkNS_10is_contextERNS_7contextERPKcSQ_EEvOT0_OT1_OT2_T3_ENKUlTnmvE_clILm1EEEDav:
 3794|  16.7k|               for_each<N>([&]<size_t I>() {
 3795|  16.7k|                  if (found_match || exhausted || variant_alternative_exhausted(ctx)) {
  ------------------
  |  Branch (3795:23): [True: 0, False: 16.7k]
  |  Branch (3795:38): [True: 0, False: 16.7k]
  |  Branch (3795:51): [True: 0, False: 16.7k]
  ------------------
 3796|      0|                     return;
 3797|      0|                  }
 3798|  16.7k|                  using V = std::variant_alternative_t<I, Variant>;
 3799|       |                  if constexpr (Trait<V>::value && !glaze_const_value_t<V>) {
 3800|       |                     auto copy_it{it};
 3801|       |                     const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above
 3802|       |                     if (!std::holds_alternative<V>(value)) {
 3803|       |                        value = V{};
 3804|       |                     }
 3805|       |                     parse<JSON>::op<ws_handled<Options>()>(std::get<V>(value), ctx, it, end);
 3806|       |                     if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) {
 3807|       |                        exhausted = true; // only rejected attempts are charged; see charge_speculation
 3808|       |                     }
 3809|       |                     if (!bool(ctx.error)) {
 3810|       |                        found_match = true;
 3811|       |                     }
 3812|       |                     else if constexpr (not Options.null_terminated) {
 3813|       |                        constexpr bool is_complete_type =
 3814|       |                           num_t<V> || bool_t<V> || string_t<V> || std::is_enum_v<V> || tuple_t<V> || is_std_tuple<V>;
 3815|       |
 3816|       |                        if constexpr (is_complete_type) {
 3817|       |                           if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) {
 3818|       |                              found_match = true;
 3819|       |                              ctx.error = error_code::none;
 3820|       |                           }
 3821|       |                           else {
 3822|       |                              it = copy_it;
 3823|       |                              rewind_depth<Options>(ctx, copy_depth);
 3824|       |                              if (non_const_idx + 1 < non_const_count && not exhausted &&
 3825|       |                                  not variant_alternative_exhausted(ctx)) {
 3826|       |                                 ctx.error = error_code::none;
 3827|       |                              }
 3828|       |                           }
 3829|       |                        }
 3830|       |                        else {
 3831|       |                           it = copy_it;
 3832|       |                           rewind_depth<Options>(ctx, copy_depth);
 3833|       |                           if (non_const_idx + 1 < non_const_count && not exhausted &&
 3834|       |                               not variant_alternative_exhausted(ctx)) {
 3835|       |                              ctx.error = error_code::none;
 3836|       |                           }
 3837|       |                        }
 3838|       |                     }
 3839|       |                     else {
 3840|       |                        it = copy_it;
 3841|       |                        rewind_depth<Options>(ctx, copy_depth);
 3842|       |                        if (non_const_idx + 1 < non_const_count && not exhausted &&
 3843|       |                            not variant_alternative_exhausted(ctx)) {
 3844|       |                           ctx.error = error_code::none;
 3845|       |                        }
 3846|       |                     }
 3847|       |                     ++non_const_idx;
 3848|       |                  }
 3849|  16.7k|               });
_ZZN3glz28process_variant_alternativesINSt3__17variantIJDndNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEbNS1_6vectorINS_12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEENS6_ISD_EEEENSC_ISD_EEEEENS_16is_variant_arrayEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSH_TkNS_10is_contextERNS_7contextERPKcSQ_EEvOT0_OT1_OT2_T3_ENKUlTnmvE_clILm2EEEDav:
 3794|  16.7k|               for_each<N>([&]<size_t I>() {
 3795|  16.7k|                  if (found_match || exhausted || variant_alternative_exhausted(ctx)) {
  ------------------
  |  Branch (3795:23): [True: 0, False: 16.7k]
  |  Branch (3795:38): [True: 0, False: 16.7k]
  |  Branch (3795:51): [True: 0, False: 16.7k]
  ------------------
 3796|      0|                     return;
 3797|      0|                  }
 3798|  16.7k|                  using V = std::variant_alternative_t<I, Variant>;
 3799|       |                  if constexpr (Trait<V>::value && !glaze_const_value_t<V>) {
 3800|       |                     auto copy_it{it};
 3801|       |                     const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above
 3802|       |                     if (!std::holds_alternative<V>(value)) {
 3803|       |                        value = V{};
 3804|       |                     }
 3805|       |                     parse<JSON>::op<ws_handled<Options>()>(std::get<V>(value), ctx, it, end);
 3806|       |                     if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) {
 3807|       |                        exhausted = true; // only rejected attempts are charged; see charge_speculation
 3808|       |                     }
 3809|       |                     if (!bool(ctx.error)) {
 3810|       |                        found_match = true;
 3811|       |                     }
 3812|       |                     else if constexpr (not Options.null_terminated) {
 3813|       |                        constexpr bool is_complete_type =
 3814|       |                           num_t<V> || bool_t<V> || string_t<V> || std::is_enum_v<V> || tuple_t<V> || is_std_tuple<V>;
 3815|       |
 3816|       |                        if constexpr (is_complete_type) {
 3817|       |                           if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) {
 3818|       |                              found_match = true;
 3819|       |                              ctx.error = error_code::none;
 3820|       |                           }
 3821|       |                           else {
 3822|       |                              it = copy_it;
 3823|       |                              rewind_depth<Options>(ctx, copy_depth);
 3824|       |                              if (non_const_idx + 1 < non_const_count && not exhausted &&
 3825|       |                                  not variant_alternative_exhausted(ctx)) {
 3826|       |                                 ctx.error = error_code::none;
 3827|       |                              }
 3828|       |                           }
 3829|       |                        }
 3830|       |                        else {
 3831|       |                           it = copy_it;
 3832|       |                           rewind_depth<Options>(ctx, copy_depth);
 3833|       |                           if (non_const_idx + 1 < non_const_count && not exhausted &&
 3834|       |                               not variant_alternative_exhausted(ctx)) {
 3835|       |                              ctx.error = error_code::none;
 3836|       |                           }
 3837|       |                        }
 3838|       |                     }
 3839|       |                     else {
 3840|       |                        it = copy_it;
 3841|       |                        rewind_depth<Options>(ctx, copy_depth);
 3842|       |                        if (non_const_idx + 1 < non_const_count && not exhausted &&
 3843|       |                            not variant_alternative_exhausted(ctx)) {
 3844|       |                           ctx.error = error_code::none;
 3845|       |                        }
 3846|       |                     }
 3847|       |                     ++non_const_idx;
 3848|       |                  }
 3849|  16.7k|               });
_ZZN3glz28process_variant_alternativesINSt3__17variantIJDndNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEbNS1_6vectorINS_12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEENS6_ISD_EEEENSC_ISD_EEEEENS_16is_variant_arrayEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSH_TkNS_10is_contextERNS_7contextERPKcSQ_EEvOT0_OT1_OT2_T3_ENKUlTnmvE_clILm3EEEDav:
 3794|  16.7k|               for_each<N>([&]<size_t I>() {
 3795|  16.7k|                  if (found_match || exhausted || variant_alternative_exhausted(ctx)) {
  ------------------
  |  Branch (3795:23): [True: 0, False: 16.7k]
  |  Branch (3795:38): [True: 0, False: 16.7k]
  |  Branch (3795:51): [True: 0, False: 16.7k]
  ------------------
 3796|      0|                     return;
 3797|      0|                  }
 3798|  16.7k|                  using V = std::variant_alternative_t<I, Variant>;
 3799|       |                  if constexpr (Trait<V>::value && !glaze_const_value_t<V>) {
 3800|       |                     auto copy_it{it};
 3801|       |                     const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above
 3802|       |                     if (!std::holds_alternative<V>(value)) {
 3803|       |                        value = V{};
 3804|       |                     }
 3805|       |                     parse<JSON>::op<ws_handled<Options>()>(std::get<V>(value), ctx, it, end);
 3806|       |                     if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) {
 3807|       |                        exhausted = true; // only rejected attempts are charged; see charge_speculation
 3808|       |                     }
 3809|       |                     if (!bool(ctx.error)) {
 3810|       |                        found_match = true;
 3811|       |                     }
 3812|       |                     else if constexpr (not Options.null_terminated) {
 3813|       |                        constexpr bool is_complete_type =
 3814|       |                           num_t<V> || bool_t<V> || string_t<V> || std::is_enum_v<V> || tuple_t<V> || is_std_tuple<V>;
 3815|       |
 3816|       |                        if constexpr (is_complete_type) {
 3817|       |                           if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) {
 3818|       |                              found_match = true;
 3819|       |                              ctx.error = error_code::none;
 3820|       |                           }
 3821|       |                           else {
 3822|       |                              it = copy_it;
 3823|       |                              rewind_depth<Options>(ctx, copy_depth);
 3824|       |                              if (non_const_idx + 1 < non_const_count && not exhausted &&
 3825|       |                                  not variant_alternative_exhausted(ctx)) {
 3826|       |                                 ctx.error = error_code::none;
 3827|       |                              }
 3828|       |                           }
 3829|       |                        }
 3830|       |                        else {
 3831|       |                           it = copy_it;
 3832|       |                           rewind_depth<Options>(ctx, copy_depth);
 3833|       |                           if (non_const_idx + 1 < non_const_count && not exhausted &&
 3834|       |                               not variant_alternative_exhausted(ctx)) {
 3835|       |                              ctx.error = error_code::none;
 3836|       |                           }
 3837|       |                        }
 3838|       |                     }
 3839|       |                     else {
 3840|       |                        it = copy_it;
 3841|       |                        rewind_depth<Options>(ctx, copy_depth);
 3842|       |                        if (non_const_idx + 1 < non_const_count && not exhausted &&
 3843|       |                            not variant_alternative_exhausted(ctx)) {
 3844|       |                           ctx.error = error_code::none;
 3845|       |                        }
 3846|       |                     }
 3847|       |                     ++non_const_idx;
 3848|       |                  }
 3849|  16.7k|               });
_ZZN3glz28process_variant_alternativesINSt3__17variantIJDndNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEbNS1_6vectorINS_12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEENS6_ISD_EEEENSC_ISD_EEEEENS_16is_variant_arrayEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSH_TkNS_10is_contextERNS_7contextERPKcSQ_EEvOT0_OT1_OT2_T3_ENKUlTnmvE_clILm4EEEDav:
 3794|  16.7k|               for_each<N>([&]<size_t I>() {
 3795|  16.7k|                  if (found_match || exhausted || variant_alternative_exhausted(ctx)) {
  ------------------
  |  Branch (3795:23): [True: 0, False: 16.7k]
  |  Branch (3795:38): [True: 0, False: 16.7k]
  |  Branch (3795:51): [True: 0, False: 16.7k]
  ------------------
 3796|      0|                     return;
 3797|      0|                  }
 3798|  16.7k|                  using V = std::variant_alternative_t<I, Variant>;
 3799|  16.7k|                  if constexpr (Trait<V>::value && !glaze_const_value_t<V>) {
 3800|  16.7k|                     auto copy_it{it};
 3801|  16.7k|                     const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above
 3802|  16.7k|                     if (!std::holds_alternative<V>(value)) {
  ------------------
  |  Branch (3802:26): [True: 16.7k, False: 0]
  ------------------
 3803|  16.7k|                        value = V{};
 3804|  16.7k|                     }
 3805|  16.7k|                     parse<JSON>::op<ws_handled<Options>()>(std::get<V>(value), ctx, it, end);
 3806|  16.7k|                     if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) {
  ------------------
  |  Branch (3806:26): [True: 5.68k, False: 11.0k]
  |  Branch (3806:45): [True: 0, False: 5.68k]
  ------------------
 3807|      0|                        exhausted = true; // only rejected attempts are charged; see charge_speculation
 3808|      0|                     }
 3809|  16.7k|                     if (!bool(ctx.error)) {
  ------------------
  |  Branch (3809:26): [True: 11.0k, False: 5.68k]
  ------------------
 3810|  11.0k|                        found_match = true;
 3811|  11.0k|                     }
 3812|  5.68k|                     else if constexpr (not Options.null_terminated) {
 3813|  5.68k|                        constexpr bool is_complete_type =
 3814|  5.68k|                           num_t<V> || bool_t<V> || string_t<V> || std::is_enum_v<V> || tuple_t<V> || is_std_tuple<V>;
  ------------------
  |  Branch (3814:28): [Folded, False: 0]
  |  Branch (3814:40): [Folded, False: 0]
  |  Branch (3814:53): [Folded, False: 0]
  |  Branch (3814:68): [Folded, False: 0]
  |  Branch (3814:89): [Folded, False: 0]
  |  Branch (3814:103): [Folded, False: 0]
  ------------------
 3815|       |
 3816|       |                        if constexpr (is_complete_type) {
 3817|       |                           if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) {
 3818|       |                              found_match = true;
 3819|       |                              ctx.error = error_code::none;
 3820|       |                           }
 3821|       |                           else {
 3822|       |                              it = copy_it;
 3823|       |                              rewind_depth<Options>(ctx, copy_depth);
 3824|       |                              if (non_const_idx + 1 < non_const_count && not exhausted &&
 3825|       |                                  not variant_alternative_exhausted(ctx)) {
 3826|       |                                 ctx.error = error_code::none;
 3827|       |                              }
 3828|       |                           }
 3829|       |                        }
 3830|  5.68k|                        else {
 3831|  5.68k|                           it = copy_it;
 3832|  5.68k|                           rewind_depth<Options>(ctx, copy_depth);
 3833|  5.68k|                           if (non_const_idx + 1 < non_const_count && not exhausted &&
  ------------------
  |  Branch (3833:32): [True: 0, False: 5.68k]
  |  Branch (3833:71): [True: 0, False: 0]
  ------------------
 3834|      0|                               not variant_alternative_exhausted(ctx)) {
  ------------------
  |  Branch (3834:32): [True: 0, False: 0]
  ------------------
 3835|      0|                              ctx.error = error_code::none;
 3836|      0|                           }
 3837|  5.68k|                        }
 3838|       |                     }
 3839|       |                     else {
 3840|       |                        it = copy_it;
 3841|       |                        rewind_depth<Options>(ctx, copy_depth);
 3842|       |                        if (non_const_idx + 1 < non_const_count && not exhausted &&
 3843|       |                            not variant_alternative_exhausted(ctx)) {
 3844|       |                           ctx.error = error_code::none;
 3845|       |                        }
 3846|       |                     }
 3847|  16.7k|                     ++non_const_idx;
 3848|  16.7k|                  }
 3849|  16.7k|               });
_ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEERNSt3__16vectorINS_12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEENS4_9allocatorIS9_EEEETkNS_10is_contextERNS_7contextERPKcSH_EEvOT0_OT1_OT2_T3_:
   49|  16.7k|      {
   50|       |         if constexpr (const_value_v<T>) {
   51|       |            if constexpr (check_error_on_const_read(Opts)) {
   52|       |               ctx.error = error_code::attempt_const_read;
   53|       |            }
   54|       |            else {
   55|       |               // do not read anything into the const value
   56|       |               skip_value<JSON>::op<Opts>(std::forward<Ctx>(ctx), std::forward<It0>(it), end);
   57|       |            }
   58|       |         }
   59|  16.7k|         else {
   60|  16.7k|            using V = std::remove_cvref_t<T>;
   61|  16.7k|            from<JSON, V>::template op<Opts>(std::forward<T>(value), std::forward<Ctx>(ctx), std::forward<It0>(it),
   62|  16.7k|                                             end);
   63|  16.7k|         }
   64|  16.7k|      }
_ZN3glz4fromILj10ENSt3__16vectorINS_12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEENS1_9allocatorIS6_EEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEERS9_TkNS_10is_contextERNS_7contextERPKcSH_EEvOT0_OT1_OT2_T3_:
 2308|  16.7k|      {
 2309|  16.7k|         constexpr auto Opts = ws_handled_off<Options>();
 2310|       |         if constexpr (!check_ws_handled(Options)) {
 2311|       |            if (skip_ws<Opts>(ctx, it, end)) {
 2312|       |               return;
 2313|       |            }
 2314|       |         }
 2315|       |
 2316|  16.7k|         if (match_invalid_end<'[', Opts>(ctx, it, end)) {
  ------------------
  |  Branch (2316:14): [True: 0, False: 16.7k]
  ------------------
 2317|      0|            return;
 2318|      0|         }
 2319|       |         // one nesting level (see enter_depth): counted in both modes so the limit binds,
 2320|       |         // released at each syntactic close below
 2321|  16.7k|         if (enter_depth(ctx)) [[unlikely]] {
  ------------------
  |  Branch (2321:14): [True: 0, False: 16.7k]
  ------------------
 2322|      0|            return;
 2323|      0|         }
 2324|       |
 2325|  16.7k|         const auto ws_start = it;
 2326|  16.7k|         if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (2326:14): [True: 0, False: 16.7k]
  ------------------
 2327|      0|            return;
 2328|      0|         }
 2329|       |
 2330|  16.7k|         if (*it == ']') {
  ------------------
  |  Branch (2330:14): [True: 190, False: 16.5k]
  ------------------
 2331|    190|            --ctx.depth;
 2332|    190|            ++it;
 2333|    190|            if constexpr ((resizable<T> || is_inplace_vector<T>) && not check_append_arrays(Opts)) {
 2334|    190|               value.clear();
 2335|       |
 2336|       |               if constexpr (check_shrink_to_fit(Opts) && has_shrink_to_fit<T>) {
 2337|       |                  value.shrink_to_fit();
 2338|       |               }
 2339|    190|            }
 2340|    190|            return;
 2341|    190|         }
 2342|       |
 2343|  16.5k|         const size_t ws_size = size_t(it - ws_start);
 2344|       |
 2345|  16.5k|         static constexpr bool should_append = (resizable<T> || is_inplace_vector<T>) && check_append_arrays(Opts);
  ------------------
  |  Branch (2345:49): [True: 16.5k, Folded]
  |  Branch (2345:65): [Folded, False: 0]
  |  Branch (2345:90): [Folded, False: 0]
  ------------------
 2346|  16.5k|         if constexpr (not should_append) {
 2347|  16.5k|            const auto n = value.size();
 2348|       |
 2349|  16.5k|            auto value_it = value.begin();
 2350|       |
 2351|  16.5k|            for (size_t i = 0; i < n; ++i) {
  ------------------
  |  Branch (2351:32): [True: 0, False: 16.5k]
  ------------------
 2352|      0|               parse<JSON>::op<ws_handled<Opts>()>(*value_it++, ctx, it, end);
 2353|      0|               if (bool(ctx.error)) [[unlikely]]
  ------------------
  |  Branch (2353:20): [True: 0, False: 0]
  ------------------
 2354|      0|                  return;
 2355|      0|               if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (2355:20): [True: 0, False: 0]
  ------------------
 2356|      0|                  return;
 2357|      0|               }
 2358|      0|               if (*it == ',') {
  ------------------
  |  Branch (2358:20): [True: 0, False: 0]
  ------------------
 2359|      0|                  ++it;
 2360|       |
 2361|      0|                  if constexpr (!Opts.minified && !Opts.comments) {
 2362|      0|                     if (ws_size && ws_size < size_t(end - it)) {
  ------------------
  |  Branch (2362:26): [True: 0, False: 0]
  |  Branch (2362:37): [True: 0, False: 0]
  ------------------
 2363|      0|                        skip_matching_ws(ws_start, it, ws_size);
 2364|      0|                     }
 2365|      0|                  }
 2366|       |
 2367|      0|                  if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (2367:23): [True: 0, False: 0]
  ------------------
 2368|      0|                     return;
 2369|      0|                  }
 2370|      0|               }
 2371|      0|               else if (*it == ']') {
  ------------------
  |  Branch (2371:25): [True: 0, False: 0]
  ------------------
 2372|      0|                  --ctx.depth;
 2373|      0|                  ++it;
 2374|      0|                  if constexpr (erasable<T>) {
 2375|      0|                     value.erase(value_it,
 2376|      0|                                 value.end()); // use erase rather than resize for non-default constructible elements
 2377|       |
 2378|       |                     if constexpr (check_shrink_to_fit(Opts) && has_shrink_to_fit<T>) {
 2379|       |                        value.shrink_to_fit();
 2380|       |                     }
 2381|      0|                  }
 2382|      0|                  return;
 2383|      0|               }
 2384|      0|               else [[unlikely]] {
 2385|      0|                  ctx.error = error_code::expected_bracket;
 2386|      0|                  return;
 2387|      0|               }
 2388|      0|            }
 2389|  16.5k|         }
 2390|       |
 2391|       |         if constexpr (Opts.partial_read) {
 2392|       |            // partial_read stops early on a success path, so give the level back like the
 2393|       |            // syntactic-close paths do; otherwise it accumulates across reads sharing a context.
 2394|       |            --ctx.depth;
 2395|       |            return;
 2396|       |         }
 2397|  16.5k|         else {
 2398|       |            // growing
 2399|  16.5k|            if constexpr (emplace_backable<T> || has_try_emplace_back<T>) {
 2400|   216k|               while (it < end) {
  ------------------
  |  Branch (2400:23): [True: 216k, False: 0]
  ------------------
 2401|       |                  // Streaming refill point: at start of each iteration, ensure buffer has data
 2402|       |                  if constexpr (has_streaming_state<decltype(ctx)>) {
 2403|       |                     if (ctx.stream.enabled()) {
 2404|       |                        const size_t consumed = static_cast<size_t>(it - ctx.stream.data());
 2405|       |                        const size_t remaining = ctx.stream.size() - consumed;
 2406|       |                        // Refill when less than half of buffer remains to ensure space for next element
 2407|       |                        if (remaining <= ctx.stream.size() / 2 || it >= end) {
 2408|       |                           const char* new_it;
 2409|       |                           const char* new_end;
 2410|       |                           ctx.stream.consume_and_refill(consumed, new_it, new_end);
 2411|       |                           it = new_it;
 2412|       |                           end = new_end;
 2413|       |                           if (it >= end && ctx.stream.at_eof()) {
 2414|       |                              break; // No more data, exit loop normally
 2415|       |                           }
 2416|       |                        }
 2417|       |                     }
 2418|       |                  }
 2419|       |
 2420|       |                  if constexpr (has_try_emplace_back<T>) {
 2421|       |                     if (value.try_emplace_back())
 2422|       |                        parse<JSON>::op<ws_handled<Opts>()>(value.back(), ctx, it, end);
 2423|       |                     else
 2424|       |                        ctx.error = error_code::exceeded_static_array_size;
 2425|       |                  }
 2426|   216k|                  else {
 2427|   216k|                     parse<JSON>::op<ws_handled<Opts>()>(value.emplace_back(), ctx, it, end);
 2428|   216k|                  }
 2429|       |
 2430|   216k|                  if (bool(ctx.error)) [[unlikely]]
  ------------------
  |  Branch (2430:23): [True: 5.68k, False: 210k]
  ------------------
 2431|  5.68k|                     return;
 2432|       |
 2433|       |                  // Streaming refill point: after parsing each element, refill if buffer is low
 2434|       |                  if constexpr (has_streaming_state<decltype(ctx)>) {
 2435|       |                     if (ctx.stream.enabled()) {
 2436|       |                        const size_t consumed = static_cast<size_t>(it - ctx.stream.data());
 2437|       |                        // Refill when less than 25% of buffer remains to ensure enough space for next element
 2438|       |                        if (ctx.stream.size() - consumed <= ctx.stream.size() / 4 || it >= end) {
 2439|       |                           const char* new_it;
 2440|       |                           const char* new_end;
 2441|       |                           ctx.stream.consume_and_refill(consumed, new_it, new_end);
 2442|       |                           it = new_it;
 2443|       |                           end = new_end;
 2444|       |                           if (it >= end && ctx.stream.at_eof()) {
 2445|       |                              ctx.error = error_code::unexpected_end;
 2446|       |                              return;
 2447|       |                           }
 2448|       |                        }
 2449|       |                     }
 2450|       |                  }
 2451|       |
 2452|   210k|                  if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (2452:23): [True: 0, False: 210k]
  ------------------
 2453|      0|                     return;
 2454|      0|                  }
 2455|   210k|                  if (*it == ',') [[likely]] {
  ------------------
  |  Branch (2455:23): [True: 199k, False: 10.8k]
  ------------------
 2456|   199k|                     ++it;
 2457|       |
 2458|   199k|                     if constexpr (!Opts.minified && !Opts.comments) {
 2459|   199k|                        if (ws_size && ws_size < size_t(end - it)) {
  ------------------
  |  Branch (2459:29): [True: 0, False: 199k]
  |  Branch (2459:40): [True: 0, False: 0]
  ------------------
 2460|      0|                           skip_matching_ws(ws_start, it, ws_size);
 2461|      0|                        }
 2462|   199k|                     }
 2463|       |
 2464|   199k|                     if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (2464:26): [True: 0, False: 199k]
  ------------------
 2465|      0|                        return;
 2466|      0|                     }
 2467|   199k|                  }
 2468|  10.8k|                  else if (*it == ']') {
  ------------------
  |  Branch (2468:28): [True: 10.8k, False: 0]
  ------------------
 2469|  10.8k|                     --ctx.depth;
 2470|  10.8k|                     ++it;
 2471|       |                     if constexpr (check_shrink_to_fit(Opts) && has_shrink_to_fit<T>) {
 2472|       |                        value.shrink_to_fit();
 2473|       |                     }
 2474|  10.8k|                     return;
 2475|  10.8k|                  }
 2476|      0|                  else [[unlikely]] {
 2477|      0|                     ctx.error = error_code::expected_bracket;
 2478|      0|                     return;
 2479|      0|                  }
 2480|   210k|               }
 2481|       |
 2482|       |               // A valid array always returns from inside the loop upon reaching ']'.
 2483|       |               // For a null-terminated buffer the loop can only exit here by falling
 2484|       |               // through when `it` reaches the terminator without a closing bracket,
 2485|       |               // which means the input was truncated (e.g. "[", "[1," or "[1,2,").
 2486|       |               // Non-null-terminated buffers surface this through skip_ws/depth
 2487|       |               // tracking (or the streaming refill break), so this guard is limited
 2488|       |               // to the null-terminated case.
 2489|       |               if constexpr (Opts.null_terminated) {
 2490|       |                  ctx.error = error_code::unexpected_end;
 2491|       |               }
 2492|       |            }
 2493|       |            else {
 2494|       |               ctx.error = error_code::exceeded_static_array_size;
 2495|       |            }
 2496|  16.5k|         }
 2497|  16.5k|      }
_ZZN3glz28process_variant_alternativesINSt3__17variantIJDndNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEbNS1_6vectorINS_12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEENS6_ISD_EEEENSC_ISD_EEEEENS_16is_variant_arrayEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSH_TkNS_10is_contextERNS_7contextERPKcSQ_EEvOT0_OT1_OT2_T3_ENKUlTnmvE_clILm5EEEDav:
 3794|  16.7k|               for_each<N>([&]<size_t I>() {
 3795|  16.7k|                  if (found_match || exhausted || variant_alternative_exhausted(ctx)) {
  ------------------
  |  Branch (3795:23): [True: 11.0k, False: 5.68k]
  |  Branch (3795:38): [True: 0, False: 5.68k]
  |  Branch (3795:51): [True: 0, False: 5.68k]
  ------------------
 3796|  11.0k|                     return;
 3797|  11.0k|                  }
 3798|  5.68k|                  using V = std::variant_alternative_t<I, Variant>;
 3799|       |                  if constexpr (Trait<V>::value && !glaze_const_value_t<V>) {
 3800|       |                     auto copy_it{it};
 3801|       |                     const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above
 3802|       |                     if (!std::holds_alternative<V>(value)) {
 3803|       |                        value = V{};
 3804|       |                     }
 3805|       |                     parse<JSON>::op<ws_handled<Options>()>(std::get<V>(value), ctx, it, end);
 3806|       |                     if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) {
 3807|       |                        exhausted = true; // only rejected attempts are charged; see charge_speculation
 3808|       |                     }
 3809|       |                     if (!bool(ctx.error)) {
 3810|       |                        found_match = true;
 3811|       |                     }
 3812|       |                     else if constexpr (not Options.null_terminated) {
 3813|       |                        constexpr bool is_complete_type =
 3814|       |                           num_t<V> || bool_t<V> || string_t<V> || std::is_enum_v<V> || tuple_t<V> || is_std_tuple<V>;
 3815|       |
 3816|       |                        if constexpr (is_complete_type) {
 3817|       |                           if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) {
 3818|       |                              found_match = true;
 3819|       |                              ctx.error = error_code::none;
 3820|       |                           }
 3821|       |                           else {
 3822|       |                              it = copy_it;
 3823|       |                              rewind_depth<Options>(ctx, copy_depth);
 3824|       |                              if (non_const_idx + 1 < non_const_count && not exhausted &&
 3825|       |                                  not variant_alternative_exhausted(ctx)) {
 3826|       |                                 ctx.error = error_code::none;
 3827|       |                              }
 3828|       |                           }
 3829|       |                        }
 3830|       |                        else {
 3831|       |                           it = copy_it;
 3832|       |                           rewind_depth<Options>(ctx, copy_depth);
 3833|       |                           if (non_const_idx + 1 < non_const_count && not exhausted &&
 3834|       |                               not variant_alternative_exhausted(ctx)) {
 3835|       |                              ctx.error = error_code::none;
 3836|       |                           }
 3837|       |                        }
 3838|       |                     }
 3839|       |                     else {
 3840|       |                        it = copy_it;
 3841|       |                        rewind_depth<Options>(ctx, copy_depth);
 3842|       |                        if (non_const_idx + 1 < non_const_count && not exhausted &&
 3843|       |                            not variant_alternative_exhausted(ctx)) {
 3844|       |                           ctx.error = error_code::none;
 3845|       |                        }
 3846|       |                     }
 3847|       |                     ++non_const_idx;
 3848|       |                  }
 3849|  5.68k|               });
_ZN3glz28process_variant_alternativesINSt3__17variantIJDndNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEbNS1_6vectorINS_12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEENS6_ISD_EEEENSC_ISD_EEEEENS_14is_variant_strEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSH_TkNS_10is_contextERNS_7contextERPKcSQ_EEvOT0_OT1_OT2_T3_:
 3725|   759k|      {
 3726|   759k|         constexpr auto category_count = variant_count_v<Variant, Trait>;
 3727|       |
 3728|       |         if constexpr (category_count == 0) {
 3729|       |            ctx.error = error_code::no_matching_variant_type;
 3730|       |         }
 3731|   759k|         else {
 3732|   759k|            constexpr auto N = std::variant_size_v<Variant>;
 3733|   759k|            constexpr auto const_count = variant_filtered_count_v<Variant, Trait, true>;
 3734|   759k|            constexpr auto non_const_count = variant_filtered_count_v<Variant, Trait, false>;
 3735|       |
 3736|   759k|            bool found_match{};
 3737|       |            // Set when the speculative parsing budget runs out; see charge_speculation. An ambiguous
 3738|       |            // nest re-parses the same subtree per alternative at every level, which is exponential,
 3739|       |            // so the budget stops it and the failure already in hand is reported.
 3740|   759k|            bool exhausted{};
 3741|       |
 3742|       |            // First pass: const glaze types in this category
 3743|       |            if constexpr (const_count > 0) {
 3744|       |               for_each<N>([&]<size_t I>() {
 3745|       |                  if (found_match || exhausted || variant_alternative_exhausted(ctx)) {
 3746|       |                     return;
 3747|       |                  }
 3748|       |                  using V = std::variant_alternative_t<I, Variant>;
 3749|       |                  if constexpr (Trait<V>::value && glaze_const_value_t<V>) {
 3750|       |                     // run time substitute to compare to const value
 3751|       |                     std::remove_const_t<std::remove_pointer_t<std::remove_const_t<meta_wrapper_t<V>>>> substitute{};
 3752|       |                     auto copy_it{it};
 3753|       |                     // A rejected alternative may have bailed out inside a container, which leaves its
 3754|       |                     // nesting level counted (see enter_depth). Rewind the depth with the iterator so
 3755|       |                     // trying N alternatives cannot spend N levels of the recursion budget.
 3756|       |                     const auto copy_depth{ctx.depth};
 3757|       |                     parse<JSON>::op<ws_handled<Options>()>(substitute, ctx, it, end);
 3758|       |                     static constexpr auto const_value{*meta_wrapper_v<V>};
 3759|       |                     if (substitute == const_value) {
 3760|       |                        found_match = true;
 3761|       |                        if (!std::holds_alternative<V>(value)) {
 3762|       |                           value = V{};
 3763|       |                        }
 3764|       |                     }
 3765|       |                     else {
 3766|       |                        // Rejected: charge the bytes it parsed before we rewind. See charge_speculation.
 3767|       |                        if (!charge_speculation(ctx, size_t(it - copy_it))) {
 3768|       |                           exhausted = true;
 3769|       |                        }
 3770|       |                        if constexpr (not Options.null_terminated) {
 3771|       |                           if (ctx.error == error_code::end_reached && not exhausted) {
 3772|       |                              ctx.error = error_code::none;
 3773|       |                           }
 3774|       |                        }
 3775|       |                        it = copy_it;
 3776|       |                        rewind_depth<Options>(ctx, copy_depth);
 3777|       |                     }
 3778|       |                  }
 3779|       |               });
 3780|       |               if (found_match) {
 3781|       |                  return;
 3782|       |               }
 3783|       |            }
 3784|       |
 3785|       |            // Second pass: non-const types in this category
 3786|   759k|            if constexpr (non_const_count > 0) {
 3787|       |               // Track position within matching types for "is last" check.
 3788|       |               // We iterate over all variant indices but only process matching types,
 3789|       |               // so we need runtime tracking (vs the old tuple-based approach where
 3790|       |               // the loop index directly corresponded to position in filtered set).
 3791|       |               // This has negligible cost: one increment per matching type.
 3792|   759k|               size_t non_const_idx = 0;
 3793|       |
 3794|   759k|               for_each<N>([&]<size_t I>() {
 3795|   759k|                  if (found_match || exhausted || variant_alternative_exhausted(ctx)) {
 3796|   759k|                     return;
 3797|   759k|                  }
 3798|   759k|                  using V = std::variant_alternative_t<I, Variant>;
 3799|   759k|                  if constexpr (Trait<V>::value && !glaze_const_value_t<V>) {
 3800|   759k|                     auto copy_it{it};
 3801|   759k|                     const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above
 3802|   759k|                     if (!std::holds_alternative<V>(value)) {
 3803|   759k|                        value = V{};
 3804|   759k|                     }
 3805|   759k|                     parse<JSON>::op<ws_handled<Options>()>(std::get<V>(value), ctx, it, end);
 3806|   759k|                     if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) {
 3807|   759k|                        exhausted = true; // only rejected attempts are charged; see charge_speculation
 3808|   759k|                     }
 3809|   759k|                     if (!bool(ctx.error)) {
 3810|   759k|                        found_match = true;
 3811|   759k|                     }
 3812|   759k|                     else if constexpr (not Options.null_terminated) {
 3813|   759k|                        constexpr bool is_complete_type =
 3814|   759k|                           num_t<V> || bool_t<V> || string_t<V> || std::is_enum_v<V> || tuple_t<V> || is_std_tuple<V>;
 3815|       |
 3816|   759k|                        if constexpr (is_complete_type) {
 3817|   759k|                           if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) {
 3818|   759k|                              found_match = true;
 3819|   759k|                              ctx.error = error_code::none;
 3820|   759k|                           }
 3821|   759k|                           else {
 3822|   759k|                              it = copy_it;
 3823|   759k|                              rewind_depth<Options>(ctx, copy_depth);
 3824|   759k|                              if (non_const_idx + 1 < non_const_count && not exhausted &&
 3825|   759k|                                  not variant_alternative_exhausted(ctx)) {
 3826|   759k|                                 ctx.error = error_code::none;
 3827|   759k|                              }
 3828|   759k|                           }
 3829|   759k|                        }
 3830|   759k|                        else {
 3831|   759k|                           it = copy_it;
 3832|   759k|                           rewind_depth<Options>(ctx, copy_depth);
 3833|   759k|                           if (non_const_idx + 1 < non_const_count && not exhausted &&
 3834|   759k|                               not variant_alternative_exhausted(ctx)) {
 3835|   759k|                              ctx.error = error_code::none;
 3836|   759k|                           }
 3837|   759k|                        }
 3838|   759k|                     }
 3839|   759k|                     else {
 3840|   759k|                        it = copy_it;
 3841|   759k|                        rewind_depth<Options>(ctx, copy_depth);
 3842|   759k|                        if (non_const_idx + 1 < non_const_count && not exhausted &&
 3843|   759k|                            not variant_alternative_exhausted(ctx)) {
 3844|   759k|                           ctx.error = error_code::none;
 3845|   759k|                        }
 3846|   759k|                     }
 3847|   759k|                     ++non_const_idx;
 3848|   759k|                  }
 3849|   759k|               });
 3850|   759k|               if (!found_match) {
  ------------------
  |  Branch (3850:20): [True: 22.0k, False: 737k]
  ------------------
 3851|  22.0k|                  if constexpr (non_const_count == 1) {
 3852|       |                     // Keep the specific error from the single type we tried
 3853|       |                  }
 3854|       |                  else if (not exhausted && not variant_alternative_exhausted(ctx)) {
 3855|       |                     // Over-nested input is not a failure of the alternative set; keep saying so.
 3856|       |                     ctx.error = error_code::no_matching_variant_type;
 3857|       |                  }
 3858|  22.0k|               }
 3859|       |            }
 3860|       |            else {
 3861|       |               ctx.error = error_code::no_matching_variant_type;
 3862|       |            }
 3863|   759k|         }
 3864|   759k|      }
_ZZN3glz28process_variant_alternativesINSt3__17variantIJDndNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEbNS1_6vectorINS_12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEENS6_ISD_EEEENSC_ISD_EEEEENS_14is_variant_strEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSH_TkNS_10is_contextERNS_7contextERPKcSQ_EEvOT0_OT1_OT2_T3_ENKUlTnmvE_clILm0EEEDav:
 3794|   759k|               for_each<N>([&]<size_t I>() {
 3795|   759k|                  if (found_match || exhausted || variant_alternative_exhausted(ctx)) {
  ------------------
  |  Branch (3795:23): [True: 0, False: 759k]
  |  Branch (3795:38): [True: 0, False: 759k]
  |  Branch (3795:51): [True: 0, False: 759k]
  ------------------
 3796|      0|                     return;
 3797|      0|                  }
 3798|   759k|                  using V = std::variant_alternative_t<I, Variant>;
 3799|       |                  if constexpr (Trait<V>::value && !glaze_const_value_t<V>) {
 3800|       |                     auto copy_it{it};
 3801|       |                     const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above
 3802|       |                     if (!std::holds_alternative<V>(value)) {
 3803|       |                        value = V{};
 3804|       |                     }
 3805|       |                     parse<JSON>::op<ws_handled<Options>()>(std::get<V>(value), ctx, it, end);
 3806|       |                     if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) {
 3807|       |                        exhausted = true; // only rejected attempts are charged; see charge_speculation
 3808|       |                     }
 3809|       |                     if (!bool(ctx.error)) {
 3810|       |                        found_match = true;
 3811|       |                     }
 3812|       |                     else if constexpr (not Options.null_terminated) {
 3813|       |                        constexpr bool is_complete_type =
 3814|       |                           num_t<V> || bool_t<V> || string_t<V> || std::is_enum_v<V> || tuple_t<V> || is_std_tuple<V>;
 3815|       |
 3816|       |                        if constexpr (is_complete_type) {
 3817|       |                           if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) {
 3818|       |                              found_match = true;
 3819|       |                              ctx.error = error_code::none;
 3820|       |                           }
 3821|       |                           else {
 3822|       |                              it = copy_it;
 3823|       |                              rewind_depth<Options>(ctx, copy_depth);
 3824|       |                              if (non_const_idx + 1 < non_const_count && not exhausted &&
 3825|       |                                  not variant_alternative_exhausted(ctx)) {
 3826|       |                                 ctx.error = error_code::none;
 3827|       |                              }
 3828|       |                           }
 3829|       |                        }
 3830|       |                        else {
 3831|       |                           it = copy_it;
 3832|       |                           rewind_depth<Options>(ctx, copy_depth);
 3833|       |                           if (non_const_idx + 1 < non_const_count && not exhausted &&
 3834|       |                               not variant_alternative_exhausted(ctx)) {
 3835|       |                              ctx.error = error_code::none;
 3836|       |                           }
 3837|       |                        }
 3838|       |                     }
 3839|       |                     else {
 3840|       |                        it = copy_it;
 3841|       |                        rewind_depth<Options>(ctx, copy_depth);
 3842|       |                        if (non_const_idx + 1 < non_const_count && not exhausted &&
 3843|       |                            not variant_alternative_exhausted(ctx)) {
 3844|       |                           ctx.error = error_code::none;
 3845|       |                        }
 3846|       |                     }
 3847|       |                     ++non_const_idx;
 3848|       |                  }
 3849|   759k|               });
_ZZN3glz28process_variant_alternativesINSt3__17variantIJDndNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEbNS1_6vectorINS_12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEENS6_ISD_EEEENSC_ISD_EEEEENS_14is_variant_strEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSH_TkNS_10is_contextERNS_7contextERPKcSQ_EEvOT0_OT1_OT2_T3_ENKUlTnmvE_clILm1EEEDav:
 3794|   759k|               for_each<N>([&]<size_t I>() {
 3795|   759k|                  if (found_match || exhausted || variant_alternative_exhausted(ctx)) {
  ------------------
  |  Branch (3795:23): [True: 0, False: 759k]
  |  Branch (3795:38): [True: 0, False: 759k]
  |  Branch (3795:51): [True: 0, False: 759k]
  ------------------
 3796|      0|                     return;
 3797|      0|                  }
 3798|   759k|                  using V = std::variant_alternative_t<I, Variant>;
 3799|       |                  if constexpr (Trait<V>::value && !glaze_const_value_t<V>) {
 3800|       |                     auto copy_it{it};
 3801|       |                     const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above
 3802|       |                     if (!std::holds_alternative<V>(value)) {
 3803|       |                        value = V{};
 3804|       |                     }
 3805|       |                     parse<JSON>::op<ws_handled<Options>()>(std::get<V>(value), ctx, it, end);
 3806|       |                     if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) {
 3807|       |                        exhausted = true; // only rejected attempts are charged; see charge_speculation
 3808|       |                     }
 3809|       |                     if (!bool(ctx.error)) {
 3810|       |                        found_match = true;
 3811|       |                     }
 3812|       |                     else if constexpr (not Options.null_terminated) {
 3813|       |                        constexpr bool is_complete_type =
 3814|       |                           num_t<V> || bool_t<V> || string_t<V> || std::is_enum_v<V> || tuple_t<V> || is_std_tuple<V>;
 3815|       |
 3816|       |                        if constexpr (is_complete_type) {
 3817|       |                           if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) {
 3818|       |                              found_match = true;
 3819|       |                              ctx.error = error_code::none;
 3820|       |                           }
 3821|       |                           else {
 3822|       |                              it = copy_it;
 3823|       |                              rewind_depth<Options>(ctx, copy_depth);
 3824|       |                              if (non_const_idx + 1 < non_const_count && not exhausted &&
 3825|       |                                  not variant_alternative_exhausted(ctx)) {
 3826|       |                                 ctx.error = error_code::none;
 3827|       |                              }
 3828|       |                           }
 3829|       |                        }
 3830|       |                        else {
 3831|       |                           it = copy_it;
 3832|       |                           rewind_depth<Options>(ctx, copy_depth);
 3833|       |                           if (non_const_idx + 1 < non_const_count && not exhausted &&
 3834|       |                               not variant_alternative_exhausted(ctx)) {
 3835|       |                              ctx.error = error_code::none;
 3836|       |                           }
 3837|       |                        }
 3838|       |                     }
 3839|       |                     else {
 3840|       |                        it = copy_it;
 3841|       |                        rewind_depth<Options>(ctx, copy_depth);
 3842|       |                        if (non_const_idx + 1 < non_const_count && not exhausted &&
 3843|       |                            not variant_alternative_exhausted(ctx)) {
 3844|       |                           ctx.error = error_code::none;
 3845|       |                        }
 3846|       |                     }
 3847|       |                     ++non_const_idx;
 3848|       |                  }
 3849|   759k|               });
_ZZN3glz28process_variant_alternativesINSt3__17variantIJDndNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEbNS1_6vectorINS_12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEENS6_ISD_EEEENSC_ISD_EEEEENS_14is_variant_strEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSH_TkNS_10is_contextERNS_7contextERPKcSQ_EEvOT0_OT1_OT2_T3_ENKUlTnmvE_clILm2EEEDav:
 3794|   759k|               for_each<N>([&]<size_t I>() {
 3795|   759k|                  if (found_match || exhausted || variant_alternative_exhausted(ctx)) {
  ------------------
  |  Branch (3795:23): [True: 0, False: 759k]
  |  Branch (3795:38): [True: 0, False: 759k]
  |  Branch (3795:51): [True: 0, False: 759k]
  ------------------
 3796|      0|                     return;
 3797|      0|                  }
 3798|   759k|                  using V = std::variant_alternative_t<I, Variant>;
 3799|   759k|                  if constexpr (Trait<V>::value && !glaze_const_value_t<V>) {
 3800|   759k|                     auto copy_it{it};
 3801|   759k|                     const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above
 3802|   759k|                     if (!std::holds_alternative<V>(value)) {
  ------------------
  |  Branch (3802:26): [True: 759k, False: 0]
  ------------------
 3803|   759k|                        value = V{};
 3804|   759k|                     }
 3805|   759k|                     parse<JSON>::op<ws_handled<Options>()>(std::get<V>(value), ctx, it, end);
 3806|   759k|                     if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) {
  ------------------
  |  Branch (3806:26): [True: 22.0k, False: 737k]
  |  Branch (3806:45): [True: 0, False: 22.0k]
  ------------------
 3807|      0|                        exhausted = true; // only rejected attempts are charged; see charge_speculation
 3808|      0|                     }
 3809|   759k|                     if (!bool(ctx.error)) {
  ------------------
  |  Branch (3809:26): [True: 737k, False: 22.0k]
  ------------------
 3810|   737k|                        found_match = true;
 3811|   737k|                     }
 3812|  22.0k|                     else if constexpr (not Options.null_terminated) {
 3813|  22.0k|                        constexpr bool is_complete_type =
 3814|  22.0k|                           num_t<V> || bool_t<V> || string_t<V> || std::is_enum_v<V> || tuple_t<V> || is_std_tuple<V>;
  ------------------
  |  Branch (3814:28): [Folded, False: 0]
  |  Branch (3814:40): [Folded, False: 0]
  |  Branch (3814:53): [True: 0, Folded]
  |  Branch (3814:68): [Folded, False: 0]
  |  Branch (3814:89): [Folded, False: 0]
  |  Branch (3814:103): [Folded, False: 0]
  ------------------
 3815|       |
 3816|  22.0k|                        if constexpr (is_complete_type) {
 3817|  22.0k|                           if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) {
  ------------------
  |  Branch (3817:32): [True: 0, False: 22.0k]
  |  Branch (3817:72): [True: 0, False: 0]
  |  Branch (3817:88): [True: 0, False: 0]
  ------------------
 3818|      0|                              found_match = true;
 3819|      0|                              ctx.error = error_code::none;
 3820|      0|                           }
 3821|  22.0k|                           else {
 3822|  22.0k|                              it = copy_it;
 3823|  22.0k|                              rewind_depth<Options>(ctx, copy_depth);
 3824|  22.0k|                              if (non_const_idx + 1 < non_const_count && not exhausted &&
  ------------------
  |  Branch (3824:35): [True: 0, False: 22.0k]
  |  Branch (3824:74): [True: 0, False: 0]
  ------------------
 3825|      0|                                  not variant_alternative_exhausted(ctx)) {
  ------------------
  |  Branch (3825:35): [True: 0, False: 0]
  ------------------
 3826|      0|                                 ctx.error = error_code::none;
 3827|      0|                              }
 3828|  22.0k|                           }
 3829|       |                        }
 3830|       |                        else {
 3831|       |                           it = copy_it;
 3832|       |                           rewind_depth<Options>(ctx, copy_depth);
 3833|       |                           if (non_const_idx + 1 < non_const_count && not exhausted &&
 3834|       |                               not variant_alternative_exhausted(ctx)) {
 3835|       |                              ctx.error = error_code::none;
 3836|       |                           }
 3837|       |                        }
 3838|       |                     }
 3839|       |                     else {
 3840|       |                        it = copy_it;
 3841|       |                        rewind_depth<Options>(ctx, copy_depth);
 3842|       |                        if (non_const_idx + 1 < non_const_count && not exhausted &&
 3843|       |                            not variant_alternative_exhausted(ctx)) {
 3844|       |                           ctx.error = error_code::none;
 3845|       |                        }
 3846|       |                     }
 3847|   759k|                     ++non_const_idx;
 3848|   759k|                  }
 3849|   759k|               });
_ZZN3glz28process_variant_alternativesINSt3__17variantIJDndNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEbNS1_6vectorINS_12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEENS6_ISD_EEEENSC_ISD_EEEEENS_14is_variant_strEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSH_TkNS_10is_contextERNS_7contextERPKcSQ_EEvOT0_OT1_OT2_T3_ENKUlTnmvE_clILm3EEEDav:
 3794|   759k|               for_each<N>([&]<size_t I>() {
 3795|   759k|                  if (found_match || exhausted || variant_alternative_exhausted(ctx)) {
  ------------------
  |  Branch (3795:23): [True: 737k, False: 22.0k]
  |  Branch (3795:38): [True: 0, False: 22.0k]
  |  Branch (3795:51): [True: 0, False: 22.0k]
  ------------------
 3796|   737k|                     return;
 3797|   737k|                  }
 3798|  22.0k|                  using V = std::variant_alternative_t<I, Variant>;
 3799|       |                  if constexpr (Trait<V>::value && !glaze_const_value_t<V>) {
 3800|       |                     auto copy_it{it};
 3801|       |                     const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above
 3802|       |                     if (!std::holds_alternative<V>(value)) {
 3803|       |                        value = V{};
 3804|       |                     }
 3805|       |                     parse<JSON>::op<ws_handled<Options>()>(std::get<V>(value), ctx, it, end);
 3806|       |                     if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) {
 3807|       |                        exhausted = true; // only rejected attempts are charged; see charge_speculation
 3808|       |                     }
 3809|       |                     if (!bool(ctx.error)) {
 3810|       |                        found_match = true;
 3811|       |                     }
 3812|       |                     else if constexpr (not Options.null_terminated) {
 3813|       |                        constexpr bool is_complete_type =
 3814|       |                           num_t<V> || bool_t<V> || string_t<V> || std::is_enum_v<V> || tuple_t<V> || is_std_tuple<V>;
 3815|       |
 3816|       |                        if constexpr (is_complete_type) {
 3817|       |                           if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) {
 3818|       |                              found_match = true;
 3819|       |                              ctx.error = error_code::none;
 3820|       |                           }
 3821|       |                           else {
 3822|       |                              it = copy_it;
 3823|       |                              rewind_depth<Options>(ctx, copy_depth);
 3824|       |                              if (non_const_idx + 1 < non_const_count && not exhausted &&
 3825|       |                                  not variant_alternative_exhausted(ctx)) {
 3826|       |                                 ctx.error = error_code::none;
 3827|       |                              }
 3828|       |                           }
 3829|       |                        }
 3830|       |                        else {
 3831|       |                           it = copy_it;
 3832|       |                           rewind_depth<Options>(ctx, copy_depth);
 3833|       |                           if (non_const_idx + 1 < non_const_count && not exhausted &&
 3834|       |                               not variant_alternative_exhausted(ctx)) {
 3835|       |                              ctx.error = error_code::none;
 3836|       |                           }
 3837|       |                        }
 3838|       |                     }
 3839|       |                     else {
 3840|       |                        it = copy_it;
 3841|       |                        rewind_depth<Options>(ctx, copy_depth);
 3842|       |                        if (non_const_idx + 1 < non_const_count && not exhausted &&
 3843|       |                            not variant_alternative_exhausted(ctx)) {
 3844|       |                           ctx.error = error_code::none;
 3845|       |                        }
 3846|       |                     }
 3847|       |                     ++non_const_idx;
 3848|       |                  }
 3849|  22.0k|               });
_ZZN3glz28process_variant_alternativesINSt3__17variantIJDndNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEbNS1_6vectorINS_12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEENS6_ISD_EEEENSC_ISD_EEEEENS_14is_variant_strEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSH_TkNS_10is_contextERNS_7contextERPKcSQ_EEvOT0_OT1_OT2_T3_ENKUlTnmvE_clILm4EEEDav:
 3794|   759k|               for_each<N>([&]<size_t I>() {
 3795|   759k|                  if (found_match || exhausted || variant_alternative_exhausted(ctx)) {
  ------------------
  |  Branch (3795:23): [True: 737k, False: 22.0k]
  |  Branch (3795:38): [True: 0, False: 22.0k]
  |  Branch (3795:51): [True: 0, False: 22.0k]
  ------------------
 3796|   737k|                     return;
 3797|   737k|                  }
 3798|  22.0k|                  using V = std::variant_alternative_t<I, Variant>;
 3799|       |                  if constexpr (Trait<V>::value && !glaze_const_value_t<V>) {
 3800|       |                     auto copy_it{it};
 3801|       |                     const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above
 3802|       |                     if (!std::holds_alternative<V>(value)) {
 3803|       |                        value = V{};
 3804|       |                     }
 3805|       |                     parse<JSON>::op<ws_handled<Options>()>(std::get<V>(value), ctx, it, end);
 3806|       |                     if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) {
 3807|       |                        exhausted = true; // only rejected attempts are charged; see charge_speculation
 3808|       |                     }
 3809|       |                     if (!bool(ctx.error)) {
 3810|       |                        found_match = true;
 3811|       |                     }
 3812|       |                     else if constexpr (not Options.null_terminated) {
 3813|       |                        constexpr bool is_complete_type =
 3814|       |                           num_t<V> || bool_t<V> || string_t<V> || std::is_enum_v<V> || tuple_t<V> || is_std_tuple<V>;
 3815|       |
 3816|       |                        if constexpr (is_complete_type) {
 3817|       |                           if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) {
 3818|       |                              found_match = true;
 3819|       |                              ctx.error = error_code::none;
 3820|       |                           }
 3821|       |                           else {
 3822|       |                              it = copy_it;
 3823|       |                              rewind_depth<Options>(ctx, copy_depth);
 3824|       |                              if (non_const_idx + 1 < non_const_count && not exhausted &&
 3825|       |                                  not variant_alternative_exhausted(ctx)) {
 3826|       |                                 ctx.error = error_code::none;
 3827|       |                              }
 3828|       |                           }
 3829|       |                        }
 3830|       |                        else {
 3831|       |                           it = copy_it;
 3832|       |                           rewind_depth<Options>(ctx, copy_depth);
 3833|       |                           if (non_const_idx + 1 < non_const_count && not exhausted &&
 3834|       |                               not variant_alternative_exhausted(ctx)) {
 3835|       |                              ctx.error = error_code::none;
 3836|       |                           }
 3837|       |                        }
 3838|       |                     }
 3839|       |                     else {
 3840|       |                        it = copy_it;
 3841|       |                        rewind_depth<Options>(ctx, copy_depth);
 3842|       |                        if (non_const_idx + 1 < non_const_count && not exhausted &&
 3843|       |                            not variant_alternative_exhausted(ctx)) {
 3844|       |                           ctx.error = error_code::none;
 3845|       |                        }
 3846|       |                     }
 3847|       |                     ++non_const_idx;
 3848|       |                  }
 3849|  22.0k|               });
_ZZN3glz28process_variant_alternativesINSt3__17variantIJDndNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEbNS1_6vectorINS_12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEENS6_ISD_EEEENSC_ISD_EEEEENS_14is_variant_strEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSH_TkNS_10is_contextERNS_7contextERPKcSQ_EEvOT0_OT1_OT2_T3_ENKUlTnmvE_clILm5EEEDav:
 3794|   759k|               for_each<N>([&]<size_t I>() {
 3795|   759k|                  if (found_match || exhausted || variant_alternative_exhausted(ctx)) {
  ------------------
  |  Branch (3795:23): [True: 737k, False: 22.0k]
  |  Branch (3795:38): [True: 0, False: 22.0k]
  |  Branch (3795:51): [True: 0, False: 22.0k]
  ------------------
 3796|   737k|                     return;
 3797|   737k|                  }
 3798|  22.0k|                  using V = std::variant_alternative_t<I, Variant>;
 3799|       |                  if constexpr (Trait<V>::value && !glaze_const_value_t<V>) {
 3800|       |                     auto copy_it{it};
 3801|       |                     const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above
 3802|       |                     if (!std::holds_alternative<V>(value)) {
 3803|       |                        value = V{};
 3804|       |                     }
 3805|       |                     parse<JSON>::op<ws_handled<Options>()>(std::get<V>(value), ctx, it, end);
 3806|       |                     if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) {
 3807|       |                        exhausted = true; // only rejected attempts are charged; see charge_speculation
 3808|       |                     }
 3809|       |                     if (!bool(ctx.error)) {
 3810|       |                        found_match = true;
 3811|       |                     }
 3812|       |                     else if constexpr (not Options.null_terminated) {
 3813|       |                        constexpr bool is_complete_type =
 3814|       |                           num_t<V> || bool_t<V> || string_t<V> || std::is_enum_v<V> || tuple_t<V> || is_std_tuple<V>;
 3815|       |
 3816|       |                        if constexpr (is_complete_type) {
 3817|       |                           if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) {
 3818|       |                              found_match = true;
 3819|       |                              ctx.error = error_code::none;
 3820|       |                           }
 3821|       |                           else {
 3822|       |                              it = copy_it;
 3823|       |                              rewind_depth<Options>(ctx, copy_depth);
 3824|       |                              if (non_const_idx + 1 < non_const_count && not exhausted &&
 3825|       |                                  not variant_alternative_exhausted(ctx)) {
 3826|       |                                 ctx.error = error_code::none;
 3827|       |                              }
 3828|       |                           }
 3829|       |                        }
 3830|       |                        else {
 3831|       |                           it = copy_it;
 3832|       |                           rewind_depth<Options>(ctx, copy_depth);
 3833|       |                           if (non_const_idx + 1 < non_const_count && not exhausted &&
 3834|       |                               not variant_alternative_exhausted(ctx)) {
 3835|       |                              ctx.error = error_code::none;
 3836|       |                           }
 3837|       |                        }
 3838|       |                     }
 3839|       |                     else {
 3840|       |                        it = copy_it;
 3841|       |                        rewind_depth<Options>(ctx, copy_depth);
 3842|       |                        if (non_const_idx + 1 < non_const_count && not exhausted &&
 3843|       |                            not variant_alternative_exhausted(ctx)) {
 3844|       |                           ctx.error = error_code::none;
 3845|       |                        }
 3846|       |                     }
 3847|       |                     ++non_const_idx;
 3848|       |                  }
 3849|  22.0k|               });
_ZN3glz28process_variant_alternativesINSt3__17variantIJDndNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEbNS1_6vectorINS_12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEENS6_ISD_EEEENSC_ISD_EEEEENS_14is_variant_numEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSH_TkNS_10is_contextERNS_7contextERPKcSQ_EEvOT0_OT1_OT2_T3_:
 3725|   268k|      {
 3726|   268k|         constexpr auto category_count = variant_count_v<Variant, Trait>;
 3727|       |
 3728|       |         if constexpr (category_count == 0) {
 3729|       |            ctx.error = error_code::no_matching_variant_type;
 3730|       |         }
 3731|   268k|         else {
 3732|   268k|            constexpr auto N = std::variant_size_v<Variant>;
 3733|   268k|            constexpr auto const_count = variant_filtered_count_v<Variant, Trait, true>;
 3734|   268k|            constexpr auto non_const_count = variant_filtered_count_v<Variant, Trait, false>;
 3735|       |
 3736|   268k|            bool found_match{};
 3737|       |            // Set when the speculative parsing budget runs out; see charge_speculation. An ambiguous
 3738|       |            // nest re-parses the same subtree per alternative at every level, which is exponential,
 3739|       |            // so the budget stops it and the failure already in hand is reported.
 3740|   268k|            bool exhausted{};
 3741|       |
 3742|       |            // First pass: const glaze types in this category
 3743|       |            if constexpr (const_count > 0) {
 3744|       |               for_each<N>([&]<size_t I>() {
 3745|       |                  if (found_match || exhausted || variant_alternative_exhausted(ctx)) {
 3746|       |                     return;
 3747|       |                  }
 3748|       |                  using V = std::variant_alternative_t<I, Variant>;
 3749|       |                  if constexpr (Trait<V>::value && glaze_const_value_t<V>) {
 3750|       |                     // run time substitute to compare to const value
 3751|       |                     std::remove_const_t<std::remove_pointer_t<std::remove_const_t<meta_wrapper_t<V>>>> substitute{};
 3752|       |                     auto copy_it{it};
 3753|       |                     // A rejected alternative may have bailed out inside a container, which leaves its
 3754|       |                     // nesting level counted (see enter_depth). Rewind the depth with the iterator so
 3755|       |                     // trying N alternatives cannot spend N levels of the recursion budget.
 3756|       |                     const auto copy_depth{ctx.depth};
 3757|       |                     parse<JSON>::op<ws_handled<Options>()>(substitute, ctx, it, end);
 3758|       |                     static constexpr auto const_value{*meta_wrapper_v<V>};
 3759|       |                     if (substitute == const_value) {
 3760|       |                        found_match = true;
 3761|       |                        if (!std::holds_alternative<V>(value)) {
 3762|       |                           value = V{};
 3763|       |                        }
 3764|       |                     }
 3765|       |                     else {
 3766|       |                        // Rejected: charge the bytes it parsed before we rewind. See charge_speculation.
 3767|       |                        if (!charge_speculation(ctx, size_t(it - copy_it))) {
 3768|       |                           exhausted = true;
 3769|       |                        }
 3770|       |                        if constexpr (not Options.null_terminated) {
 3771|       |                           if (ctx.error == error_code::end_reached && not exhausted) {
 3772|       |                              ctx.error = error_code::none;
 3773|       |                           }
 3774|       |                        }
 3775|       |                        it = copy_it;
 3776|       |                        rewind_depth<Options>(ctx, copy_depth);
 3777|       |                     }
 3778|       |                  }
 3779|       |               });
 3780|       |               if (found_match) {
 3781|       |                  return;
 3782|       |               }
 3783|       |            }
 3784|       |
 3785|       |            // Second pass: non-const types in this category
 3786|   268k|            if constexpr (non_const_count > 0) {
 3787|       |               // Track position within matching types for "is last" check.
 3788|       |               // We iterate over all variant indices but only process matching types,
 3789|       |               // so we need runtime tracking (vs the old tuple-based approach where
 3790|       |               // the loop index directly corresponded to position in filtered set).
 3791|       |               // This has negligible cost: one increment per matching type.
 3792|   268k|               size_t non_const_idx = 0;
 3793|       |
 3794|   268k|               for_each<N>([&]<size_t I>() {
 3795|   268k|                  if (found_match || exhausted || variant_alternative_exhausted(ctx)) {
 3796|   268k|                     return;
 3797|   268k|                  }
 3798|   268k|                  using V = std::variant_alternative_t<I, Variant>;
 3799|   268k|                  if constexpr (Trait<V>::value && !glaze_const_value_t<V>) {
 3800|   268k|                     auto copy_it{it};
 3801|   268k|                     const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above
 3802|   268k|                     if (!std::holds_alternative<V>(value)) {
 3803|   268k|                        value = V{};
 3804|   268k|                     }
 3805|   268k|                     parse<JSON>::op<ws_handled<Options>()>(std::get<V>(value), ctx, it, end);
 3806|   268k|                     if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) {
 3807|   268k|                        exhausted = true; // only rejected attempts are charged; see charge_speculation
 3808|   268k|                     }
 3809|   268k|                     if (!bool(ctx.error)) {
 3810|   268k|                        found_match = true;
 3811|   268k|                     }
 3812|   268k|                     else if constexpr (not Options.null_terminated) {
 3813|   268k|                        constexpr bool is_complete_type =
 3814|   268k|                           num_t<V> || bool_t<V> || string_t<V> || std::is_enum_v<V> || tuple_t<V> || is_std_tuple<V>;
 3815|       |
 3816|   268k|                        if constexpr (is_complete_type) {
 3817|   268k|                           if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) {
 3818|   268k|                              found_match = true;
 3819|   268k|                              ctx.error = error_code::none;
 3820|   268k|                           }
 3821|   268k|                           else {
 3822|   268k|                              it = copy_it;
 3823|   268k|                              rewind_depth<Options>(ctx, copy_depth);
 3824|   268k|                              if (non_const_idx + 1 < non_const_count && not exhausted &&
 3825|   268k|                                  not variant_alternative_exhausted(ctx)) {
 3826|   268k|                                 ctx.error = error_code::none;
 3827|   268k|                              }
 3828|   268k|                           }
 3829|   268k|                        }
 3830|   268k|                        else {
 3831|   268k|                           it = copy_it;
 3832|   268k|                           rewind_depth<Options>(ctx, copy_depth);
 3833|   268k|                           if (non_const_idx + 1 < non_const_count && not exhausted &&
 3834|   268k|                               not variant_alternative_exhausted(ctx)) {
 3835|   268k|                              ctx.error = error_code::none;
 3836|   268k|                           }
 3837|   268k|                        }
 3838|   268k|                     }
 3839|   268k|                     else {
 3840|   268k|                        it = copy_it;
 3841|   268k|                        rewind_depth<Options>(ctx, copy_depth);
 3842|   268k|                        if (non_const_idx + 1 < non_const_count && not exhausted &&
 3843|   268k|                            not variant_alternative_exhausted(ctx)) {
 3844|   268k|                           ctx.error = error_code::none;
 3845|   268k|                        }
 3846|   268k|                     }
 3847|   268k|                     ++non_const_idx;
 3848|   268k|                  }
 3849|   268k|               });
 3850|   268k|               if (!found_match) {
  ------------------
  |  Branch (3850:20): [True: 0, False: 268k]
  ------------------
 3851|      0|                  if constexpr (non_const_count == 1) {
 3852|       |                     // Keep the specific error from the single type we tried
 3853|       |                  }
 3854|       |                  else if (not exhausted && not variant_alternative_exhausted(ctx)) {
 3855|       |                     // Over-nested input is not a failure of the alternative set; keep saying so.
 3856|       |                     ctx.error = error_code::no_matching_variant_type;
 3857|       |                  }
 3858|      0|               }
 3859|       |            }
 3860|       |            else {
 3861|       |               ctx.error = error_code::no_matching_variant_type;
 3862|       |            }
 3863|   268k|         }
 3864|   268k|      }
_ZZN3glz28process_variant_alternativesINSt3__17variantIJDndNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEbNS1_6vectorINS_12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEENS6_ISD_EEEENSC_ISD_EEEEENS_14is_variant_numEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSH_TkNS_10is_contextERNS_7contextERPKcSQ_EEvOT0_OT1_OT2_T3_ENKUlTnmvE_clILm0EEEDav:
 3794|   268k|               for_each<N>([&]<size_t I>() {
 3795|   268k|                  if (found_match || exhausted || variant_alternative_exhausted(ctx)) {
  ------------------
  |  Branch (3795:23): [True: 0, False: 268k]
  |  Branch (3795:38): [True: 0, False: 268k]
  |  Branch (3795:51): [True: 0, False: 268k]
  ------------------
 3796|      0|                     return;
 3797|      0|                  }
 3798|   268k|                  using V = std::variant_alternative_t<I, Variant>;
 3799|       |                  if constexpr (Trait<V>::value && !glaze_const_value_t<V>) {
 3800|       |                     auto copy_it{it};
 3801|       |                     const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above
 3802|       |                     if (!std::holds_alternative<V>(value)) {
 3803|       |                        value = V{};
 3804|       |                     }
 3805|       |                     parse<JSON>::op<ws_handled<Options>()>(std::get<V>(value), ctx, it, end);
 3806|       |                     if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) {
 3807|       |                        exhausted = true; // only rejected attempts are charged; see charge_speculation
 3808|       |                     }
 3809|       |                     if (!bool(ctx.error)) {
 3810|       |                        found_match = true;
 3811|       |                     }
 3812|       |                     else if constexpr (not Options.null_terminated) {
 3813|       |                        constexpr bool is_complete_type =
 3814|       |                           num_t<V> || bool_t<V> || string_t<V> || std::is_enum_v<V> || tuple_t<V> || is_std_tuple<V>;
 3815|       |
 3816|       |                        if constexpr (is_complete_type) {
 3817|       |                           if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) {
 3818|       |                              found_match = true;
 3819|       |                              ctx.error = error_code::none;
 3820|       |                           }
 3821|       |                           else {
 3822|       |                              it = copy_it;
 3823|       |                              rewind_depth<Options>(ctx, copy_depth);
 3824|       |                              if (non_const_idx + 1 < non_const_count && not exhausted &&
 3825|       |                                  not variant_alternative_exhausted(ctx)) {
 3826|       |                                 ctx.error = error_code::none;
 3827|       |                              }
 3828|       |                           }
 3829|       |                        }
 3830|       |                        else {
 3831|       |                           it = copy_it;
 3832|       |                           rewind_depth<Options>(ctx, copy_depth);
 3833|       |                           if (non_const_idx + 1 < non_const_count && not exhausted &&
 3834|       |                               not variant_alternative_exhausted(ctx)) {
 3835|       |                              ctx.error = error_code::none;
 3836|       |                           }
 3837|       |                        }
 3838|       |                     }
 3839|       |                     else {
 3840|       |                        it = copy_it;
 3841|       |                        rewind_depth<Options>(ctx, copy_depth);
 3842|       |                        if (non_const_idx + 1 < non_const_count && not exhausted &&
 3843|       |                            not variant_alternative_exhausted(ctx)) {
 3844|       |                           ctx.error = error_code::none;
 3845|       |                        }
 3846|       |                     }
 3847|       |                     ++non_const_idx;
 3848|       |                  }
 3849|   268k|               });
_ZZN3glz28process_variant_alternativesINSt3__17variantIJDndNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEbNS1_6vectorINS_12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEENS6_ISD_EEEENSC_ISD_EEEEENS_14is_variant_numEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSH_TkNS_10is_contextERNS_7contextERPKcSQ_EEvOT0_OT1_OT2_T3_ENKUlTnmvE_clILm1EEEDav:
 3794|   268k|               for_each<N>([&]<size_t I>() {
 3795|   268k|                  if (found_match || exhausted || variant_alternative_exhausted(ctx)) {
  ------------------
  |  Branch (3795:23): [True: 0, False: 268k]
  |  Branch (3795:38): [True: 0, False: 268k]
  |  Branch (3795:51): [True: 0, False: 268k]
  ------------------
 3796|      0|                     return;
 3797|      0|                  }
 3798|   268k|                  using V = std::variant_alternative_t<I, Variant>;
 3799|   268k|                  if constexpr (Trait<V>::value && !glaze_const_value_t<V>) {
 3800|   268k|                     auto copy_it{it};
 3801|   268k|                     const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above
 3802|   268k|                     if (!std::holds_alternative<V>(value)) {
  ------------------
  |  Branch (3802:26): [True: 268k, False: 0]
  ------------------
 3803|   268k|                        value = V{};
 3804|   268k|                     }
 3805|   268k|                     parse<JSON>::op<ws_handled<Options>()>(std::get<V>(value), ctx, it, end);
 3806|   268k|                     if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) {
  ------------------
  |  Branch (3806:26): [True: 0, False: 268k]
  |  Branch (3806:45): [True: 0, False: 0]
  ------------------
 3807|      0|                        exhausted = true; // only rejected attempts are charged; see charge_speculation
 3808|      0|                     }
 3809|   268k|                     if (!bool(ctx.error)) {
  ------------------
  |  Branch (3809:26): [True: 268k, False: 0]
  ------------------
 3810|   268k|                        found_match = true;
 3811|   268k|                     }
 3812|      0|                     else if constexpr (not Options.null_terminated) {
 3813|      0|                        constexpr bool is_complete_type =
 3814|      0|                           num_t<V> || bool_t<V> || string_t<V> || std::is_enum_v<V> || tuple_t<V> || is_std_tuple<V>;
  ------------------
  |  Branch (3814:28): [True: 0, Folded]
  |  Branch (3814:40): [Folded, False: 0]
  |  Branch (3814:53): [Folded, False: 0]
  |  Branch (3814:68): [Folded, False: 0]
  |  Branch (3814:89): [Folded, False: 0]
  |  Branch (3814:103): [Folded, False: 0]
  ------------------
 3815|       |
 3816|      0|                        if constexpr (is_complete_type) {
 3817|      0|                           if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) {
  ------------------
  |  Branch (3817:32): [True: 0, False: 0]
  |  Branch (3817:72): [True: 0, False: 0]
  |  Branch (3817:88): [True: 0, False: 0]
  ------------------
 3818|      0|                              found_match = true;
 3819|      0|                              ctx.error = error_code::none;
 3820|      0|                           }
 3821|      0|                           else {
 3822|      0|                              it = copy_it;
 3823|      0|                              rewind_depth<Options>(ctx, copy_depth);
 3824|      0|                              if (non_const_idx + 1 < non_const_count && not exhausted &&
  ------------------
  |  Branch (3824:35): [True: 0, False: 0]
  |  Branch (3824:74): [True: 0, False: 0]
  ------------------
 3825|      0|                                  not variant_alternative_exhausted(ctx)) {
  ------------------
  |  Branch (3825:35): [True: 0, False: 0]
  ------------------
 3826|      0|                                 ctx.error = error_code::none;
 3827|      0|                              }
 3828|      0|                           }
 3829|       |                        }
 3830|       |                        else {
 3831|       |                           it = copy_it;
 3832|       |                           rewind_depth<Options>(ctx, copy_depth);
 3833|       |                           if (non_const_idx + 1 < non_const_count && not exhausted &&
 3834|       |                               not variant_alternative_exhausted(ctx)) {
 3835|       |                              ctx.error = error_code::none;
 3836|       |                           }
 3837|       |                        }
 3838|       |                     }
 3839|       |                     else {
 3840|       |                        it = copy_it;
 3841|       |                        rewind_depth<Options>(ctx, copy_depth);
 3842|       |                        if (non_const_idx + 1 < non_const_count && not exhausted &&
 3843|       |                            not variant_alternative_exhausted(ctx)) {
 3844|       |                           ctx.error = error_code::none;
 3845|       |                        }
 3846|       |                     }
 3847|   268k|                     ++non_const_idx;
 3848|   268k|                  }
 3849|   268k|               });
_ZZN3glz28process_variant_alternativesINSt3__17variantIJDndNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEbNS1_6vectorINS_12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEENS6_ISD_EEEENSC_ISD_EEEEENS_14is_variant_numEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSH_TkNS_10is_contextERNS_7contextERPKcSQ_EEvOT0_OT1_OT2_T3_ENKUlTnmvE_clILm2EEEDav:
 3794|   268k|               for_each<N>([&]<size_t I>() {
 3795|   268k|                  if (found_match || exhausted || variant_alternative_exhausted(ctx)) {
  ------------------
  |  Branch (3795:23): [True: 268k, False: 0]
  |  Branch (3795:38): [True: 0, False: 0]
  |  Branch (3795:51): [True: 0, False: 0]
  ------------------
 3796|   268k|                     return;
 3797|   268k|                  }
 3798|      0|                  using V = std::variant_alternative_t<I, Variant>;
 3799|       |                  if constexpr (Trait<V>::value && !glaze_const_value_t<V>) {
 3800|       |                     auto copy_it{it};
 3801|       |                     const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above
 3802|       |                     if (!std::holds_alternative<V>(value)) {
 3803|       |                        value = V{};
 3804|       |                     }
 3805|       |                     parse<JSON>::op<ws_handled<Options>()>(std::get<V>(value), ctx, it, end);
 3806|       |                     if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) {
 3807|       |                        exhausted = true; // only rejected attempts are charged; see charge_speculation
 3808|       |                     }
 3809|       |                     if (!bool(ctx.error)) {
 3810|       |                        found_match = true;
 3811|       |                     }
 3812|       |                     else if constexpr (not Options.null_terminated) {
 3813|       |                        constexpr bool is_complete_type =
 3814|       |                           num_t<V> || bool_t<V> || string_t<V> || std::is_enum_v<V> || tuple_t<V> || is_std_tuple<V>;
 3815|       |
 3816|       |                        if constexpr (is_complete_type) {
 3817|       |                           if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) {
 3818|       |                              found_match = true;
 3819|       |                              ctx.error = error_code::none;
 3820|       |                           }
 3821|       |                           else {
 3822|       |                              it = copy_it;
 3823|       |                              rewind_depth<Options>(ctx, copy_depth);
 3824|       |                              if (non_const_idx + 1 < non_const_count && not exhausted &&
 3825|       |                                  not variant_alternative_exhausted(ctx)) {
 3826|       |                                 ctx.error = error_code::none;
 3827|       |                              }
 3828|       |                           }
 3829|       |                        }
 3830|       |                        else {
 3831|       |                           it = copy_it;
 3832|       |                           rewind_depth<Options>(ctx, copy_depth);
 3833|       |                           if (non_const_idx + 1 < non_const_count && not exhausted &&
 3834|       |                               not variant_alternative_exhausted(ctx)) {
 3835|       |                              ctx.error = error_code::none;
 3836|       |                           }
 3837|       |                        }
 3838|       |                     }
 3839|       |                     else {
 3840|       |                        it = copy_it;
 3841|       |                        rewind_depth<Options>(ctx, copy_depth);
 3842|       |                        if (non_const_idx + 1 < non_const_count && not exhausted &&
 3843|       |                            not variant_alternative_exhausted(ctx)) {
 3844|       |                           ctx.error = error_code::none;
 3845|       |                        }
 3846|       |                     }
 3847|       |                     ++non_const_idx;
 3848|       |                  }
 3849|      0|               });
_ZZN3glz28process_variant_alternativesINSt3__17variantIJDndNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEbNS1_6vectorINS_12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEENS6_ISD_EEEENSC_ISD_EEEEENS_14is_variant_numEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSH_TkNS_10is_contextERNS_7contextERPKcSQ_EEvOT0_OT1_OT2_T3_ENKUlTnmvE_clILm3EEEDav:
 3794|   268k|               for_each<N>([&]<size_t I>() {
 3795|   268k|                  if (found_match || exhausted || variant_alternative_exhausted(ctx)) {
  ------------------
  |  Branch (3795:23): [True: 268k, False: 0]
  |  Branch (3795:38): [True: 0, False: 0]
  |  Branch (3795:51): [True: 0, False: 0]
  ------------------
 3796|   268k|                     return;
 3797|   268k|                  }
 3798|      0|                  using V = std::variant_alternative_t<I, Variant>;
 3799|       |                  if constexpr (Trait<V>::value && !glaze_const_value_t<V>) {
 3800|       |                     auto copy_it{it};
 3801|       |                     const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above
 3802|       |                     if (!std::holds_alternative<V>(value)) {
 3803|       |                        value = V{};
 3804|       |                     }
 3805|       |                     parse<JSON>::op<ws_handled<Options>()>(std::get<V>(value), ctx, it, end);
 3806|       |                     if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) {
 3807|       |                        exhausted = true; // only rejected attempts are charged; see charge_speculation
 3808|       |                     }
 3809|       |                     if (!bool(ctx.error)) {
 3810|       |                        found_match = true;
 3811|       |                     }
 3812|       |                     else if constexpr (not Options.null_terminated) {
 3813|       |                        constexpr bool is_complete_type =
 3814|       |                           num_t<V> || bool_t<V> || string_t<V> || std::is_enum_v<V> || tuple_t<V> || is_std_tuple<V>;
 3815|       |
 3816|       |                        if constexpr (is_complete_type) {
 3817|       |                           if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) {
 3818|       |                              found_match = true;
 3819|       |                              ctx.error = error_code::none;
 3820|       |                           }
 3821|       |                           else {
 3822|       |                              it = copy_it;
 3823|       |                              rewind_depth<Options>(ctx, copy_depth);
 3824|       |                              if (non_const_idx + 1 < non_const_count && not exhausted &&
 3825|       |                                  not variant_alternative_exhausted(ctx)) {
 3826|       |                                 ctx.error = error_code::none;
 3827|       |                              }
 3828|       |                           }
 3829|       |                        }
 3830|       |                        else {
 3831|       |                           it = copy_it;
 3832|       |                           rewind_depth<Options>(ctx, copy_depth);
 3833|       |                           if (non_const_idx + 1 < non_const_count && not exhausted &&
 3834|       |                               not variant_alternative_exhausted(ctx)) {
 3835|       |                              ctx.error = error_code::none;
 3836|       |                           }
 3837|       |                        }
 3838|       |                     }
 3839|       |                     else {
 3840|       |                        it = copy_it;
 3841|       |                        rewind_depth<Options>(ctx, copy_depth);
 3842|       |                        if (non_const_idx + 1 < non_const_count && not exhausted &&
 3843|       |                            not variant_alternative_exhausted(ctx)) {
 3844|       |                           ctx.error = error_code::none;
 3845|       |                        }
 3846|       |                     }
 3847|       |                     ++non_const_idx;
 3848|       |                  }
 3849|      0|               });
_ZZN3glz28process_variant_alternativesINSt3__17variantIJDndNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEbNS1_6vectorINS_12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEENS6_ISD_EEEENSC_ISD_EEEEENS_14is_variant_numEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSH_TkNS_10is_contextERNS_7contextERPKcSQ_EEvOT0_OT1_OT2_T3_ENKUlTnmvE_clILm4EEEDav:
 3794|   268k|               for_each<N>([&]<size_t I>() {
 3795|   268k|                  if (found_match || exhausted || variant_alternative_exhausted(ctx)) {
  ------------------
  |  Branch (3795:23): [True: 268k, False: 0]
  |  Branch (3795:38): [True: 0, False: 0]
  |  Branch (3795:51): [True: 0, False: 0]
  ------------------
 3796|   268k|                     return;
 3797|   268k|                  }
 3798|      0|                  using V = std::variant_alternative_t<I, Variant>;
 3799|       |                  if constexpr (Trait<V>::value && !glaze_const_value_t<V>) {
 3800|       |                     auto copy_it{it};
 3801|       |                     const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above
 3802|       |                     if (!std::holds_alternative<V>(value)) {
 3803|       |                        value = V{};
 3804|       |                     }
 3805|       |                     parse<JSON>::op<ws_handled<Options>()>(std::get<V>(value), ctx, it, end);
 3806|       |                     if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) {
 3807|       |                        exhausted = true; // only rejected attempts are charged; see charge_speculation
 3808|       |                     }
 3809|       |                     if (!bool(ctx.error)) {
 3810|       |                        found_match = true;
 3811|       |                     }
 3812|       |                     else if constexpr (not Options.null_terminated) {
 3813|       |                        constexpr bool is_complete_type =
 3814|       |                           num_t<V> || bool_t<V> || string_t<V> || std::is_enum_v<V> || tuple_t<V> || is_std_tuple<V>;
 3815|       |
 3816|       |                        if constexpr (is_complete_type) {
 3817|       |                           if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) {
 3818|       |                              found_match = true;
 3819|       |                              ctx.error = error_code::none;
 3820|       |                           }
 3821|       |                           else {
 3822|       |                              it = copy_it;
 3823|       |                              rewind_depth<Options>(ctx, copy_depth);
 3824|       |                              if (non_const_idx + 1 < non_const_count && not exhausted &&
 3825|       |                                  not variant_alternative_exhausted(ctx)) {
 3826|       |                                 ctx.error = error_code::none;
 3827|       |                              }
 3828|       |                           }
 3829|       |                        }
 3830|       |                        else {
 3831|       |                           it = copy_it;
 3832|       |                           rewind_depth<Options>(ctx, copy_depth);
 3833|       |                           if (non_const_idx + 1 < non_const_count && not exhausted &&
 3834|       |                               not variant_alternative_exhausted(ctx)) {
 3835|       |                              ctx.error = error_code::none;
 3836|       |                           }
 3837|       |                        }
 3838|       |                     }
 3839|       |                     else {
 3840|       |                        it = copy_it;
 3841|       |                        rewind_depth<Options>(ctx, copy_depth);
 3842|       |                        if (non_const_idx + 1 < non_const_count && not exhausted &&
 3843|       |                            not variant_alternative_exhausted(ctx)) {
 3844|       |                           ctx.error = error_code::none;
 3845|       |                        }
 3846|       |                     }
 3847|       |                     ++non_const_idx;
 3848|       |                  }
 3849|      0|               });
_ZZN3glz28process_variant_alternativesINSt3__17variantIJDndNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEbNS1_6vectorINS_12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEENS6_ISD_EEEENSC_ISD_EEEEENS_14is_variant_numEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSH_TkNS_10is_contextERNS_7contextERPKcSQ_EEvOT0_OT1_OT2_T3_ENKUlTnmvE_clILm5EEEDav:
 3794|   268k|               for_each<N>([&]<size_t I>() {
 3795|   268k|                  if (found_match || exhausted || variant_alternative_exhausted(ctx)) {
  ------------------
  |  Branch (3795:23): [True: 268k, False: 0]
  |  Branch (3795:38): [True: 0, False: 0]
  |  Branch (3795:51): [True: 0, False: 0]
  ------------------
 3796|   268k|                     return;
 3797|   268k|                  }
 3798|      0|                  using V = std::variant_alternative_t<I, Variant>;
 3799|       |                  if constexpr (Trait<V>::value && !glaze_const_value_t<V>) {
 3800|       |                     auto copy_it{it};
 3801|       |                     const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above
 3802|       |                     if (!std::holds_alternative<V>(value)) {
 3803|       |                        value = V{};
 3804|       |                     }
 3805|       |                     parse<JSON>::op<ws_handled<Options>()>(std::get<V>(value), ctx, it, end);
 3806|       |                     if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) {
 3807|       |                        exhausted = true; // only rejected attempts are charged; see charge_speculation
 3808|       |                     }
 3809|       |                     if (!bool(ctx.error)) {
 3810|       |                        found_match = true;
 3811|       |                     }
 3812|       |                     else if constexpr (not Options.null_terminated) {
 3813|       |                        constexpr bool is_complete_type =
 3814|       |                           num_t<V> || bool_t<V> || string_t<V> || std::is_enum_v<V> || tuple_t<V> || is_std_tuple<V>;
 3815|       |
 3816|       |                        if constexpr (is_complete_type) {
 3817|       |                           if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) {
 3818|       |                              found_match = true;
 3819|       |                              ctx.error = error_code::none;
 3820|       |                           }
 3821|       |                           else {
 3822|       |                              it = copy_it;
 3823|       |                              rewind_depth<Options>(ctx, copy_depth);
 3824|       |                              if (non_const_idx + 1 < non_const_count && not exhausted &&
 3825|       |                                  not variant_alternative_exhausted(ctx)) {
 3826|       |                                 ctx.error = error_code::none;
 3827|       |                              }
 3828|       |                           }
 3829|       |                        }
 3830|       |                        else {
 3831|       |                           it = copy_it;
 3832|       |                           rewind_depth<Options>(ctx, copy_depth);
 3833|       |                           if (non_const_idx + 1 < non_const_count && not exhausted &&
 3834|       |                               not variant_alternative_exhausted(ctx)) {
 3835|       |                              ctx.error = error_code::none;
 3836|       |                           }
 3837|       |                        }
 3838|       |                     }
 3839|       |                     else {
 3840|       |                        it = copy_it;
 3841|       |                        rewind_depth<Options>(ctx, copy_depth);
 3842|       |                        if (non_const_idx + 1 < non_const_count && not exhausted &&
 3843|       |                            not variant_alternative_exhausted(ctx)) {
 3844|       |                           ctx.error = error_code::none;
 3845|       |                        }
 3846|       |                     }
 3847|       |                     ++non_const_idx;
 3848|       |                  }
 3849|      0|               });

_ZN3glz10skip_valueILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETkNS_10is_contextERNS_7contextERPKcS7_QntdtT_8commentsEEvOT0_OT1_T2_:
  321|  16.6k|   {
  322|  16.6k|      using namespace glz::detail;
  323|       |
  324|       |      // Validating skips (parse_value/JSON pointer) require the full value in a
  325|       |      // contiguous buffer, so streaming refill is not applied there.
  326|       |      if constexpr (has_streaming_state<decltype(ctx)> && not check_validate_skipped(Opts)) {
  327|       |         if (ctx.stream.enabled()) {
  328|       |            skip_value_streaming<Opts>(ctx, it, end);
  329|       |            return;
  330|       |         }
  331|       |      }
  332|       |
  333|  16.6k|      if constexpr (not check_validate_skipped(Opts)) {
  334|  16.6k|         if constexpr (not check_ws_handled(Opts)) {
  335|  16.6k|            if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (335:17): [True: 0, False: 16.6k]
  ------------------
  336|      0|               return;
  337|      0|            }
  338|  16.6k|         }
  339|  55.0k|         while (true) {
  ------------------
  |  Branch (339:17): [True: 55.0k, Folded]
  ------------------
  340|  55.0k|            switch (*it) {
  341|  1.45k|            case '{':
  ------------------
  |  Branch (341:13): [True: 1.45k, False: 53.6k]
  ------------------
  342|  1.45k|               ++it;
  343|  1.45k|               if constexpr (not Opts.null_terminated) {
  344|  1.45k|                  if (it == end) [[unlikely]] {
  ------------------
  |  Branch (344:23): [True: 0, False: 1.45k]
  ------------------
  345|      0|                     ctx.error = error_code::unexpected_end;
  346|      0|                     return;
  347|      0|                  }
  348|  1.45k|               }
  349|  1.45k|               skip_until_closed<Opts, '{', '}'>(ctx, it, end);
  350|  1.45k|               if (bool(ctx.error)) [[unlikely]]
  ------------------
  |  Branch (350:20): [True: 0, False: 1.45k]
  ------------------
  351|      0|                  return;
  352|  1.45k|               break;
  353|  5.45k|            case '[':
  ------------------
  |  Branch (353:13): [True: 5.45k, False: 49.5k]
  ------------------
  354|  5.45k|               ++it;
  355|  5.45k|               if constexpr (not Opts.null_terminated) {
  356|  5.45k|                  if (it == end) [[unlikely]] {
  ------------------
  |  Branch (356:23): [True: 0, False: 5.45k]
  ------------------
  357|      0|                     ctx.error = error_code::unexpected_end;
  358|      0|                     return;
  359|      0|                  }
  360|  5.45k|               }
  361|  5.45k|               skip_until_closed<Opts, '[', ']'>(ctx, it, end);
  362|  5.45k|               if (bool(ctx.error)) [[unlikely]]
  ------------------
  |  Branch (362:20): [True: 0, False: 5.45k]
  ------------------
  363|      0|                  return;
  364|  5.45k|               break;
  365|  5.45k|            case '"':
  ------------------
  |  Branch (365:13): [True: 5.27k, False: 49.7k]
  ------------------
  366|  5.27k|               skip_string<Opts>(ctx, it, end);
  367|  5.27k|               if (bool(ctx.error)) [[unlikely]]
  ------------------
  |  Branch (367:20): [True: 0, False: 5.27k]
  ------------------
  368|      0|                  return;
  369|  5.27k|               break;
  370|  5.27k|            case ',':
  ------------------
  |  Branch (370:13): [True: 4.09k, False: 50.9k]
  ------------------
  371|  4.46k|            case '}':
  ------------------
  |  Branch (371:13): [True: 363, False: 54.6k]
  ------------------
  372|  4.46k|            case ']':
  ------------------
  |  Branch (372:13): [True: 0, False: 55.0k]
  ------------------
  373|  4.46k|               break;
  374|      0|            case '\0':
  ------------------
  |  Branch (374:13): [True: 0, False: 55.0k]
  ------------------
  375|      0|               ctx.error = error_code::unexpected_end;
  376|      0|               return;
  377|  38.4k|            default: {
  ------------------
  |  Branch (377:13): [True: 38.4k, False: 16.6k]
  ------------------
  378|  38.4k|               ++it;
  379|  38.4k|               if constexpr (not Opts.null_terminated) {
  380|  38.4k|                  if (it == end) [[unlikely]] {
  ------------------
  |  Branch (380:23): [True: 0, False: 38.4k]
  ------------------
  381|      0|                     ctx.error = error_code::unexpected_end;
  382|      0|                     return;
  383|      0|                  }
  384|  38.4k|               }
  385|  38.4k|               continue;
  386|  4.46k|            }
  387|  55.0k|            }
  388|       |
  389|  16.6k|            break;
  390|  55.0k|         }
  391|       |      }
  392|       |      else {
  393|       |         if constexpr (not check_ws_handled(Opts)) {
  394|       |            if (skip_ws<Opts>(ctx, it, end)) {
  395|       |               return;
  396|       |            }
  397|       |         }
  398|       |         switch (*it) {
  399|       |         case '{': {
  400|       |            skip_object<Opts>(ctx, it, end);
  401|       |            break;
  402|       |         }
  403|       |         case '[': {
  404|       |            skip_array<Opts>(ctx, it, end);
  405|       |            break;
  406|       |         }
  407|       |         case '"': {
  408|       |            skip_string<Opts>(ctx, it, end);
  409|       |            break;
  410|       |         }
  411|       |         case 'n': {
  412|       |            ++it;
  413|       |            match<"ull", Opts>(ctx, it, end);
  414|       |            break;
  415|       |         }
  416|       |         case 'f': {
  417|       |            ++it;
  418|       |            match<"alse", Opts>(ctx, it, end);
  419|       |            break;
  420|       |         }
  421|       |         case 't': {
  422|       |            ++it;
  423|       |            match<"rue", Opts>(ctx, it, end);
  424|       |            break;
  425|       |         }
  426|       |         case '\0': {
  427|       |            ctx.error = error_code::unexpected_end;
  428|       |            break;
  429|       |         }
  430|       |         default: {
  431|       |            skip_number<Opts>(ctx, it, end);
  432|       |         }
  433|       |         }
  434|       |      }
  435|  16.6k|   }
_ZN3glz10skip_valueILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEETkNS_10is_contextERNS_7contextERPKcS7_QntdtT_8commentsEEvOT0_OT1_T2_:
  321|  4.90M|   {
  322|  4.90M|      using namespace glz::detail;
  323|       |
  324|       |      // Validating skips (parse_value/JSON pointer) require the full value in a
  325|       |      // contiguous buffer, so streaming refill is not applied there.
  326|       |      if constexpr (has_streaming_state<decltype(ctx)> && not check_validate_skipped(Opts)) {
  327|       |         if (ctx.stream.enabled()) {
  328|       |            skip_value_streaming<Opts>(ctx, it, end);
  329|       |            return;
  330|       |         }
  331|       |      }
  332|       |
  333|  4.90M|      if constexpr (not check_validate_skipped(Opts)) {
  334|       |         if constexpr (not check_ws_handled(Opts)) {
  335|       |            if (skip_ws<Opts>(ctx, it, end)) {
  336|       |               return;
  337|       |            }
  338|       |         }
  339|  16.2M|         while (true) {
  ------------------
  |  Branch (339:17): [True: 16.2M, Folded]
  ------------------
  340|  16.2M|            switch (*it) {
  341|   174k|            case '{':
  ------------------
  |  Branch (341:13): [True: 174k, False: 16.1M]
  ------------------
  342|   174k|               ++it;
  343|   174k|               if constexpr (not Opts.null_terminated) {
  344|   174k|                  if (it == end) [[unlikely]] {
  ------------------
  |  Branch (344:23): [True: 3, False: 174k]
  ------------------
  345|      3|                     ctx.error = error_code::unexpected_end;
  346|      3|                     return;
  347|      3|                  }
  348|   174k|               }
  349|   174k|               skip_until_closed<Opts, '{', '}'>(ctx, it, end);
  350|   174k|               if (bool(ctx.error)) [[unlikely]]
  ------------------
  |  Branch (350:20): [True: 2.57k, False: 172k]
  ------------------
  351|  2.57k|                  return;
  352|   172k|               break;
  353|   172k|            case '[':
  ------------------
  |  Branch (353:13): [True: 12.2k, False: 16.2M]
  ------------------
  354|  12.2k|               ++it;
  355|  12.2k|               if constexpr (not Opts.null_terminated) {
  356|  12.2k|                  if (it == end) [[unlikely]] {
  ------------------
  |  Branch (356:23): [True: 7, False: 12.2k]
  ------------------
  357|      7|                     ctx.error = error_code::unexpected_end;
  358|      7|                     return;
  359|      7|                  }
  360|  12.2k|               }
  361|  12.2k|               skip_until_closed<Opts, '[', ']'>(ctx, it, end);
  362|  12.2k|               if (bool(ctx.error)) [[unlikely]]
  ------------------
  |  Branch (362:20): [True: 2.73k, False: 9.48k]
  ------------------
  363|  2.73k|                  return;
  364|  9.48k|               break;
  365|  14.2k|            case '"':
  ------------------
  |  Branch (365:13): [True: 14.2k, False: 16.2M]
  ------------------
  366|  14.2k|               skip_string<Opts>(ctx, it, end);
  367|  14.2k|               if (bool(ctx.error)) [[unlikely]]
  ------------------
  |  Branch (367:20): [True: 285, False: 13.9k]
  ------------------
  368|    285|                  return;
  369|  13.9k|               break;
  370|  4.70M|            case ',':
  ------------------
  |  Branch (370:13): [True: 4.70M, False: 11.5M]
  ------------------
  371|  4.70M|            case '}':
  ------------------
  |  Branch (371:13): [True: 1.94k, False: 16.2M]
  ------------------
  372|  4.70M|            case ']':
  ------------------
  |  Branch (372:13): [True: 769, False: 16.2M]
  ------------------
  373|  4.70M|               break;
  374|    687|            case '\0':
  ------------------
  |  Branch (374:13): [True: 687, False: 16.2M]
  ------------------
  375|    687|               ctx.error = error_code::unexpected_end;
  376|    687|               return;
  377|  11.3M|            default: {
  ------------------
  |  Branch (377:13): [True: 11.3M, False: 4.90M]
  ------------------
  378|  11.3M|               ++it;
  379|  11.3M|               if constexpr (not Opts.null_terminated) {
  380|  11.3M|                  if (it == end) [[unlikely]] {
  ------------------
  |  Branch (380:23): [True: 144, False: 11.3M]
  ------------------
  381|    144|                     ctx.error = error_code::unexpected_end;
  382|    144|                     return;
  383|    144|                  }
  384|  11.3M|               }
  385|  11.3M|               continue;
  386|  4.70M|            }
  387|  16.2M|            }
  388|       |
  389|  4.90M|            break;
  390|  16.2M|         }
  391|       |      }
  392|       |      else {
  393|       |         if constexpr (not check_ws_handled(Opts)) {
  394|       |            if (skip_ws<Opts>(ctx, it, end)) {
  395|       |               return;
  396|       |            }
  397|       |         }
  398|       |         switch (*it) {
  399|       |         case '{': {
  400|       |            skip_object<Opts>(ctx, it, end);
  401|       |            break;
  402|       |         }
  403|       |         case '[': {
  404|       |            skip_array<Opts>(ctx, it, end);
  405|       |            break;
  406|       |         }
  407|       |         case '"': {
  408|       |            skip_string<Opts>(ctx, it, end);
  409|       |            break;
  410|       |         }
  411|       |         case 'n': {
  412|       |            ++it;
  413|       |            match<"ull", Opts>(ctx, it, end);
  414|       |            break;
  415|       |         }
  416|       |         case 'f': {
  417|       |            ++it;
  418|       |            match<"alse", Opts>(ctx, it, end);
  419|       |            break;
  420|       |         }
  421|       |         case 't': {
  422|       |            ++it;
  423|       |            match<"rue", Opts>(ctx, it, end);
  424|       |            break;
  425|       |         }
  426|       |         case '\0': {
  427|       |            ctx.error = error_code::unexpected_end;
  428|       |            break;
  429|       |         }
  430|       |         default: {
  431|       |            skip_number<Opts>(ctx, it, end);
  432|       |         }
  433|       |         }
  434|       |      }
  435|  4.90M|   }
_ZN3glz10skip_valueILj10EE2opITnDaXtlNS_22registry_validate_optsIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEEEtlS4_Lj10ELb0ELb0ELb1ELb1EELb1ELb1EEETkNS_10is_contextERNS_7contextERPKcS9_QntdtT_8commentsEEvOT0_OT1_T2_:
  321|   819k|   {
  322|   819k|      using namespace glz::detail;
  323|       |
  324|       |      // Validating skips (parse_value/JSON pointer) require the full value in a
  325|       |      // contiguous buffer, so streaming refill is not applied there.
  326|       |      if constexpr (has_streaming_state<decltype(ctx)> && not check_validate_skipped(Opts)) {
  327|       |         if (ctx.stream.enabled()) {
  328|       |            skip_value_streaming<Opts>(ctx, it, end);
  329|       |            return;
  330|       |         }
  331|       |      }
  332|       |
  333|       |      if constexpr (not check_validate_skipped(Opts)) {
  334|       |         if constexpr (not check_ws_handled(Opts)) {
  335|       |            if (skip_ws<Opts>(ctx, it, end)) {
  336|       |               return;
  337|       |            }
  338|       |         }
  339|       |         while (true) {
  340|       |            switch (*it) {
  341|       |            case '{':
  342|       |               ++it;
  343|       |               if constexpr (not Opts.null_terminated) {
  344|       |                  if (it == end) [[unlikely]] {
  345|       |                     ctx.error = error_code::unexpected_end;
  346|       |                     return;
  347|       |                  }
  348|       |               }
  349|       |               skip_until_closed<Opts, '{', '}'>(ctx, it, end);
  350|       |               if (bool(ctx.error)) [[unlikely]]
  351|       |                  return;
  352|       |               break;
  353|       |            case '[':
  354|       |               ++it;
  355|       |               if constexpr (not Opts.null_terminated) {
  356|       |                  if (it == end) [[unlikely]] {
  357|       |                     ctx.error = error_code::unexpected_end;
  358|       |                     return;
  359|       |                  }
  360|       |               }
  361|       |               skip_until_closed<Opts, '[', ']'>(ctx, it, end);
  362|       |               if (bool(ctx.error)) [[unlikely]]
  363|       |                  return;
  364|       |               break;
  365|       |            case '"':
  366|       |               skip_string<Opts>(ctx, it, end);
  367|       |               if (bool(ctx.error)) [[unlikely]]
  368|       |                  return;
  369|       |               break;
  370|       |            case ',':
  371|       |            case '}':
  372|       |            case ']':
  373|       |               break;
  374|       |            case '\0':
  375|       |               ctx.error = error_code::unexpected_end;
  376|       |               return;
  377|       |            default: {
  378|       |               ++it;
  379|       |               if constexpr (not Opts.null_terminated) {
  380|       |                  if (it == end) [[unlikely]] {
  381|       |                     ctx.error = error_code::unexpected_end;
  382|       |                     return;
  383|       |                  }
  384|       |               }
  385|       |               continue;
  386|       |            }
  387|       |            }
  388|       |
  389|       |            break;
  390|       |         }
  391|       |      }
  392|   819k|      else {
  393|   819k|         if constexpr (not check_ws_handled(Opts)) {
  394|   819k|            if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (394:17): [True: 15, False: 819k]
  ------------------
  395|     15|               return;
  396|     15|            }
  397|   819k|         }
  398|   819k|         switch (*it) {
  399|   115k|         case '{': {
  ------------------
  |  Branch (399:10): [True: 115k, False: 703k]
  ------------------
  400|   115k|            skip_object<Opts>(ctx, it, end);
  401|   115k|            break;
  402|      0|         }
  403|   295k|         case '[': {
  ------------------
  |  Branch (403:10): [True: 295k, False: 523k]
  ------------------
  404|   295k|            skip_array<Opts>(ctx, it, end);
  405|   295k|            break;
  406|      0|         }
  407|  57.7k|         case '"': {
  ------------------
  |  Branch (407:10): [True: 57.7k, False: 761k]
  ------------------
  408|  57.7k|            skip_string<Opts>(ctx, it, end);
  409|  57.7k|            break;
  410|      0|         }
  411|  4.17k|         case 'n': {
  ------------------
  |  Branch (411:10): [True: 4.17k, False: 815k]
  ------------------
  412|  4.17k|            ++it;
  413|  4.17k|            match<"ull", Opts>(ctx, it, end);
  414|  4.17k|            break;
  415|      0|         }
  416|  5.25k|         case 'f': {
  ------------------
  |  Branch (416:10): [True: 5.25k, False: 814k]
  ------------------
  417|  5.25k|            ++it;
  418|  5.25k|            match<"alse", Opts>(ctx, it, end);
  419|  5.25k|            break;
  420|      0|         }
  421|  3.51k|         case 't': {
  ------------------
  |  Branch (421:10): [True: 3.51k, False: 815k]
  ------------------
  422|  3.51k|            ++it;
  423|  3.51k|            match<"rue", Opts>(ctx, it, end);
  424|  3.51k|            break;
  425|      0|         }
  426|  1.45k|         case '\0': {
  ------------------
  |  Branch (426:10): [True: 1.45k, False: 817k]
  ------------------
  427|  1.45k|            ctx.error = error_code::unexpected_end;
  428|  1.45k|            break;
  429|      0|         }
  430|   335k|         default: {
  ------------------
  |  Branch (430:10): [True: 335k, False: 483k]
  ------------------
  431|   335k|            skip_number<Opts>(ctx, it, end);
  432|   335k|         }
  433|   819k|         }
  434|   819k|      }
  435|   819k|   }
_ZN3glz11skip_objectITnDaXtlNS_22registry_validate_optsIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEEEtlS2_Lj10ELb0ELb0ELb1ELb1EELb1ELb1EEETkNS_10is_contextERNS_7contextERPKcS7_EEvOT0_OT1_T2_:
   25|   115k|   {
   26|       |      if constexpr (!check_validate_skipped(Opts)) {
   27|       |         ++it;
   28|       |         if constexpr (not Opts.null_terminated) {
   29|       |            if (it == end) [[unlikely]] {
   30|       |               ctx.error = error_code::unexpected_end;
   31|       |               return;
   32|       |            }
   33|       |         }
   34|       |         skip_until_closed<Opts, '{', '}'>(ctx, it, end);
   35|       |      }
   36|   115k|      else {
   37|       |         // one nesting level (see enter_depth): counted in both modes so the limit binds,
   38|       |         // released at each syntactic close below
   39|   115k|         if (enter_depth(ctx)) [[unlikely]] {
  ------------------
  |  Branch (39:14): [True: 195, False: 115k]
  ------------------
   40|    195|            return;
   41|    195|         }
   42|   115k|         ++it;
   43|   115k|         if constexpr (not Opts.null_terminated) {
   44|   115k|            if (it == end) [[unlikely]] {
  ------------------
  |  Branch (44:17): [True: 3, False: 115k]
  ------------------
   45|      3|               ctx.error = error_code::unexpected_end;
   46|      3|               return;
   47|      3|            }
   48|   115k|         }
   49|   115k|         if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (49:14): [True: 19, False: 115k]
  ------------------
   50|     19|            return;
   51|     19|         }
   52|   115k|         if (*it == '}') {
  ------------------
  |  Branch (52:14): [True: 1.31k, False: 114k]
  ------------------
   53|  1.31k|            --ctx.depth;
   54|  1.31k|            ++it;
   55|  1.31k|            if constexpr (not Opts.null_terminated) {
   56|  1.31k|               if (it == end) {
  ------------------
  |  Branch (56:20): [True: 2, False: 1.30k]
  ------------------
   57|      2|                  ctx.error = error_code::end_reached;
   58|      2|                  return;
   59|      2|               }
   60|  1.31k|            }
   61|  1.30k|            return;
   62|  1.31k|         }
   63|   166k|         while (true) {
  ------------------
  |  Branch (63:17): [True: 166k, Folded]
  ------------------
   64|   166k|            if (*it != '"') {
  ------------------
  |  Branch (64:17): [True: 22.9k, False: 143k]
  ------------------
   65|  22.9k|               ctx.error = error_code::syntax_error;
   66|  22.9k|               return;
   67|  22.9k|            }
   68|   143k|            skip_string<Opts>(ctx, it, end);
   69|   143k|            if (bool(ctx.error)) [[unlikely]]
  ------------------
  |  Branch (69:17): [True: 4.46k, False: 139k]
  ------------------
   70|  4.46k|               return;
   71|   139k|            if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (71:17): [True: 48, False: 139k]
  ------------------
   72|     48|               return;
   73|     48|            }
   74|   139k|            if (match_invalid_end<':', Opts>(ctx, it, end)) {
  ------------------
  |  Branch (74:17): [True: 8.67k, False: 130k]
  ------------------
   75|  8.67k|               return;
   76|  8.67k|            }
   77|   130k|            if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (77:17): [True: 6, False: 130k]
  ------------------
   78|      6|               return;
   79|      6|            }
   80|   130k|            skip_value<JSON>::op<Opts>(ctx, it, end);
   81|   130k|            if (bool(ctx.error)) [[unlikely]]
  ------------------
  |  Branch (81:17): [True: 30.6k, False: 99.9k]
  ------------------
   82|  30.6k|               return;
   83|  99.9k|            if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (83:17): [True: 76, False: 99.9k]
  ------------------
   84|     76|               return;
   85|     76|            }
   86|  99.9k|            if (*it != ',') break;
  ------------------
  |  Branch (86:17): [True: 47.2k, False: 52.7k]
  ------------------
   87|  52.7k|            ++it;
   88|  52.7k|            if constexpr (not Opts.null_terminated) {
   89|  52.7k|               if (it == end) [[unlikely]] {
  ------------------
  |  Branch (89:20): [True: 2, False: 52.7k]
  ------------------
   90|      2|                  ctx.error = error_code::unexpected_end;
   91|      2|                  return;
   92|      2|               }
   93|  52.7k|            }
   94|  52.7k|            if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (94:17): [True: 6, False: 52.6k]
  ------------------
   95|      6|               return;
   96|      6|            }
   97|  52.7k|         }
   98|  47.2k|         match<'}'>(ctx, it);
   99|  47.2k|         --ctx.depth;
  100|  47.2k|         if constexpr (not Opts.null_terminated) {
  101|  47.2k|            if (it == end) {
  ------------------
  |  Branch (101:17): [True: 26.7k, False: 20.5k]
  ------------------
  102|  26.7k|               ctx.error = error_code::end_reached;
  103|  26.7k|               return;
  104|  26.7k|            }
  105|  47.2k|         }
  106|  47.2k|      }
  107|   115k|   }
_ZN3glz10skip_arrayITnDaXtlNS_22registry_validate_optsIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEEEtlS2_Lj10ELb0ELb0ELb1ELb1EELb1ELb1EEETkNS_10is_contextERNS_7contextERPKcS7_QooeqdtT_6formatL_ZNS_4JSONEEeqdtT_6formatL_ZNS_6NDJSONEEEEvOT0_OT1_T2_:
  112|   295k|   {
  113|       |      if constexpr (!check_validate_skipped(Opts)) {
  114|       |         ++it;
  115|       |         if constexpr (not Opts.null_terminated) {
  116|       |            if (it == end) [[unlikely]] {
  117|       |               ctx.error = error_code::unexpected_end;
  118|       |               return;
  119|       |            }
  120|       |         }
  121|       |         skip_until_closed<Opts, '[', ']'>(ctx, it, end);
  122|       |      }
  123|   295k|      else {
  124|       |         // one nesting level (see enter_depth): counted in both modes so the limit binds,
  125|       |         // released at each syntactic close below
  126|   295k|         if (enter_depth(ctx)) [[unlikely]] {
  ------------------
  |  Branch (126:14): [True: 587, False: 295k]
  ------------------
  127|    587|            return;
  128|    587|         }
  129|   295k|         ++it;
  130|   295k|         if constexpr (not Opts.null_terminated) {
  131|   295k|            if (it == end) [[unlikely]] {
  ------------------
  |  Branch (131:17): [True: 1, False: 295k]
  ------------------
  132|      1|               ctx.error = error_code::unexpected_end;
  133|      1|               return;
  134|      1|            }
  135|   295k|         }
  136|   295k|         if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (136:14): [True: 2, False: 295k]
  ------------------
  137|      2|            return;
  138|      2|         }
  139|   295k|         if (*it == ']') {
  ------------------
  |  Branch (139:14): [True: 2.09k, False: 292k]
  ------------------
  140|  2.09k|            --ctx.depth;
  141|  2.09k|            ++it;
  142|  2.09k|            if constexpr (not Opts.null_terminated) {
  143|  2.09k|               if (it == end) {
  ------------------
  |  Branch (143:20): [True: 635, False: 1.46k]
  ------------------
  144|    635|                  ctx.error = error_code::end_reached;
  145|    635|                  return;
  146|    635|               }
  147|  2.09k|            }
  148|  1.46k|            return;
  149|  2.09k|         }
  150|   323k|         while (true) {
  ------------------
  |  Branch (150:17): [True: 323k, Folded]
  ------------------
  151|   323k|            skip_value<JSON>::op<Opts>(ctx, it, end);
  152|   323k|            if (bool(ctx.error)) [[unlikely]]
  ------------------
  |  Branch (152:17): [True: 277k, False: 46.4k]
  ------------------
  153|   277k|               return;
  154|  46.4k|            if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (154:17): [True: 5, False: 46.4k]
  ------------------
  155|      5|               return;
  156|      5|            }
  157|  46.4k|            if (*it != ',') break;
  ------------------
  |  Branch (157:17): [True: 15.4k, False: 31.0k]
  ------------------
  158|  31.0k|            ++it;
  159|  31.0k|            if constexpr (not Opts.null_terminated) {
  160|  31.0k|               if (it == end) [[unlikely]] {
  ------------------
  |  Branch (160:20): [True: 1, False: 30.9k]
  ------------------
  161|      1|                  ctx.error = error_code::unexpected_end;
  162|      1|                  return;
  163|      1|               }
  164|  31.0k|            }
  165|  31.0k|            if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (165:17): [True: 1, False: 30.9k]
  ------------------
  166|      1|               return;
  167|      1|            }
  168|  31.0k|         }
  169|  15.4k|         match<']'>(ctx, it);
  170|  15.4k|         --ctx.depth;
  171|  15.4k|         if constexpr (not Opts.null_terminated) {
  172|  15.4k|            if (it == end) {
  ------------------
  |  Branch (172:17): [True: 272, False: 15.2k]
  ------------------
  173|    272|               ctx.error = error_code::end_reached;
  174|    272|               return;
  175|    272|            }
  176|  15.4k|         }
  177|  15.4k|      }
  178|   295k|   }
_ZN3glz11parse_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETkNS_10is_contextERNS_7contextERPKcS5_EEDaOT0_OT1_T2_:
  308|  19.7k|   {
  309|  19.7k|      auto start = it;
  310|  19.7k|      struct opts_validate_skipped : std::decay_t<decltype(Opts)>
  311|  19.7k|      {
  312|  19.7k|         bool validate_skipped = true;
  313|  19.7k|      };
  314|  19.7k|      skip_value<JSON>::op<opts_validate_skipped{{Opts}}>(ctx, it, end);
  315|  19.7k|      return std::span{start, size_t(it - start)};
  316|  19.7k|   }
_ZN3glz10skip_valueILj10EE2opITnDaXtlZNS_11parse_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETkNS_10is_contextERNS_7contextERPKcS8_EEDaOT0_OT1_T2_E21opts_validate_skippedtlS4_Lj10ELb0ELb0ELb1ELb1EELb1EEETkNS_10is_contextES6_S9_S8_QntdtT_8commentsEEvSB_SD_SE_:
  321|  44.0k|   {
  322|  44.0k|      using namespace glz::detail;
  323|       |
  324|       |      // Validating skips (parse_value/JSON pointer) require the full value in a
  325|       |      // contiguous buffer, so streaming refill is not applied there.
  326|       |      if constexpr (has_streaming_state<decltype(ctx)> && not check_validate_skipped(Opts)) {
  327|       |         if (ctx.stream.enabled()) {
  328|       |            skip_value_streaming<Opts>(ctx, it, end);
  329|       |            return;
  330|       |         }
  331|       |      }
  332|       |
  333|       |      if constexpr (not check_validate_skipped(Opts)) {
  334|       |         if constexpr (not check_ws_handled(Opts)) {
  335|       |            if (skip_ws<Opts>(ctx, it, end)) {
  336|       |               return;
  337|       |            }
  338|       |         }
  339|       |         while (true) {
  340|       |            switch (*it) {
  341|       |            case '{':
  342|       |               ++it;
  343|       |               if constexpr (not Opts.null_terminated) {
  344|       |                  if (it == end) [[unlikely]] {
  345|       |                     ctx.error = error_code::unexpected_end;
  346|       |                     return;
  347|       |                  }
  348|       |               }
  349|       |               skip_until_closed<Opts, '{', '}'>(ctx, it, end);
  350|       |               if (bool(ctx.error)) [[unlikely]]
  351|       |                  return;
  352|       |               break;
  353|       |            case '[':
  354|       |               ++it;
  355|       |               if constexpr (not Opts.null_terminated) {
  356|       |                  if (it == end) [[unlikely]] {
  357|       |                     ctx.error = error_code::unexpected_end;
  358|       |                     return;
  359|       |                  }
  360|       |               }
  361|       |               skip_until_closed<Opts, '[', ']'>(ctx, it, end);
  362|       |               if (bool(ctx.error)) [[unlikely]]
  363|       |                  return;
  364|       |               break;
  365|       |            case '"':
  366|       |               skip_string<Opts>(ctx, it, end);
  367|       |               if (bool(ctx.error)) [[unlikely]]
  368|       |                  return;
  369|       |               break;
  370|       |            case ',':
  371|       |            case '}':
  372|       |            case ']':
  373|       |               break;
  374|       |            case '\0':
  375|       |               ctx.error = error_code::unexpected_end;
  376|       |               return;
  377|       |            default: {
  378|       |               ++it;
  379|       |               if constexpr (not Opts.null_terminated) {
  380|       |                  if (it == end) [[unlikely]] {
  381|       |                     ctx.error = error_code::unexpected_end;
  382|       |                     return;
  383|       |                  }
  384|       |               }
  385|       |               continue;
  386|       |            }
  387|       |            }
  388|       |
  389|       |            break;
  390|       |         }
  391|       |      }
  392|  44.0k|      else {
  393|  44.0k|         if constexpr (not check_ws_handled(Opts)) {
  394|  44.0k|            if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (394:17): [True: 0, False: 44.0k]
  ------------------
  395|      0|               return;
  396|      0|            }
  397|  44.0k|         }
  398|  44.0k|         switch (*it) {
  399|  3.13k|         case '{': {
  ------------------
  |  Branch (399:10): [True: 3.13k, False: 40.9k]
  ------------------
  400|  3.13k|            skip_object<Opts>(ctx, it, end);
  401|  3.13k|            break;
  402|      0|         }
  403|  3.40k|         case '[': {
  ------------------
  |  Branch (403:10): [True: 3.40k, False: 40.6k]
  ------------------
  404|  3.40k|            skip_array<Opts>(ctx, it, end);
  405|  3.40k|            break;
  406|      0|         }
  407|  2.65k|         case '"': {
  ------------------
  |  Branch (407:10): [True: 2.65k, False: 41.4k]
  ------------------
  408|  2.65k|            skip_string<Opts>(ctx, it, end);
  409|  2.65k|            break;
  410|      0|         }
  411|    543|         case 'n': {
  ------------------
  |  Branch (411:10): [True: 543, False: 43.5k]
  ------------------
  412|    543|            ++it;
  413|    543|            match<"ull", Opts>(ctx, it, end);
  414|    543|            break;
  415|      0|         }
  416|  1.17k|         case 'f': {
  ------------------
  |  Branch (416:10): [True: 1.17k, False: 42.9k]
  ------------------
  417|  1.17k|            ++it;
  418|  1.17k|            match<"alse", Opts>(ctx, it, end);
  419|  1.17k|            break;
  420|      0|         }
  421|    869|         case 't': {
  ------------------
  |  Branch (421:10): [True: 869, False: 43.2k]
  ------------------
  422|    869|            ++it;
  423|    869|            match<"rue", Opts>(ctx, it, end);
  424|    869|            break;
  425|      0|         }
  426|      0|         case '\0': {
  ------------------
  |  Branch (426:10): [True: 0, False: 44.0k]
  ------------------
  427|      0|            ctx.error = error_code::unexpected_end;
  428|      0|            break;
  429|      0|         }
  430|  32.2k|         default: {
  ------------------
  |  Branch (430:10): [True: 32.2k, False: 11.7k]
  ------------------
  431|  32.2k|            skip_number<Opts>(ctx, it, end);
  432|  32.2k|         }
  433|  44.0k|         }
  434|  44.0k|      }
  435|  44.0k|   }
_ZN3glz11skip_objectITnDaXtlZNS_11parse_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETkNS_10is_contextERNS_7contextERPKcS6_EEDaOT0_OT1_T2_E21opts_validate_skippedtlS2_Lj10ELb0ELb0ELb1ELb1EELb1EEETkNS_10is_contextES4_S7_S6_EEvS9_SB_SC_:
   25|  3.13k|   {
   26|       |      if constexpr (!check_validate_skipped(Opts)) {
   27|       |         ++it;
   28|       |         if constexpr (not Opts.null_terminated) {
   29|       |            if (it == end) [[unlikely]] {
   30|       |               ctx.error = error_code::unexpected_end;
   31|       |               return;
   32|       |            }
   33|       |         }
   34|       |         skip_until_closed<Opts, '{', '}'>(ctx, it, end);
   35|       |      }
   36|  3.13k|      else {
   37|       |         // one nesting level (see enter_depth): counted in both modes so the limit binds,
   38|       |         // released at each syntactic close below
   39|  3.13k|         if (enter_depth(ctx)) [[unlikely]] {
  ------------------
  |  Branch (39:14): [True: 0, False: 3.13k]
  ------------------
   40|      0|            return;
   41|      0|         }
   42|  3.13k|         ++it;
   43|  3.13k|         if constexpr (not Opts.null_terminated) {
   44|  3.13k|            if (it == end) [[unlikely]] {
  ------------------
  |  Branch (44:17): [True: 0, False: 3.13k]
  ------------------
   45|      0|               ctx.error = error_code::unexpected_end;
   46|      0|               return;
   47|      0|            }
   48|  3.13k|         }
   49|  3.13k|         if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (49:14): [True: 0, False: 3.13k]
  ------------------
   50|      0|            return;
   51|      0|         }
   52|  3.13k|         if (*it == '}') {
  ------------------
  |  Branch (52:14): [True: 553, False: 2.58k]
  ------------------
   53|    553|            --ctx.depth;
   54|    553|            ++it;
   55|    553|            if constexpr (not Opts.null_terminated) {
   56|    553|               if (it == end) {
  ------------------
  |  Branch (56:20): [True: 0, False: 553]
  ------------------
   57|      0|                  ctx.error = error_code::end_reached;
   58|      0|                  return;
   59|      0|               }
   60|    553|            }
   61|    553|            return;
   62|    553|         }
   63|  9.38k|         while (true) {
  ------------------
  |  Branch (63:17): [True: 9.38k, Folded]
  ------------------
   64|  9.38k|            if (*it != '"') {
  ------------------
  |  Branch (64:17): [True: 0, False: 9.38k]
  ------------------
   65|      0|               ctx.error = error_code::syntax_error;
   66|      0|               return;
   67|      0|            }
   68|  9.38k|            skip_string<Opts>(ctx, it, end);
   69|  9.38k|            if (bool(ctx.error)) [[unlikely]]
  ------------------
  |  Branch (69:17): [True: 0, False: 9.38k]
  ------------------
   70|      0|               return;
   71|  9.38k|            if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (71:17): [True: 0, False: 9.38k]
  ------------------
   72|      0|               return;
   73|      0|            }
   74|  9.38k|            if (match_invalid_end<':', Opts>(ctx, it, end)) {
  ------------------
  |  Branch (74:17): [True: 0, False: 9.38k]
  ------------------
   75|      0|               return;
   76|      0|            }
   77|  9.38k|            if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (77:17): [True: 0, False: 9.38k]
  ------------------
   78|      0|               return;
   79|      0|            }
   80|  9.38k|            skip_value<JSON>::op<Opts>(ctx, it, end);
   81|  9.38k|            if (bool(ctx.error)) [[unlikely]]
  ------------------
  |  Branch (81:17): [True: 0, False: 9.38k]
  ------------------
   82|      0|               return;
   83|  9.38k|            if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (83:17): [True: 0, False: 9.38k]
  ------------------
   84|      0|               return;
   85|      0|            }
   86|  9.38k|            if (*it != ',') break;
  ------------------
  |  Branch (86:17): [True: 2.58k, False: 6.80k]
  ------------------
   87|  6.80k|            ++it;
   88|  6.80k|            if constexpr (not Opts.null_terminated) {
   89|  6.80k|               if (it == end) [[unlikely]] {
  ------------------
  |  Branch (89:20): [True: 0, False: 6.80k]
  ------------------
   90|      0|                  ctx.error = error_code::unexpected_end;
   91|      0|                  return;
   92|      0|               }
   93|  6.80k|            }
   94|  6.80k|            if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (94:17): [True: 0, False: 6.80k]
  ------------------
   95|      0|               return;
   96|      0|            }
   97|  6.80k|         }
   98|  2.58k|         match<'}'>(ctx, it);
   99|  2.58k|         --ctx.depth;
  100|  2.58k|         if constexpr (not Opts.null_terminated) {
  101|  2.58k|            if (it == end) {
  ------------------
  |  Branch (101:17): [True: 0, False: 2.58k]
  ------------------
  102|      0|               ctx.error = error_code::end_reached;
  103|      0|               return;
  104|      0|            }
  105|  2.58k|         }
  106|  2.58k|      }
  107|  3.13k|   }
_ZN3glz10skip_arrayITnDaXtlZNS_11parse_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETkNS_10is_contextERNS_7contextERPKcS6_EEDaOT0_OT1_T2_E21opts_validate_skippedtlS2_Lj10ELb0ELb0ELb1ELb1EELb1EEETkNS_10is_contextES4_S7_S6_QooeqdtT_6formatL_ZNS_4JSONEEeqdtT_6formatL_ZNS_6NDJSONEEEEvS9_SB_SC_:
  112|  3.40k|   {
  113|       |      if constexpr (!check_validate_skipped(Opts)) {
  114|       |         ++it;
  115|       |         if constexpr (not Opts.null_terminated) {
  116|       |            if (it == end) [[unlikely]] {
  117|       |               ctx.error = error_code::unexpected_end;
  118|       |               return;
  119|       |            }
  120|       |         }
  121|       |         skip_until_closed<Opts, '[', ']'>(ctx, it, end);
  122|       |      }
  123|  3.40k|      else {
  124|       |         // one nesting level (see enter_depth): counted in both modes so the limit binds,
  125|       |         // released at each syntactic close below
  126|  3.40k|         if (enter_depth(ctx)) [[unlikely]] {
  ------------------
  |  Branch (126:14): [True: 0, False: 3.40k]
  ------------------
  127|      0|            return;
  128|      0|         }
  129|  3.40k|         ++it;
  130|  3.40k|         if constexpr (not Opts.null_terminated) {
  131|  3.40k|            if (it == end) [[unlikely]] {
  ------------------
  |  Branch (131:17): [True: 0, False: 3.40k]
  ------------------
  132|      0|               ctx.error = error_code::unexpected_end;
  133|      0|               return;
  134|      0|            }
  135|  3.40k|         }
  136|  3.40k|         if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (136:14): [True: 0, False: 3.40k]
  ------------------
  137|      0|            return;
  138|      0|         }
  139|  3.40k|         if (*it == ']') {
  ------------------
  |  Branch (139:14): [True: 365, False: 3.04k]
  ------------------
  140|    365|            --ctx.depth;
  141|    365|            ++it;
  142|    365|            if constexpr (not Opts.null_terminated) {
  143|    365|               if (it == end) {
  ------------------
  |  Branch (143:20): [True: 0, False: 365]
  ------------------
  144|      0|                  ctx.error = error_code::end_reached;
  145|      0|                  return;
  146|      0|               }
  147|    365|            }
  148|    365|            return;
  149|    365|         }
  150|  14.9k|         while (true) {
  ------------------
  |  Branch (150:17): [True: 14.9k, Folded]
  ------------------
  151|  14.9k|            skip_value<JSON>::op<Opts>(ctx, it, end);
  152|  14.9k|            if (bool(ctx.error)) [[unlikely]]
  ------------------
  |  Branch (152:17): [True: 0, False: 14.9k]
  ------------------
  153|      0|               return;
  154|  14.9k|            if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (154:17): [True: 0, False: 14.9k]
  ------------------
  155|      0|               return;
  156|      0|            }
  157|  14.9k|            if (*it != ',') break;
  ------------------
  |  Branch (157:17): [True: 3.04k, False: 11.9k]
  ------------------
  158|  11.9k|            ++it;
  159|  11.9k|            if constexpr (not Opts.null_terminated) {
  160|  11.9k|               if (it == end) [[unlikely]] {
  ------------------
  |  Branch (160:20): [True: 0, False: 11.9k]
  ------------------
  161|      0|                  ctx.error = error_code::unexpected_end;
  162|      0|                  return;
  163|      0|               }
  164|  11.9k|            }
  165|  11.9k|            if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (165:17): [True: 0, False: 11.9k]
  ------------------
  166|      0|               return;
  167|      0|            }
  168|  11.9k|         }
  169|  3.04k|         match<']'>(ctx, it);
  170|  3.04k|         --ctx.depth;
  171|  3.04k|         if constexpr (not Opts.null_terminated) {
  172|  3.04k|            if (it == end) {
  ------------------
  |  Branch (172:17): [True: 0, False: 3.04k]
  ------------------
  173|      0|               ctx.error = error_code::end_reached;
  174|      0|               return;
  175|      0|            }
  176|  3.04k|         }
  177|  3.04k|      }
  178|  3.40k|   }

_ZN3glz10write_jsonITkNS_15write_supportedIL_ZNS_4JSONEEEERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEENS2_8expectedIS8_NS_9error_ctxEEEOT_:
 2840|  49.3k|   {
 2841|  49.3k|      return write<opts{}>(std::forward<T>(value));
 2842|  49.3k|   }
_ZN3glz2toILj10ENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE2opITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERS7_RKS7_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_:
  845|  49.3k|      {
  846|       |         if constexpr (check_string_as_number(Opts)) {
  847|       |            const sv str = [&]() -> const sv {
  848|       |               if constexpr (array_char_t<T>) {
  849|       |                  const auto* start = value.data();
  850|       |                  const auto* end = static_cast<const char*>(std::memchr(start, '\0', value.size()));
  851|       |                  return sv{start, end ? size_t(end - start) : value.size()};
  852|       |               }
  853|       |               else if constexpr (u8str_t<T>) {
  854|       |                  return sv{reinterpret_cast<const char*>(value.data()), value.size()};
  855|       |               }
  856|       |               else {
  857|       |                  return str_view<T>(value);
  858|       |               }
  859|       |            }();
  860|       |            if (!ensure_space(ctx, b, ix + str.size() + write_padding_bytes)) [[unlikely]] {
  861|       |               return;
  862|       |            }
  863|       |            dump_maybe_empty<false>(str, b, ix);
  864|       |         }
  865|       |         else if constexpr (char_t<T>) {
  866|       |            if constexpr (check_unquoted(Opts)) {
  867|       |               dump(value, b, ix);
  868|       |            }
  869|       |            else {
  870|       |               // 8 bytes is enough for quotes and escaped character (worst case: \uXXXX = 6 + 2 quotes)
  871|       |               if (!ensure_space(ctx, b, ix + 8)) [[unlikely]] {
  872|       |                  return;
  873|       |               }
  874|       |
  875|       |               std::memcpy(&b[ix], "\"", 1);
  876|       |               ++ix;
  877|       |               if (const auto escaped = char_escape_table[uint8_t(value)]; escaped) {
  878|       |                  std::memcpy(&b[ix], &escaped, 2);
  879|       |                  ix += 2;
  880|       |               }
  881|       |               else if (value == '\0') {
  882|       |                  // null character treated as empty string
  883|       |               }
  884|       |               else if constexpr (check_escape_control_characters(Opts)) {
  885|       |                  if (uint8_t(value) < 0x20) {
  886|       |                     // Write as \uXXXX format
  887|       |                     char unicode_escape[6] = {'\\', 'u', '0', '0', '0', '0'};
  888|       |                     constexpr char hex_digits[] = "0123456789ABCDEF";
  889|       |                     unicode_escape[4] = hex_digits[(value >> 4) & 0xF];
  890|       |                     unicode_escape[5] = hex_digits[value & 0xF];
  891|       |                     std::memcpy(&b[ix], unicode_escape, 6);
  892|       |                     ix += 6;
  893|       |                  }
  894|       |                  else {
  895|       |                     std::memcpy(&b[ix], &value, 1);
  896|       |                     ++ix;
  897|       |                  }
  898|       |               }
  899|       |               else {
  900|       |                  if constexpr (check_reject_control_characters(Opts)) {
  901|       |                     if (uint8_t(value) < 0x20) [[unlikely]] {
  902|       |                        ctx.error = error_code::invalid_control_character;
  903|       |                     }
  904|       |                  }
  905|       |                  std::memcpy(&b[ix], &value, 1);
  906|       |                  ++ix;
  907|       |               }
  908|       |               std::memcpy(&b[ix], "\"", 1);
  909|       |               ++ix;
  910|       |            }
  911|       |         }
  912|  49.3k|         else {
  913|       |            if constexpr (check_raw_string(Opts)) {
  914|       |               const sv str = [&]() -> const sv {
  915|       |                  if constexpr (u8str_t<T>) {
  916|       |                     return sv{reinterpret_cast<const char*>(value.data()), value.size()};
  917|       |                  }
  918|       |                  else {
  919|       |                     return str_view<T>(value);
  920|       |                  }
  921|       |               }();
  922|       |
  923|       |               // We need space for quotes and the string length: 2 + n.
  924|       |               // Use +8 for extra buffer
  925|       |               if (!ensure_space(ctx, b, ix + 8 + str.size())) [[unlikely]] {
  926|       |                  return;
  927|       |               }
  928|       |               // now we don't have to check writing
  929|       |
  930|       |               if constexpr (not check_unquoted(Opts)) {
  931|       |                  std::memcpy(&b[ix], "\"", 1);
  932|       |                  ++ix;
  933|       |               }
  934|       |               if (str.size()) [[likely]] {
  935|       |                  const auto n = str.size();
  936|       |                  std::memcpy(&b[ix], str.data(), n);
  937|       |                  ix += n;
  938|       |               }
  939|       |               if constexpr (not check_unquoted(Opts)) {
  940|       |                  std::memcpy(&b[ix], "\"", 1);
  941|       |                  ++ix;
  942|       |               }
  943|       |            }
  944|  49.3k|            else {
  945|  49.3k|               const sv str = [&]() -> const sv {
  946|  49.3k|                  if constexpr (array_char_t<T>) {
  947|  49.3k|                     return sv{value.data(), value.size()};
  948|  49.3k|                  }
  949|  49.3k|                  else if constexpr (u8str_t<T>) {
  950|  49.3k|                     return sv{reinterpret_cast<const char*>(value.data()), value.size()};
  951|  49.3k|                  }
  952|  49.3k|                  else {
  953|  49.3k|                     return str_view<T>(value);
  954|  49.3k|                  }
  955|  49.3k|               }();
  956|  49.3k|               const auto n = str.size();
  957|       |
  958|       |               // In the case n == 0 we need two characters for quotes.
  959|       |               // For each individual character we need room for two characters to handle escapes.
  960|       |               // When using Unicode escapes, we might need up to 6 characters (\uXXXX) per character
  961|       |               if constexpr (check_escape_control_characters(Opts)) {
  962|       |                  if constexpr (has_bounded_capacity<B>) {
  963|       |                     // 6 bytes per character is a ceiling only a string of nothing but control
  964|       |                     // characters reaches. A resizable buffer merely over-allocates against it,
  965|       |                     // but a fixed buffer has nowhere to grow, so the ceiling would reject output
  966|       |                     // that fits. Measuring the string answers exactly, at the cost of a pass over
  967|       |                     // it, so bracket the measurement between two O(1) bounds and only pay it when
  968|       |                     // the answer is still in doubt: the ceiling fitting means yes, and the floor
  969|       |                     // of one byte per character not fitting means no.
  970|       |                     const size_t capacity = buffer_traits<std::remove_cvref_t<B>>::capacity(b);
  971|       |                     size_t required = ix + 10 + 6 * n;
  972|       |                     if (required > capacity) [[unlikely]] {
  973|       |                        required = ix + 10 + n;
  974|       |                        if (required <= capacity) {
  975|       |                           required = ix + 10 + detail::escaped_string_size(str);
  976|       |                        }
  977|       |                     }
  978|       |                     if (!ensure_space(ctx, b, required)) [[unlikely]] {
  979|       |                        return;
  980|       |                     }
  981|       |                  }
  982|       |                  // We need 2 + 6 * n characters in the worst case (all control chars)
  983|       |                  else if (!ensure_space(ctx, b, ix + 10 + 6 * n)) [[unlikely]] {
  984|       |                     return;
  985|       |                  }
  986|       |               }
  987|  49.3k|               else {
  988|       |                  // Using the original sizing
  989|  49.3k|                  if (!ensure_space(ctx, b, ix + 10 + 2 * n)) [[unlikely]] {
  ------------------
  |  Branch (989:23): [True: 0, False: 49.3k]
  ------------------
  990|      0|                     return;
  991|      0|                  }
  992|  49.3k|               }
  993|       |               // now we don't have to check writing
  994|       |
  995|       |               if constexpr (check_unquoted(Opts)) {
  996|       |                  if (n) {
  997|       |                     std::memcpy(&b[ix], str.data(), n);
  998|       |                     ix += n;
  999|       |                  }
 1000|       |               }
 1001|  49.3k|               else {
 1002|  49.3k|                  std::memcpy(&b[ix], "\"", 1);
 1003|  49.3k|                  ++ix;
 1004|       |
 1005|  49.3k|                  const auto* c = str.data();
 1006|  49.3k|                  const auto* const e = c + n;
 1007|  49.3k|                  const auto start = &b[ix];
 1008|  49.3k|                  auto data = start;
 1009|       |
 1010|       |                  // By default we don't escape control characters for performance. Invalid JSON characters
 1011|       |                  // result in null characters in the output, making the JSON invalid — these would then be
 1012|       |                  // detected upon reading. Enable the `escape_control_characters` option to properly escape
 1013|       |                  // control characters (0x00–0x1F) as \uXXXX sequences.
 1014|       |
 1015|       |                  // Escape handler: writes the escaped form of *c into data, advances both pointers
 1016|  49.3k|                  auto write_escape = [&]() {
 1017|  49.3k|                     if constexpr (check_escape_control_characters(Opts)) {
 1018|  49.3k|                        if (const auto escaped = char_escape_table[uint8_t(*c)]; escaped) {
 1019|  49.3k|                           std::memcpy(data, &escaped, 2);
 1020|  49.3k|                           data += 2;
 1021|  49.3k|                        }
 1022|  49.3k|                        else {
 1023|  49.3k|                           char unicode_escape[6] = {'\\', 'u', '0', '0', '0', '0'};
 1024|  49.3k|                           constexpr char hex_digits[] = "0123456789ABCDEF";
 1025|  49.3k|                           unicode_escape[4] = hex_digits[(uint8_t(*c) >> 4) & 0xF];
 1026|  49.3k|                           unicode_escape[5] = hex_digits[uint8_t(*c) & 0xF];
 1027|  49.3k|                           std::memcpy(data, unicode_escape, 6);
 1028|  49.3k|                           data += 6;
 1029|  49.3k|                        }
 1030|  49.3k|                     }
 1031|  49.3k|                     else {
 1032|  49.3k|                        if constexpr (check_reject_control_characters(Opts)) {
 1033|       |                           // A control character with no two-character escape cannot be written
 1034|       |                           // without \uXXXX. The table entry is zero, so the memcpy below would
 1035|       |                           // put two NULs where one byte was. Flag it and let the loop finish:
 1036|       |                           // returning early here would leave c un-advanced and the SIMD scan
 1037|       |                           // would find the same byte forever. The output is abandoned anyway.
 1038|  49.3k|                           if (char_escape_table[uint8_t(*c)] == 0) [[unlikely]] {
 1039|  49.3k|                              ctx.error = error_code::invalid_control_character;
 1040|  49.3k|                           }
 1041|  49.3k|                        }
 1042|  49.3k|                        std::memcpy(data, &char_escape_table[uint8_t(*c)], 2);
 1043|  49.3k|                        data += 2;
 1044|  49.3k|                     }
 1045|  49.3k|                     ++c;
 1046|  49.3k|                  };
 1047|       |
 1048|       |                  // Adding a helper here means adding a branch to string_escape_simd() in
 1049|       |                  // simd/backends.hpp, which names the widest one this cascade invokes, and a row
 1050|       |                  // to known_builds in tests/json_test/utf8_validation_test.cpp, which checks it.
 1051|       |#if defined(GLZ_USE_AVX2)
 1052|       |                  detail::avx2_string_escape(c, e, data, n, write_escape);
 1053|       |#endif
 1054|  49.3k|#if defined(GLZ_USE_SSE2)
 1055|  49.3k|                  detail::sse2_string_escape(c, e, data, n, write_escape);
 1056|       |#elif defined(GLZ_USE_NEON)
 1057|       |                  detail::neon_string_escape(c, e, data, n, write_escape);
 1058|       |#endif
 1059|       |
 1060|       |                  // SWAR: 8 bytes at a time
 1061|  49.3k|                  if (n > 7) {
  ------------------
  |  Branch (1061:23): [True: 49.3k, False: 0]
  ------------------
 1062|  96.1k|                     for (const auto end_m7 = e - 7; c < end_m7;) {
  ------------------
  |  Branch (1062:54): [True: 46.8k, False: 49.3k]
  ------------------
 1063|  46.8k|                        std::memcpy(data, c, 8);
 1064|  46.8k|                        uint64_t swar;
 1065|  46.8k|                        std::memcpy(&swar, c, 8);
 1066|       |                        if constexpr (std::endian::native == std::endian::big) {
 1067|       |                           swar = std::byteswap(swar);
 1068|       |                        }
 1069|       |
 1070|  46.8k|                        constexpr uint64_t lo7_mask = repeat_byte8(0b01111111);
 1071|  46.8k|                        const uint64_t lo7 = swar & lo7_mask;
 1072|  46.8k|                        const uint64_t quote = (lo7 ^ repeat_byte8('"')) + lo7_mask;
 1073|  46.8k|                        const uint64_t backslash = (lo7 ^ repeat_byte8('\\')) + lo7_mask;
 1074|  46.8k|                        const uint64_t less_32 = (swar & repeat_byte8(0b01100000)) + lo7_mask;
 1075|  46.8k|                        uint64_t next = ~((quote & backslash & less_32) | swar);
 1076|       |
 1077|  46.8k|                        next &= repeat_byte8(0b10000000);
 1078|  46.8k|                        if (next == 0) {
  ------------------
  |  Branch (1078:29): [True: 35.7k, False: 11.0k]
  ------------------
 1079|  35.7k|                           data += 8;
 1080|  35.7k|                           c += 8;
 1081|  35.7k|                           continue;
 1082|  35.7k|                        }
 1083|       |
 1084|  11.0k|                        const auto length = (countr_zero(next) >> 3);
 1085|  11.0k|                        c += length;
 1086|  11.0k|                        data += length;
 1087|  11.0k|                        write_escape();
 1088|  11.0k|                     }
 1089|  49.3k|                  }
 1090|       |
 1091|       |                  // Scalar tail
 1092|   193k|                  for (; c < e; ++c) {
  ------------------
  |  Branch (1092:26): [True: 143k, False: 49.3k]
  ------------------
 1093|   143k|                     if (const auto escaped = char_escape_table[uint8_t(*c)]; escaped) {
  ------------------
  |  Branch (1093:79): [True: 1.93k, False: 142k]
  ------------------
 1094|  1.93k|                        std::memcpy(data, &escaped, 2);
 1095|  1.93k|                        data += 2;
 1096|  1.93k|                     }
 1097|       |                     else if constexpr (check_escape_control_characters(Opts)) {
 1098|       |                        if (uint8_t(*c) < 0x20) {
 1099|       |                           char unicode_escape[6] = {'\\', 'u', '0', '0', '0', '0'};
 1100|       |                           constexpr char hex_digits[] = "0123456789ABCDEF";
 1101|       |                           unicode_escape[4] = hex_digits[(uint8_t(*c) >> 4) & 0xF];
 1102|       |                           unicode_escape[5] = hex_digits[uint8_t(*c) & 0xF];
 1103|       |                           std::memcpy(data, unicode_escape, 6);
 1104|       |                           data += 6;
 1105|       |                        }
 1106|       |                        else {
 1107|       |                           std::memcpy(data, c, 1);
 1108|       |                           ++data;
 1109|       |                        }
 1110|       |                     }
 1111|   142k|                     else {
 1112|       |                        if constexpr (check_reject_control_characters(Opts)) {
 1113|       |                           if (uint8_t(*c) < 0x20) [[unlikely]] {
 1114|       |                              ctx.error = error_code::invalid_control_character;
 1115|       |                           }
 1116|       |                        }
 1117|   142k|                        std::memcpy(data, c, 1);
 1118|   142k|                        ++data;
 1119|   142k|                     }
 1120|   143k|                  }
 1121|       |
 1122|  49.3k|                  ix += size_t(data - start);
 1123|       |
 1124|  49.3k|                  std::memcpy(&b[ix], "\"", 1);
 1125|  49.3k|                  ++ix;
 1126|  49.3k|               }
 1127|  49.3k|            }
 1128|  49.3k|         }
 1129|  49.3k|      }
_ZZN3glz2toILj10ENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE2opITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERS7_RKS7_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_ENKUlvE_clEv:
  945|  49.3k|               const sv str = [&]() -> const sv {
  946|       |                  if constexpr (array_char_t<T>) {
  947|       |                     return sv{value.data(), value.size()};
  948|       |                  }
  949|       |                  else if constexpr (u8str_t<T>) {
  950|       |                     return sv{reinterpret_cast<const char*>(value.data()), value.size()};
  951|       |                  }
  952|  49.3k|                  else {
  953|  49.3k|                     return str_view<T>(value);
  954|  49.3k|                  }
  955|  49.3k|               }();
_ZZN3glz2toILj10ENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE2opITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERS7_RKS7_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_ENKUlvE0_clEv:
 1016|  13.2M|                  auto write_escape = [&]() {
 1017|       |                     if constexpr (check_escape_control_characters(Opts)) {
 1018|       |                        if (const auto escaped = char_escape_table[uint8_t(*c)]; escaped) {
 1019|       |                           std::memcpy(data, &escaped, 2);
 1020|       |                           data += 2;
 1021|       |                        }
 1022|       |                        else {
 1023|       |                           char unicode_escape[6] = {'\\', 'u', '0', '0', '0', '0'};
 1024|       |                           constexpr char hex_digits[] = "0123456789ABCDEF";
 1025|       |                           unicode_escape[4] = hex_digits[(uint8_t(*c) >> 4) & 0xF];
 1026|       |                           unicode_escape[5] = hex_digits[uint8_t(*c) & 0xF];
 1027|       |                           std::memcpy(data, unicode_escape, 6);
 1028|       |                           data += 6;
 1029|       |                        }
 1030|       |                     }
 1031|  13.2M|                     else {
 1032|       |                        if constexpr (check_reject_control_characters(Opts)) {
 1033|       |                           // A control character with no two-character escape cannot be written
 1034|       |                           // without \uXXXX. The table entry is zero, so the memcpy below would
 1035|       |                           // put two NULs where one byte was. Flag it and let the loop finish:
 1036|       |                           // returning early here would leave c un-advanced and the SIMD scan
 1037|       |                           // would find the same byte forever. The output is abandoned anyway.
 1038|       |                           if (char_escape_table[uint8_t(*c)] == 0) [[unlikely]] {
 1039|       |                              ctx.error = error_code::invalid_control_character;
 1040|       |                           }
 1041|       |                        }
 1042|  13.2M|                        std::memcpy(data, &char_escape_table[uint8_t(*c)], 2);
 1043|  13.2M|                        data += 2;
 1044|  13.2M|                     }
 1045|  13.2M|                     ++c;
 1046|  13.2M|                  };
_ZN3glz10write_jsonITkNS_15write_supportedIL_ZNS_4JSONEEEERNSt3__17variantIJDnNS2_17basic_string_viewIcNS2_11char_traitsIcEEEElEEEEENS2_8expectedINS2_12basic_stringIcS6_NS2_9allocatorIcEEEENS_9error_ctxEEEOT_:
 2840|  47.7k|   {
 2841|  47.7k|      return write<opts{}>(std::forward<T>(value));
 2842|  47.7k|   }
_ZN3glz2toILj10ENSt3__17variantIJDnNS1_17basic_string_viewIcNS1_11char_traitsIcEEEElEEEE2opITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERNS1_12basic_stringIcS5_NS1_9allocatorIcEEEERS7_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_:
 1947|  47.7k|      {
 1948|       |         // Adjacent tagging needs no per-alternative dispatch: the discriminator and the value are
 1949|       |         // written side by side whatever the alternative is. The visit below still instantiates in
 1950|       |         // that mode (`if constexpr` does not discard the statements after it), but both of its
 1951|       |         // tagged branches are compile-time dead there and the runtime `return` keeps it unreached.
 1952|       |         if constexpr (check_write_type_info(Opts) && tagging == variant_tagging_kind::adjacent) {
 1953|       |            write_adjacent<Opts>(value, ctx, b, ix);
 1954|       |            return;
 1955|       |         }
 1956|  47.7k|         std::visit(
 1957|  47.7k|            [&](auto&& val) {
 1958|  47.7k|               using V = std::decay_t<decltype(val)>;
 1959|       |
 1960|  47.7k|               if constexpr (check_write_type_info(Opts) && tagging == variant_tagging_kind::internal &&
 1961|  47.7k|                             custom_write<V>) {
 1962|       |                  // Custom alternative: the user's serializer emits the object body, into which we
 1963|       |                  // merge the variant tag. For this to produce valid JSON the custom to<> must (1)
 1964|       |                  // write an object body and (2) honor opening_and_closing_handled (suppress its own
 1965|       |                  // braces) so the tag shares the alternative's object. A custom writer that emits a
 1966|       |                  // scalar/array, or that ignores those flags, would yield malformed output.
 1967|       |                  //
 1968|       |                  // The tag-emission below mirrors the reflected-object branch that follows; keep the
 1969|       |                  // two in sync. The body size is not known at compile time, so we always write the
 1970|       |                  // tag separator and then drop it at runtime if the body turned out empty.
 1971|  47.7k|                  if (missing_id(value, ctx)) {
 1972|  47.7k|                     return;
 1973|  47.7k|                  }
 1974|  47.7k|                  using id_type = std::decay_t<decltype(ids_v<T>[value.index()])>;
 1975|  47.7k|                  if constexpr (Opts.prettify) {
 1976|  47.7k|                     dump("{\n", b, ix);
 1977|  47.7k|                     ctx.depth += check_indentation_width(Opts);
 1978|  47.7k|                     dumpn(check_indentation_char(Opts), ctx.depth, b, ix);
 1979|  47.7k|                     dump('"', b, ix);
 1980|  47.7k|                     dump_maybe_empty(tag_v<T>, b, ix);
 1981|  47.7k|                     if constexpr (std::integral<id_type>) {
 1982|  47.7k|                        dump("\": ", b, ix);
 1983|  47.7k|                        serialize<JSON>::op<Opts>(ids_v<T>[value.index()], ctx, b, ix);
 1984|  47.7k|                     }
 1985|  47.7k|                     else {
 1986|  47.7k|                        dump("\": \"", b, ix);
 1987|  47.7k|                        dump_maybe_empty(ids_v<T>[value.index()], b, ix);
 1988|  47.7k|                        dump('"', b, ix);
 1989|  47.7k|                     }
 1990|  47.7k|                     const auto pos_after_tag = ix;
 1991|  47.7k|                     dump(",\n", b, ix);
 1992|  47.7k|                     dumpn(check_indentation_char(Opts), ctx.depth, b, ix);
 1993|  47.7k|                     const auto pos_body_start = ix;
 1994|  47.7k|                     to<JSON, V>::template op<opening_and_closing_handled<Opts>()>(val, ctx, b, ix);
 1995|  47.7k|                     if (ix == pos_body_start) {
 1996|  47.7k|                        ix = pos_after_tag; // custom body was empty: undo the tag separator
 1997|  47.7k|                     }
 1998|  47.7k|                     ctx.depth -= check_indentation_width(Opts);
 1999|  47.7k|                     if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] {
 2000|  47.7k|                        return;
 2001|  47.7k|                     }
 2002|  47.7k|                     std::memcpy(&b[ix], "\n", 1);
 2003|  47.7k|                     ++ix;
 2004|  47.7k|                     std::memset(&b[ix], check_indentation_char(Opts), ctx.depth);
 2005|  47.7k|                     ix += ctx.depth;
 2006|  47.7k|                     std::memcpy(&b[ix], "}", 1);
 2007|  47.7k|                     ++ix;
 2008|  47.7k|                  }
 2009|  47.7k|                  else {
 2010|  47.7k|                     dump("{\"", b, ix);
 2011|  47.7k|                     dump_maybe_empty(tag_v<T>, b, ix);
 2012|  47.7k|                     if constexpr (std::integral<id_type>) {
 2013|  47.7k|                        dump("\":", b, ix);
 2014|  47.7k|                        serialize<JSON>::op<Opts>(ids_v<T>[value.index()], ctx, b, ix);
 2015|  47.7k|                     }
 2016|  47.7k|                     else {
 2017|  47.7k|                        dump("\":\"", b, ix);
 2018|  47.7k|                        dump_maybe_empty(ids_v<T>[value.index()], b, ix);
 2019|  47.7k|                        dump('"', b, ix);
 2020|  47.7k|                     }
 2021|  47.7k|                     const auto pos_after_tag = ix;
 2022|  47.7k|                     dump(',', b, ix);
 2023|  47.7k|                     const auto pos_body_start = ix;
 2024|  47.7k|                     to<JSON, V>::template op<opening_and_closing_handled<Opts>()>(val, ctx, b, ix);
 2025|  47.7k|                     if (ix == pos_body_start) {
 2026|  47.7k|                        ix = pos_after_tag; // custom body was empty: undo the tag separator
 2027|  47.7k|                     }
 2028|  47.7k|                     dump('}', b, ix);
 2029|  47.7k|                  }
 2030|  47.7k|               }
 2031|  47.7k|               else if constexpr (check_write_type_info(Opts) && tagging == variant_tagging_kind::internal &&
 2032|  47.7k|                                  variant_unit_alternative<V>) {
 2033|       |                  // A unit alternative carries no data, so internal tagging renders it as the
 2034|       |                  // discriminator alone -- the same object an empty struct alternative produces.
 2035|  47.7k|                  if (missing_id(value, ctx)) {
 2036|  47.7k|                     return;
 2037|  47.7k|                  }
 2038|  47.7k|                  if constexpr (Opts.prettify) {
 2039|  47.7k|                     dump("{\n", b, ix);
 2040|  47.7k|                     ctx.depth += check_indentation_width(Opts);
 2041|  47.7k|                     dumpn(check_indentation_char(Opts), ctx.depth, b, ix);
 2042|  47.7k|                     dump('"', b, ix);
 2043|  47.7k|                     dump_maybe_empty(tag_v<T>, b, ix);
 2044|  47.7k|                     dump("\": ", b, ix);
 2045|  47.7k|                     write_id<Opts>(value, ctx, b, ix);
 2046|  47.7k|                     ctx.depth -= check_indentation_width(Opts);
 2047|  47.7k|                     if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] {
 2048|  47.7k|                        return;
 2049|  47.7k|                     }
 2050|  47.7k|                     std::memcpy(&b[ix], "\n", 1);
 2051|  47.7k|                     ++ix;
 2052|  47.7k|                     std::memset(&b[ix], check_indentation_char(Opts), ctx.depth);
 2053|  47.7k|                     ix += ctx.depth;
 2054|  47.7k|                     std::memcpy(&b[ix], "}", 1);
 2055|  47.7k|                     ++ix;
 2056|  47.7k|                  }
 2057|  47.7k|                  else {
 2058|  47.7k|                     dump("{\"", b, ix);
 2059|  47.7k|                     dump_maybe_empty(tag_v<T>, b, ix);
 2060|  47.7k|                     dump("\":", b, ix);
 2061|  47.7k|                     write_id<Opts>(value, ctx, b, ix);
 2062|  47.7k|                     dump('}', b, ix);
 2063|  47.7k|                  }
 2064|  47.7k|               }
 2065|  47.7k|               else if constexpr (check_write_type_info(Opts) && tagging == variant_tagging_kind::internal &&
 2066|  47.7k|                                  (glaze_object_t<V> || reflectable<V> || is_memory_object<V>) &&
 2067|  47.7k|                                  (not alternative_declares_key<V>(tag_v<T>))) {
 2068|       |                  // An alternative that declares a member named like the discriminator carries the
 2069|       |                  // discriminator itself, so no tag is merged here and the bare-write branch below
 2070|       |                  // handles it. Previously only `reflectable` alternatives were excluded; a
 2071|       |                  // `glaze_object_t` one fell through to this branch and emitted the key twice.
 2072|  47.7k|                  if (missing_id(value, ctx)) {
 2073|  47.7k|                     return;
 2074|  47.7k|                  }
 2075|  47.7k|                  constexpr auto N = []() {
 2076|  47.7k|                     if constexpr (is_memory_object<V>) {
 2077|  47.7k|                        return reflect<memory_type<V>>::size;
 2078|  47.7k|                     }
 2079|  47.7k|                     else {
 2080|  47.7k|                        return reflect<V>::size;
 2081|  47.7k|                     }
 2082|  47.7k|                  }();
 2083|       |
 2084|       |                  // must first write out type
 2085|  47.7k|                  if constexpr (Opts.prettify) {
 2086|  47.7k|                     dump("{\n", b, ix);
 2087|  47.7k|                     ctx.depth += check_indentation_width(Opts);
 2088|  47.7k|                     dumpn(check_indentation_char(Opts), ctx.depth, b, ix);
 2089|  47.7k|                     dump('"', b, ix);
 2090|  47.7k|                     dump_maybe_empty(tag_v<T>, b, ix);
 2091|       |
 2092|  47.7k|                     using id_type = std::decay_t<decltype(ids_v<T>[value.index()])>;
 2093|       |
 2094|  47.7k|                     if constexpr (std::integral<id_type>) {
 2095|  47.7k|                        dump("\": ", b, ix);
 2096|  47.7k|                        serialize<JSON>::op<Opts>(ids_v<T>[value.index()], ctx, b, ix);
 2097|  47.7k|                        if constexpr (N > 0) {
 2098|  47.7k|                           dump(",\n", b, ix);
 2099|  47.7k|                           dumpn(check_indentation_char(Opts), ctx.depth, b, ix);
 2100|  47.7k|                        }
 2101|  47.7k|                     }
 2102|  47.7k|                     else {
 2103|  47.7k|                        dump("\": \"", b, ix);
 2104|  47.7k|                        dump_maybe_empty(ids_v<T>[value.index()], b, ix);
 2105|  47.7k|                        if constexpr (N == 0) {
 2106|  47.7k|                           dump('"', b, ix);
 2107|  47.7k|                        }
 2108|  47.7k|                        else {
 2109|  47.7k|                           dump("\",\n", b, ix);
 2110|  47.7k|                           dumpn(check_indentation_char(Opts), ctx.depth, b, ix);
 2111|  47.7k|                        }
 2112|  47.7k|                     }
 2113|  47.7k|                  }
 2114|  47.7k|                  else {
 2115|  47.7k|                     using id_type = std::decay_t<decltype(ids_v<T>[value.index()])>;
 2116|       |
 2117|  47.7k|                     dump("{\"", b, ix);
 2118|  47.7k|                     dump_maybe_empty(tag_v<T>, b, ix);
 2119|       |
 2120|  47.7k|                     if constexpr (std::integral<id_type>) {
 2121|  47.7k|                        dump("\":", b, ix);
 2122|  47.7k|                        serialize<JSON>::op<Opts>(ids_v<T>[value.index()], ctx, b, ix);
 2123|  47.7k|                        if constexpr (N > 0) {
 2124|  47.7k|                           dump(',', b, ix);
 2125|  47.7k|                        }
 2126|  47.7k|                     }
 2127|  47.7k|                     else {
 2128|  47.7k|                        dump("\":\"", b, ix);
 2129|  47.7k|                        dump_maybe_empty(ids_v<T>[value.index()], b, ix);
 2130|  47.7k|                        if constexpr (N == 0) {
 2131|  47.7k|                           dump('"', b, ix);
 2132|  47.7k|                        }
 2133|  47.7k|                        else {
 2134|  47.7k|                           dump("\",", b, ix);
 2135|  47.7k|                        }
 2136|  47.7k|                     }
 2137|  47.7k|                  }
 2138|  47.7k|                  if constexpr (is_memory_object<V>) {
 2139|  47.7k|                     if (!val) [[unlikely]] {
 2140|  47.7k|                        ctx.error = error_code::invalid_variant_object;
 2141|  47.7k|                        return;
 2142|  47.7k|                     }
 2143|  47.7k|                     to<JSON, memory_type<V>>::template op<opening_and_closing_handled<Opts>()>(*val, ctx, b, ix);
 2144|  47.7k|                  }
 2145|  47.7k|                  else {
 2146|  47.7k|                     to<JSON, V>::template op<opening_and_closing_handled<Opts>()>(val, ctx, b, ix);
 2147|  47.7k|                  }
 2148|       |                  // If we skip everything then we may have an extra comma, which we want to revert
 2149|  47.7k|                  if constexpr (Opts.skip_null_members) {
 2150|  47.7k|                     if (b[ix - 1] == ',') {
 2151|  47.7k|                        --ix;
 2152|  47.7k|                     }
 2153|  47.7k|                  }
 2154|       |
 2155|  47.7k|                  if constexpr (Opts.prettify) {
 2156|  47.7k|                     ctx.depth -= check_indentation_width(Opts);
 2157|  47.7k|                     if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] {
 2158|  47.7k|                        return;
 2159|  47.7k|                     }
 2160|  47.7k|                     std::memcpy(&b[ix], "\n", 1);
 2161|  47.7k|                     ++ix;
 2162|  47.7k|                     std::memset(&b[ix], check_indentation_char(Opts), ctx.depth);
 2163|  47.7k|                     ix += ctx.depth;
 2164|  47.7k|                     std::memcpy(&b[ix], "}", 1);
 2165|  47.7k|                     ++ix;
 2166|  47.7k|                  }
 2167|  47.7k|                  else {
 2168|  47.7k|                     dump('}', b, ix);
 2169|  47.7k|                  }
 2170|  47.7k|               }
 2171|  47.7k|               else {
 2172|  47.7k|                  to<JSON, V>::template op<Opts>(val, ctx, b, ix);
 2173|  47.7k|               }
 2174|  47.7k|            },
 2175|  47.7k|            value);
 2176|  47.7k|      }
_ZZN3glz2toILj10ENSt3__17variantIJDnNS1_17basic_string_viewIcNS1_11char_traitsIcEEEElEEEE2opITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERNS1_12basic_stringIcS5_NS1_9allocatorIcEEEERS7_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_ENKUlOT_E_clIRDnEEDaSS_:
 1957|  9.11k|            [&](auto&& val) {
 1958|  9.11k|               using V = std::decay_t<decltype(val)>;
 1959|       |
 1960|       |               if constexpr (check_write_type_info(Opts) && tagging == variant_tagging_kind::internal &&
 1961|       |                             custom_write<V>) {
 1962|       |                  // Custom alternative: the user's serializer emits the object body, into which we
 1963|       |                  // merge the variant tag. For this to produce valid JSON the custom to<> must (1)
 1964|       |                  // write an object body and (2) honor opening_and_closing_handled (suppress its own
 1965|       |                  // braces) so the tag shares the alternative's object. A custom writer that emits a
 1966|       |                  // scalar/array, or that ignores those flags, would yield malformed output.
 1967|       |                  //
 1968|       |                  // The tag-emission below mirrors the reflected-object branch that follows; keep the
 1969|       |                  // two in sync. The body size is not known at compile time, so we always write the
 1970|       |                  // tag separator and then drop it at runtime if the body turned out empty.
 1971|       |                  if (missing_id(value, ctx)) {
 1972|       |                     return;
 1973|       |                  }
 1974|       |                  using id_type = std::decay_t<decltype(ids_v<T>[value.index()])>;
 1975|       |                  if constexpr (Opts.prettify) {
 1976|       |                     dump("{\n", b, ix);
 1977|       |                     ctx.depth += check_indentation_width(Opts);
 1978|       |                     dumpn(check_indentation_char(Opts), ctx.depth, b, ix);
 1979|       |                     dump('"', b, ix);
 1980|       |                     dump_maybe_empty(tag_v<T>, b, ix);
 1981|       |                     if constexpr (std::integral<id_type>) {
 1982|       |                        dump("\": ", b, ix);
 1983|       |                        serialize<JSON>::op<Opts>(ids_v<T>[value.index()], ctx, b, ix);
 1984|       |                     }
 1985|       |                     else {
 1986|       |                        dump("\": \"", b, ix);
 1987|       |                        dump_maybe_empty(ids_v<T>[value.index()], b, ix);
 1988|       |                        dump('"', b, ix);
 1989|       |                     }
 1990|       |                     const auto pos_after_tag = ix;
 1991|       |                     dump(",\n", b, ix);
 1992|       |                     dumpn(check_indentation_char(Opts), ctx.depth, b, ix);
 1993|       |                     const auto pos_body_start = ix;
 1994|       |                     to<JSON, V>::template op<opening_and_closing_handled<Opts>()>(val, ctx, b, ix);
 1995|       |                     if (ix == pos_body_start) {
 1996|       |                        ix = pos_after_tag; // custom body was empty: undo the tag separator
 1997|       |                     }
 1998|       |                     ctx.depth -= check_indentation_width(Opts);
 1999|       |                     if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] {
 2000|       |                        return;
 2001|       |                     }
 2002|       |                     std::memcpy(&b[ix], "\n", 1);
 2003|       |                     ++ix;
 2004|       |                     std::memset(&b[ix], check_indentation_char(Opts), ctx.depth);
 2005|       |                     ix += ctx.depth;
 2006|       |                     std::memcpy(&b[ix], "}", 1);
 2007|       |                     ++ix;
 2008|       |                  }
 2009|       |                  else {
 2010|       |                     dump("{\"", b, ix);
 2011|       |                     dump_maybe_empty(tag_v<T>, b, ix);
 2012|       |                     if constexpr (std::integral<id_type>) {
 2013|       |                        dump("\":", b, ix);
 2014|       |                        serialize<JSON>::op<Opts>(ids_v<T>[value.index()], ctx, b, ix);
 2015|       |                     }
 2016|       |                     else {
 2017|       |                        dump("\":\"", b, ix);
 2018|       |                        dump_maybe_empty(ids_v<T>[value.index()], b, ix);
 2019|       |                        dump('"', b, ix);
 2020|       |                     }
 2021|       |                     const auto pos_after_tag = ix;
 2022|       |                     dump(',', b, ix);
 2023|       |                     const auto pos_body_start = ix;
 2024|       |                     to<JSON, V>::template op<opening_and_closing_handled<Opts>()>(val, ctx, b, ix);
 2025|       |                     if (ix == pos_body_start) {
 2026|       |                        ix = pos_after_tag; // custom body was empty: undo the tag separator
 2027|       |                     }
 2028|       |                     dump('}', b, ix);
 2029|       |                  }
 2030|       |               }
 2031|       |               else if constexpr (check_write_type_info(Opts) && tagging == variant_tagging_kind::internal &&
 2032|       |                                  variant_unit_alternative<V>) {
 2033|       |                  // A unit alternative carries no data, so internal tagging renders it as the
 2034|       |                  // discriminator alone -- the same object an empty struct alternative produces.
 2035|       |                  if (missing_id(value, ctx)) {
 2036|       |                     return;
 2037|       |                  }
 2038|       |                  if constexpr (Opts.prettify) {
 2039|       |                     dump("{\n", b, ix);
 2040|       |                     ctx.depth += check_indentation_width(Opts);
 2041|       |                     dumpn(check_indentation_char(Opts), ctx.depth, b, ix);
 2042|       |                     dump('"', b, ix);
 2043|       |                     dump_maybe_empty(tag_v<T>, b, ix);
 2044|       |                     dump("\": ", b, ix);
 2045|       |                     write_id<Opts>(value, ctx, b, ix);
 2046|       |                     ctx.depth -= check_indentation_width(Opts);
 2047|       |                     if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] {
 2048|       |                        return;
 2049|       |                     }
 2050|       |                     std::memcpy(&b[ix], "\n", 1);
 2051|       |                     ++ix;
 2052|       |                     std::memset(&b[ix], check_indentation_char(Opts), ctx.depth);
 2053|       |                     ix += ctx.depth;
 2054|       |                     std::memcpy(&b[ix], "}", 1);
 2055|       |                     ++ix;
 2056|       |                  }
 2057|       |                  else {
 2058|       |                     dump("{\"", b, ix);
 2059|       |                     dump_maybe_empty(tag_v<T>, b, ix);
 2060|       |                     dump("\":", b, ix);
 2061|       |                     write_id<Opts>(value, ctx, b, ix);
 2062|       |                     dump('}', b, ix);
 2063|       |                  }
 2064|       |               }
 2065|       |               else if constexpr (check_write_type_info(Opts) && tagging == variant_tagging_kind::internal &&
 2066|       |                                  (glaze_object_t<V> || reflectable<V> || is_memory_object<V>) &&
 2067|       |                                  (not alternative_declares_key<V>(tag_v<T>))) {
 2068|       |                  // An alternative that declares a member named like the discriminator carries the
 2069|       |                  // discriminator itself, so no tag is merged here and the bare-write branch below
 2070|       |                  // handles it. Previously only `reflectable` alternatives were excluded; a
 2071|       |                  // `glaze_object_t` one fell through to this branch and emitted the key twice.
 2072|       |                  if (missing_id(value, ctx)) {
 2073|       |                     return;
 2074|       |                  }
 2075|       |                  constexpr auto N = []() {
 2076|       |                     if constexpr (is_memory_object<V>) {
 2077|       |                        return reflect<memory_type<V>>::size;
 2078|       |                     }
 2079|       |                     else {
 2080|       |                        return reflect<V>::size;
 2081|       |                     }
 2082|       |                  }();
 2083|       |
 2084|       |                  // must first write out type
 2085|       |                  if constexpr (Opts.prettify) {
 2086|       |                     dump("{\n", b, ix);
 2087|       |                     ctx.depth += check_indentation_width(Opts);
 2088|       |                     dumpn(check_indentation_char(Opts), ctx.depth, b, ix);
 2089|       |                     dump('"', b, ix);
 2090|       |                     dump_maybe_empty(tag_v<T>, b, ix);
 2091|       |
 2092|       |                     using id_type = std::decay_t<decltype(ids_v<T>[value.index()])>;
 2093|       |
 2094|       |                     if constexpr (std::integral<id_type>) {
 2095|       |                        dump("\": ", b, ix);
 2096|       |                        serialize<JSON>::op<Opts>(ids_v<T>[value.index()], ctx, b, ix);
 2097|       |                        if constexpr (N > 0) {
 2098|       |                           dump(",\n", b, ix);
 2099|       |                           dumpn(check_indentation_char(Opts), ctx.depth, b, ix);
 2100|       |                        }
 2101|       |                     }
 2102|       |                     else {
 2103|       |                        dump("\": \"", b, ix);
 2104|       |                        dump_maybe_empty(ids_v<T>[value.index()], b, ix);
 2105|       |                        if constexpr (N == 0) {
 2106|       |                           dump('"', b, ix);
 2107|       |                        }
 2108|       |                        else {
 2109|       |                           dump("\",\n", b, ix);
 2110|       |                           dumpn(check_indentation_char(Opts), ctx.depth, b, ix);
 2111|       |                        }
 2112|       |                     }
 2113|       |                  }
 2114|       |                  else {
 2115|       |                     using id_type = std::decay_t<decltype(ids_v<T>[value.index()])>;
 2116|       |
 2117|       |                     dump("{\"", b, ix);
 2118|       |                     dump_maybe_empty(tag_v<T>, b, ix);
 2119|       |
 2120|       |                     if constexpr (std::integral<id_type>) {
 2121|       |                        dump("\":", b, ix);
 2122|       |                        serialize<JSON>::op<Opts>(ids_v<T>[value.index()], ctx, b, ix);
 2123|       |                        if constexpr (N > 0) {
 2124|       |                           dump(',', b, ix);
 2125|       |                        }
 2126|       |                     }
 2127|       |                     else {
 2128|       |                        dump("\":\"", b, ix);
 2129|       |                        dump_maybe_empty(ids_v<T>[value.index()], b, ix);
 2130|       |                        if constexpr (N == 0) {
 2131|       |                           dump('"', b, ix);
 2132|       |                        }
 2133|       |                        else {
 2134|       |                           dump("\",", b, ix);
 2135|       |                        }
 2136|       |                     }
 2137|       |                  }
 2138|       |                  if constexpr (is_memory_object<V>) {
 2139|       |                     if (!val) [[unlikely]] {
 2140|       |                        ctx.error = error_code::invalid_variant_object;
 2141|       |                        return;
 2142|       |                     }
 2143|       |                     to<JSON, memory_type<V>>::template op<opening_and_closing_handled<Opts>()>(*val, ctx, b, ix);
 2144|       |                  }
 2145|       |                  else {
 2146|       |                     to<JSON, V>::template op<opening_and_closing_handled<Opts>()>(val, ctx, b, ix);
 2147|       |                  }
 2148|       |                  // If we skip everything then we may have an extra comma, which we want to revert
 2149|       |                  if constexpr (Opts.skip_null_members) {
 2150|       |                     if (b[ix - 1] == ',') {
 2151|       |                        --ix;
 2152|       |                     }
 2153|       |                  }
 2154|       |
 2155|       |                  if constexpr (Opts.prettify) {
 2156|       |                     ctx.depth -= check_indentation_width(Opts);
 2157|       |                     if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] {
 2158|       |                        return;
 2159|       |                     }
 2160|       |                     std::memcpy(&b[ix], "\n", 1);
 2161|       |                     ++ix;
 2162|       |                     std::memset(&b[ix], check_indentation_char(Opts), ctx.depth);
 2163|       |                     ix += ctx.depth;
 2164|       |                     std::memcpy(&b[ix], "}", 1);
 2165|       |                     ++ix;
 2166|       |                  }
 2167|       |                  else {
 2168|       |                     dump('}', b, ix);
 2169|       |                  }
 2170|       |               }
 2171|  9.11k|               else {
 2172|  9.11k|                  to<JSON, V>::template op<Opts>(val, ctx, b, ix);
 2173|  9.11k|               }
 2174|  9.11k|            },
_ZN3glz2toILj10EDnE2opITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERDnTkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_:
 1841|  9.11k|      {
 1842|  9.11k|         if constexpr (not check_write_unchecked(Opts)) {
 1843|  9.11k|            if (!ensure_space(ctx, b, ix + 4)) [[unlikely]] {
  ------------------
  |  Branch (1843:17): [True: 0, False: 9.11k]
  ------------------
 1844|      0|               return;
 1845|      0|            }
 1846|  9.11k|         }
 1847|       |         if constexpr (std::endian::native == std::endian::big) {
 1848|       |            static constexpr char null_v[] = "null";
 1849|       |            std::memcpy(&b[ix], null_v, 4);
 1850|       |         }
 1851|  9.11k|         else {
 1852|  9.11k|            static constexpr uint32_t null_v = 1819047278;
 1853|  9.11k|            std::memcpy(&b[ix], &null_v, 4);
 1854|  9.11k|         }
 1855|  9.11k|         ix += 4;
 1856|  9.11k|      }
_ZZN3glz2toILj10ENSt3__17variantIJDnNS1_17basic_string_viewIcNS1_11char_traitsIcEEEElEEEE2opITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERNS1_12basic_stringIcS5_NS1_9allocatorIcEEEERS7_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_ENKUlOT_E_clIRS6_EEDaSS_:
 1957|  5.77k|            [&](auto&& val) {
 1958|  5.77k|               using V = std::decay_t<decltype(val)>;
 1959|       |
 1960|       |               if constexpr (check_write_type_info(Opts) && tagging == variant_tagging_kind::internal &&
 1961|       |                             custom_write<V>) {
 1962|       |                  // Custom alternative: the user's serializer emits the object body, into which we
 1963|       |                  // merge the variant tag. For this to produce valid JSON the custom to<> must (1)
 1964|       |                  // write an object body and (2) honor opening_and_closing_handled (suppress its own
 1965|       |                  // braces) so the tag shares the alternative's object. A custom writer that emits a
 1966|       |                  // scalar/array, or that ignores those flags, would yield malformed output.
 1967|       |                  //
 1968|       |                  // The tag-emission below mirrors the reflected-object branch that follows; keep the
 1969|       |                  // two in sync. The body size is not known at compile time, so we always write the
 1970|       |                  // tag separator and then drop it at runtime if the body turned out empty.
 1971|       |                  if (missing_id(value, ctx)) {
 1972|       |                     return;
 1973|       |                  }
 1974|       |                  using id_type = std::decay_t<decltype(ids_v<T>[value.index()])>;
 1975|       |                  if constexpr (Opts.prettify) {
 1976|       |                     dump("{\n", b, ix);
 1977|       |                     ctx.depth += check_indentation_width(Opts);
 1978|       |                     dumpn(check_indentation_char(Opts), ctx.depth, b, ix);
 1979|       |                     dump('"', b, ix);
 1980|       |                     dump_maybe_empty(tag_v<T>, b, ix);
 1981|       |                     if constexpr (std::integral<id_type>) {
 1982|       |                        dump("\": ", b, ix);
 1983|       |                        serialize<JSON>::op<Opts>(ids_v<T>[value.index()], ctx, b, ix);
 1984|       |                     }
 1985|       |                     else {
 1986|       |                        dump("\": \"", b, ix);
 1987|       |                        dump_maybe_empty(ids_v<T>[value.index()], b, ix);
 1988|       |                        dump('"', b, ix);
 1989|       |                     }
 1990|       |                     const auto pos_after_tag = ix;
 1991|       |                     dump(",\n", b, ix);
 1992|       |                     dumpn(check_indentation_char(Opts), ctx.depth, b, ix);
 1993|       |                     const auto pos_body_start = ix;
 1994|       |                     to<JSON, V>::template op<opening_and_closing_handled<Opts>()>(val, ctx, b, ix);
 1995|       |                     if (ix == pos_body_start) {
 1996|       |                        ix = pos_after_tag; // custom body was empty: undo the tag separator
 1997|       |                     }
 1998|       |                     ctx.depth -= check_indentation_width(Opts);
 1999|       |                     if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] {
 2000|       |                        return;
 2001|       |                     }
 2002|       |                     std::memcpy(&b[ix], "\n", 1);
 2003|       |                     ++ix;
 2004|       |                     std::memset(&b[ix], check_indentation_char(Opts), ctx.depth);
 2005|       |                     ix += ctx.depth;
 2006|       |                     std::memcpy(&b[ix], "}", 1);
 2007|       |                     ++ix;
 2008|       |                  }
 2009|       |                  else {
 2010|       |                     dump("{\"", b, ix);
 2011|       |                     dump_maybe_empty(tag_v<T>, b, ix);
 2012|       |                     if constexpr (std::integral<id_type>) {
 2013|       |                        dump("\":", b, ix);
 2014|       |                        serialize<JSON>::op<Opts>(ids_v<T>[value.index()], ctx, b, ix);
 2015|       |                     }
 2016|       |                     else {
 2017|       |                        dump("\":\"", b, ix);
 2018|       |                        dump_maybe_empty(ids_v<T>[value.index()], b, ix);
 2019|       |                        dump('"', b, ix);
 2020|       |                     }
 2021|       |                     const auto pos_after_tag = ix;
 2022|       |                     dump(',', b, ix);
 2023|       |                     const auto pos_body_start = ix;
 2024|       |                     to<JSON, V>::template op<opening_and_closing_handled<Opts>()>(val, ctx, b, ix);
 2025|       |                     if (ix == pos_body_start) {
 2026|       |                        ix = pos_after_tag; // custom body was empty: undo the tag separator
 2027|       |                     }
 2028|       |                     dump('}', b, ix);
 2029|       |                  }
 2030|       |               }
 2031|       |               else if constexpr (check_write_type_info(Opts) && tagging == variant_tagging_kind::internal &&
 2032|       |                                  variant_unit_alternative<V>) {
 2033|       |                  // A unit alternative carries no data, so internal tagging renders it as the
 2034|       |                  // discriminator alone -- the same object an empty struct alternative produces.
 2035|       |                  if (missing_id(value, ctx)) {
 2036|       |                     return;
 2037|       |                  }
 2038|       |                  if constexpr (Opts.prettify) {
 2039|       |                     dump("{\n", b, ix);
 2040|       |                     ctx.depth += check_indentation_width(Opts);
 2041|       |                     dumpn(check_indentation_char(Opts), ctx.depth, b, ix);
 2042|       |                     dump('"', b, ix);
 2043|       |                     dump_maybe_empty(tag_v<T>, b, ix);
 2044|       |                     dump("\": ", b, ix);
 2045|       |                     write_id<Opts>(value, ctx, b, ix);
 2046|       |                     ctx.depth -= check_indentation_width(Opts);
 2047|       |                     if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] {
 2048|       |                        return;
 2049|       |                     }
 2050|       |                     std::memcpy(&b[ix], "\n", 1);
 2051|       |                     ++ix;
 2052|       |                     std::memset(&b[ix], check_indentation_char(Opts), ctx.depth);
 2053|       |                     ix += ctx.depth;
 2054|       |                     std::memcpy(&b[ix], "}", 1);
 2055|       |                     ++ix;
 2056|       |                  }
 2057|       |                  else {
 2058|       |                     dump("{\"", b, ix);
 2059|       |                     dump_maybe_empty(tag_v<T>, b, ix);
 2060|       |                     dump("\":", b, ix);
 2061|       |                     write_id<Opts>(value, ctx, b, ix);
 2062|       |                     dump('}', b, ix);
 2063|       |                  }
 2064|       |               }
 2065|       |               else if constexpr (check_write_type_info(Opts) && tagging == variant_tagging_kind::internal &&
 2066|       |                                  (glaze_object_t<V> || reflectable<V> || is_memory_object<V>) &&
 2067|       |                                  (not alternative_declares_key<V>(tag_v<T>))) {
 2068|       |                  // An alternative that declares a member named like the discriminator carries the
 2069|       |                  // discriminator itself, so no tag is merged here and the bare-write branch below
 2070|       |                  // handles it. Previously only `reflectable` alternatives were excluded; a
 2071|       |                  // `glaze_object_t` one fell through to this branch and emitted the key twice.
 2072|       |                  if (missing_id(value, ctx)) {
 2073|       |                     return;
 2074|       |                  }
 2075|       |                  constexpr auto N = []() {
 2076|       |                     if constexpr (is_memory_object<V>) {
 2077|       |                        return reflect<memory_type<V>>::size;
 2078|       |                     }
 2079|       |                     else {
 2080|       |                        return reflect<V>::size;
 2081|       |                     }
 2082|       |                  }();
 2083|       |
 2084|       |                  // must first write out type
 2085|       |                  if constexpr (Opts.prettify) {
 2086|       |                     dump("{\n", b, ix);
 2087|       |                     ctx.depth += check_indentation_width(Opts);
 2088|       |                     dumpn(check_indentation_char(Opts), ctx.depth, b, ix);
 2089|       |                     dump('"', b, ix);
 2090|       |                     dump_maybe_empty(tag_v<T>, b, ix);
 2091|       |
 2092|       |                     using id_type = std::decay_t<decltype(ids_v<T>[value.index()])>;
 2093|       |
 2094|       |                     if constexpr (std::integral<id_type>) {
 2095|       |                        dump("\": ", b, ix);
 2096|       |                        serialize<JSON>::op<Opts>(ids_v<T>[value.index()], ctx, b, ix);
 2097|       |                        if constexpr (N > 0) {
 2098|       |                           dump(",\n", b, ix);
 2099|       |                           dumpn(check_indentation_char(Opts), ctx.depth, b, ix);
 2100|       |                        }
 2101|       |                     }
 2102|       |                     else {
 2103|       |                        dump("\": \"", b, ix);
 2104|       |                        dump_maybe_empty(ids_v<T>[value.index()], b, ix);
 2105|       |                        if constexpr (N == 0) {
 2106|       |                           dump('"', b, ix);
 2107|       |                        }
 2108|       |                        else {
 2109|       |                           dump("\",\n", b, ix);
 2110|       |                           dumpn(check_indentation_char(Opts), ctx.depth, b, ix);
 2111|       |                        }
 2112|       |                     }
 2113|       |                  }
 2114|       |                  else {
 2115|       |                     using id_type = std::decay_t<decltype(ids_v<T>[value.index()])>;
 2116|       |
 2117|       |                     dump("{\"", b, ix);
 2118|       |                     dump_maybe_empty(tag_v<T>, b, ix);
 2119|       |
 2120|       |                     if constexpr (std::integral<id_type>) {
 2121|       |                        dump("\":", b, ix);
 2122|       |                        serialize<JSON>::op<Opts>(ids_v<T>[value.index()], ctx, b, ix);
 2123|       |                        if constexpr (N > 0) {
 2124|       |                           dump(',', b, ix);
 2125|       |                        }
 2126|       |                     }
 2127|       |                     else {
 2128|       |                        dump("\":\"", b, ix);
 2129|       |                        dump_maybe_empty(ids_v<T>[value.index()], b, ix);
 2130|       |                        if constexpr (N == 0) {
 2131|       |                           dump('"', b, ix);
 2132|       |                        }
 2133|       |                        else {
 2134|       |                           dump("\",", b, ix);
 2135|       |                        }
 2136|       |                     }
 2137|       |                  }
 2138|       |                  if constexpr (is_memory_object<V>) {
 2139|       |                     if (!val) [[unlikely]] {
 2140|       |                        ctx.error = error_code::invalid_variant_object;
 2141|       |                        return;
 2142|       |                     }
 2143|       |                     to<JSON, memory_type<V>>::template op<opening_and_closing_handled<Opts>()>(*val, ctx, b, ix);
 2144|       |                  }
 2145|       |                  else {
 2146|       |                     to<JSON, V>::template op<opening_and_closing_handled<Opts>()>(val, ctx, b, ix);
 2147|       |                  }
 2148|       |                  // If we skip everything then we may have an extra comma, which we want to revert
 2149|       |                  if constexpr (Opts.skip_null_members) {
 2150|       |                     if (b[ix - 1] == ',') {
 2151|       |                        --ix;
 2152|       |                     }
 2153|       |                  }
 2154|       |
 2155|       |                  if constexpr (Opts.prettify) {
 2156|       |                     ctx.depth -= check_indentation_width(Opts);
 2157|       |                     if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] {
 2158|       |                        return;
 2159|       |                     }
 2160|       |                     std::memcpy(&b[ix], "\n", 1);
 2161|       |                     ++ix;
 2162|       |                     std::memset(&b[ix], check_indentation_char(Opts), ctx.depth);
 2163|       |                     ix += ctx.depth;
 2164|       |                     std::memcpy(&b[ix], "}", 1);
 2165|       |                     ++ix;
 2166|       |                  }
 2167|       |                  else {
 2168|       |                     dump('}', b, ix);
 2169|       |                  }
 2170|       |               }
 2171|  5.77k|               else {
 2172|  5.77k|                  to<JSON, V>::template op<Opts>(val, ctx, b, ix);
 2173|  5.77k|               }
 2174|  5.77k|            },
_ZN3glz2toILj10ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEE2opITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERNS1_12basic_stringIcS4_NS1_9allocatorIcEEEERS5_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_:
  845|  5.77k|      {
  846|       |         if constexpr (check_string_as_number(Opts)) {
  847|       |            const sv str = [&]() -> const sv {
  848|       |               if constexpr (array_char_t<T>) {
  849|       |                  const auto* start = value.data();
  850|       |                  const auto* end = static_cast<const char*>(std::memchr(start, '\0', value.size()));
  851|       |                  return sv{start, end ? size_t(end - start) : value.size()};
  852|       |               }
  853|       |               else if constexpr (u8str_t<T>) {
  854|       |                  return sv{reinterpret_cast<const char*>(value.data()), value.size()};
  855|       |               }
  856|       |               else {
  857|       |                  return str_view<T>(value);
  858|       |               }
  859|       |            }();
  860|       |            if (!ensure_space(ctx, b, ix + str.size() + write_padding_bytes)) [[unlikely]] {
  861|       |               return;
  862|       |            }
  863|       |            dump_maybe_empty<false>(str, b, ix);
  864|       |         }
  865|       |         else if constexpr (char_t<T>) {
  866|       |            if constexpr (check_unquoted(Opts)) {
  867|       |               dump(value, b, ix);
  868|       |            }
  869|       |            else {
  870|       |               // 8 bytes is enough for quotes and escaped character (worst case: \uXXXX = 6 + 2 quotes)
  871|       |               if (!ensure_space(ctx, b, ix + 8)) [[unlikely]] {
  872|       |                  return;
  873|       |               }
  874|       |
  875|       |               std::memcpy(&b[ix], "\"", 1);
  876|       |               ++ix;
  877|       |               if (const auto escaped = char_escape_table[uint8_t(value)]; escaped) {
  878|       |                  std::memcpy(&b[ix], &escaped, 2);
  879|       |                  ix += 2;
  880|       |               }
  881|       |               else if (value == '\0') {
  882|       |                  // null character treated as empty string
  883|       |               }
  884|       |               else if constexpr (check_escape_control_characters(Opts)) {
  885|       |                  if (uint8_t(value) < 0x20) {
  886|       |                     // Write as \uXXXX format
  887|       |                     char unicode_escape[6] = {'\\', 'u', '0', '0', '0', '0'};
  888|       |                     constexpr char hex_digits[] = "0123456789ABCDEF";
  889|       |                     unicode_escape[4] = hex_digits[(value >> 4) & 0xF];
  890|       |                     unicode_escape[5] = hex_digits[value & 0xF];
  891|       |                     std::memcpy(&b[ix], unicode_escape, 6);
  892|       |                     ix += 6;
  893|       |                  }
  894|       |                  else {
  895|       |                     std::memcpy(&b[ix], &value, 1);
  896|       |                     ++ix;
  897|       |                  }
  898|       |               }
  899|       |               else {
  900|       |                  if constexpr (check_reject_control_characters(Opts)) {
  901|       |                     if (uint8_t(value) < 0x20) [[unlikely]] {
  902|       |                        ctx.error = error_code::invalid_control_character;
  903|       |                     }
  904|       |                  }
  905|       |                  std::memcpy(&b[ix], &value, 1);
  906|       |                  ++ix;
  907|       |               }
  908|       |               std::memcpy(&b[ix], "\"", 1);
  909|       |               ++ix;
  910|       |            }
  911|       |         }
  912|  5.77k|         else {
  913|       |            if constexpr (check_raw_string(Opts)) {
  914|       |               const sv str = [&]() -> const sv {
  915|       |                  if constexpr (u8str_t<T>) {
  916|       |                     return sv{reinterpret_cast<const char*>(value.data()), value.size()};
  917|       |                  }
  918|       |                  else {
  919|       |                     return str_view<T>(value);
  920|       |                  }
  921|       |               }();
  922|       |
  923|       |               // We need space for quotes and the string length: 2 + n.
  924|       |               // Use +8 for extra buffer
  925|       |               if (!ensure_space(ctx, b, ix + 8 + str.size())) [[unlikely]] {
  926|       |                  return;
  927|       |               }
  928|       |               // now we don't have to check writing
  929|       |
  930|       |               if constexpr (not check_unquoted(Opts)) {
  931|       |                  std::memcpy(&b[ix], "\"", 1);
  932|       |                  ++ix;
  933|       |               }
  934|       |               if (str.size()) [[likely]] {
  935|       |                  const auto n = str.size();
  936|       |                  std::memcpy(&b[ix], str.data(), n);
  937|       |                  ix += n;
  938|       |               }
  939|       |               if constexpr (not check_unquoted(Opts)) {
  940|       |                  std::memcpy(&b[ix], "\"", 1);
  941|       |                  ++ix;
  942|       |               }
  943|       |            }
  944|  5.77k|            else {
  945|  5.77k|               const sv str = [&]() -> const sv {
  946|  5.77k|                  if constexpr (array_char_t<T>) {
  947|  5.77k|                     return sv{value.data(), value.size()};
  948|  5.77k|                  }
  949|  5.77k|                  else if constexpr (u8str_t<T>) {
  950|  5.77k|                     return sv{reinterpret_cast<const char*>(value.data()), value.size()};
  951|  5.77k|                  }
  952|  5.77k|                  else {
  953|  5.77k|                     return str_view<T>(value);
  954|  5.77k|                  }
  955|  5.77k|               }();
  956|  5.77k|               const auto n = str.size();
  957|       |
  958|       |               // In the case n == 0 we need two characters for quotes.
  959|       |               // For each individual character we need room for two characters to handle escapes.
  960|       |               // When using Unicode escapes, we might need up to 6 characters (\uXXXX) per character
  961|       |               if constexpr (check_escape_control_characters(Opts)) {
  962|       |                  if constexpr (has_bounded_capacity<B>) {
  963|       |                     // 6 bytes per character is a ceiling only a string of nothing but control
  964|       |                     // characters reaches. A resizable buffer merely over-allocates against it,
  965|       |                     // but a fixed buffer has nowhere to grow, so the ceiling would reject output
  966|       |                     // that fits. Measuring the string answers exactly, at the cost of a pass over
  967|       |                     // it, so bracket the measurement between two O(1) bounds and only pay it when
  968|       |                     // the answer is still in doubt: the ceiling fitting means yes, and the floor
  969|       |                     // of one byte per character not fitting means no.
  970|       |                     const size_t capacity = buffer_traits<std::remove_cvref_t<B>>::capacity(b);
  971|       |                     size_t required = ix + 10 + 6 * n;
  972|       |                     if (required > capacity) [[unlikely]] {
  973|       |                        required = ix + 10 + n;
  974|       |                        if (required <= capacity) {
  975|       |                           required = ix + 10 + detail::escaped_string_size(str);
  976|       |                        }
  977|       |                     }
  978|       |                     if (!ensure_space(ctx, b, required)) [[unlikely]] {
  979|       |                        return;
  980|       |                     }
  981|       |                  }
  982|       |                  // We need 2 + 6 * n characters in the worst case (all control chars)
  983|       |                  else if (!ensure_space(ctx, b, ix + 10 + 6 * n)) [[unlikely]] {
  984|       |                     return;
  985|       |                  }
  986|       |               }
  987|  5.77k|               else {
  988|       |                  // Using the original sizing
  989|  5.77k|                  if (!ensure_space(ctx, b, ix + 10 + 2 * n)) [[unlikely]] {
  ------------------
  |  Branch (989:23): [True: 0, False: 5.77k]
  ------------------
  990|      0|                     return;
  991|      0|                  }
  992|  5.77k|               }
  993|       |               // now we don't have to check writing
  994|       |
  995|       |               if constexpr (check_unquoted(Opts)) {
  996|       |                  if (n) {
  997|       |                     std::memcpy(&b[ix], str.data(), n);
  998|       |                     ix += n;
  999|       |                  }
 1000|       |               }
 1001|  5.77k|               else {
 1002|  5.77k|                  std::memcpy(&b[ix], "\"", 1);
 1003|  5.77k|                  ++ix;
 1004|       |
 1005|  5.77k|                  const auto* c = str.data();
 1006|  5.77k|                  const auto* const e = c + n;
 1007|  5.77k|                  const auto start = &b[ix];
 1008|  5.77k|                  auto data = start;
 1009|       |
 1010|       |                  // By default we don't escape control characters for performance. Invalid JSON characters
 1011|       |                  // result in null characters in the output, making the JSON invalid — these would then be
 1012|       |                  // detected upon reading. Enable the `escape_control_characters` option to properly escape
 1013|       |                  // control characters (0x00–0x1F) as \uXXXX sequences.
 1014|       |
 1015|       |                  // Escape handler: writes the escaped form of *c into data, advances both pointers
 1016|  5.77k|                  auto write_escape = [&]() {
 1017|  5.77k|                     if constexpr (check_escape_control_characters(Opts)) {
 1018|  5.77k|                        if (const auto escaped = char_escape_table[uint8_t(*c)]; escaped) {
 1019|  5.77k|                           std::memcpy(data, &escaped, 2);
 1020|  5.77k|                           data += 2;
 1021|  5.77k|                        }
 1022|  5.77k|                        else {
 1023|  5.77k|                           char unicode_escape[6] = {'\\', 'u', '0', '0', '0', '0'};
 1024|  5.77k|                           constexpr char hex_digits[] = "0123456789ABCDEF";
 1025|  5.77k|                           unicode_escape[4] = hex_digits[(uint8_t(*c) >> 4) & 0xF];
 1026|  5.77k|                           unicode_escape[5] = hex_digits[uint8_t(*c) & 0xF];
 1027|  5.77k|                           std::memcpy(data, unicode_escape, 6);
 1028|  5.77k|                           data += 6;
 1029|  5.77k|                        }
 1030|  5.77k|                     }
 1031|  5.77k|                     else {
 1032|  5.77k|                        if constexpr (check_reject_control_characters(Opts)) {
 1033|       |                           // A control character with no two-character escape cannot be written
 1034|       |                           // without \uXXXX. The table entry is zero, so the memcpy below would
 1035|       |                           // put two NULs where one byte was. Flag it and let the loop finish:
 1036|       |                           // returning early here would leave c un-advanced and the SIMD scan
 1037|       |                           // would find the same byte forever. The output is abandoned anyway.
 1038|  5.77k|                           if (char_escape_table[uint8_t(*c)] == 0) [[unlikely]] {
 1039|  5.77k|                              ctx.error = error_code::invalid_control_character;
 1040|  5.77k|                           }
 1041|  5.77k|                        }
 1042|  5.77k|                        std::memcpy(data, &char_escape_table[uint8_t(*c)], 2);
 1043|  5.77k|                        data += 2;
 1044|  5.77k|                     }
 1045|  5.77k|                     ++c;
 1046|  5.77k|                  };
 1047|       |
 1048|       |                  // Adding a helper here means adding a branch to string_escape_simd() in
 1049|       |                  // simd/backends.hpp, which names the widest one this cascade invokes, and a row
 1050|       |                  // to known_builds in tests/json_test/utf8_validation_test.cpp, which checks it.
 1051|       |#if defined(GLZ_USE_AVX2)
 1052|       |                  detail::avx2_string_escape(c, e, data, n, write_escape);
 1053|       |#endif
 1054|  5.77k|#if defined(GLZ_USE_SSE2)
 1055|  5.77k|                  detail::sse2_string_escape(c, e, data, n, write_escape);
 1056|       |#elif defined(GLZ_USE_NEON)
 1057|       |                  detail::neon_string_escape(c, e, data, n, write_escape);
 1058|       |#endif
 1059|       |
 1060|       |                  // SWAR: 8 bytes at a time
 1061|  5.77k|                  if (n > 7) {
  ------------------
  |  Branch (1061:23): [True: 3.98k, False: 1.78k]
  ------------------
 1062|  14.6k|                     for (const auto end_m7 = e - 7; c < end_m7;) {
  ------------------
  |  Branch (1062:54): [True: 10.6k, False: 3.98k]
  ------------------
 1063|  10.6k|                        std::memcpy(data, c, 8);
 1064|  10.6k|                        uint64_t swar;
 1065|  10.6k|                        std::memcpy(&swar, c, 8);
 1066|       |                        if constexpr (std::endian::native == std::endian::big) {
 1067|       |                           swar = std::byteswap(swar);
 1068|       |                        }
 1069|       |
 1070|  10.6k|                        constexpr uint64_t lo7_mask = repeat_byte8(0b01111111);
 1071|  10.6k|                        const uint64_t lo7 = swar & lo7_mask;
 1072|  10.6k|                        const uint64_t quote = (lo7 ^ repeat_byte8('"')) + lo7_mask;
 1073|  10.6k|                        const uint64_t backslash = (lo7 ^ repeat_byte8('\\')) + lo7_mask;
 1074|  10.6k|                        const uint64_t less_32 = (swar & repeat_byte8(0b01100000)) + lo7_mask;
 1075|  10.6k|                        uint64_t next = ~((quote & backslash & less_32) | swar);
 1076|       |
 1077|  10.6k|                        next &= repeat_byte8(0b10000000);
 1078|  10.6k|                        if (next == 0) {
  ------------------
  |  Branch (1078:29): [True: 1.46k, False: 9.21k]
  ------------------
 1079|  1.46k|                           data += 8;
 1080|  1.46k|                           c += 8;
 1081|  1.46k|                           continue;
 1082|  1.46k|                        }
 1083|       |
 1084|  9.21k|                        const auto length = (countr_zero(next) >> 3);
 1085|  9.21k|                        c += length;
 1086|  9.21k|                        data += length;
 1087|  9.21k|                        write_escape();
 1088|  9.21k|                     }
 1089|  3.98k|                  }
 1090|       |
 1091|       |                  // Scalar tail
 1092|  28.7k|                  for (; c < e; ++c) {
  ------------------
  |  Branch (1092:26): [True: 22.9k, False: 5.77k]
  ------------------
 1093|  22.9k|                     if (const auto escaped = char_escape_table[uint8_t(*c)]; escaped) {
  ------------------
  |  Branch (1093:79): [True: 1.50k, False: 21.4k]
  ------------------
 1094|  1.50k|                        std::memcpy(data, &escaped, 2);
 1095|  1.50k|                        data += 2;
 1096|  1.50k|                     }
 1097|       |                     else if constexpr (check_escape_control_characters(Opts)) {
 1098|       |                        if (uint8_t(*c) < 0x20) {
 1099|       |                           char unicode_escape[6] = {'\\', 'u', '0', '0', '0', '0'};
 1100|       |                           constexpr char hex_digits[] = "0123456789ABCDEF";
 1101|       |                           unicode_escape[4] = hex_digits[(uint8_t(*c) >> 4) & 0xF];
 1102|       |                           unicode_escape[5] = hex_digits[uint8_t(*c) & 0xF];
 1103|       |                           std::memcpy(data, unicode_escape, 6);
 1104|       |                           data += 6;
 1105|       |                        }
 1106|       |                        else {
 1107|       |                           std::memcpy(data, c, 1);
 1108|       |                           ++data;
 1109|       |                        }
 1110|       |                     }
 1111|  21.4k|                     else {
 1112|       |                        if constexpr (check_reject_control_characters(Opts)) {
 1113|       |                           if (uint8_t(*c) < 0x20) [[unlikely]] {
 1114|       |                              ctx.error = error_code::invalid_control_character;
 1115|       |                           }
 1116|       |                        }
 1117|  21.4k|                        std::memcpy(data, c, 1);
 1118|  21.4k|                        ++data;
 1119|  21.4k|                     }
 1120|  22.9k|                  }
 1121|       |
 1122|  5.77k|                  ix += size_t(data - start);
 1123|       |
 1124|  5.77k|                  std::memcpy(&b[ix], "\"", 1);
 1125|  5.77k|                  ++ix;
 1126|  5.77k|               }
 1127|  5.77k|            }
 1128|  5.77k|         }
 1129|  5.77k|      }
_ZZN3glz2toILj10ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEE2opITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERNS1_12basic_stringIcS4_NS1_9allocatorIcEEEERS5_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_ENKUlvE_clEv:
  945|  5.77k|               const sv str = [&]() -> const sv {
  946|       |                  if constexpr (array_char_t<T>) {
  947|       |                     return sv{value.data(), value.size()};
  948|       |                  }
  949|       |                  else if constexpr (u8str_t<T>) {
  950|       |                     return sv{reinterpret_cast<const char*>(value.data()), value.size()};
  951|       |                  }
  952|  5.77k|                  else {
  953|  5.77k|                     return str_view<T>(value);
  954|  5.77k|                  }
  955|  5.77k|               }();
_ZZN3glz2toILj10ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEE2opITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERNS1_12basic_stringIcS4_NS1_9allocatorIcEEEERS5_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_ENKUlvE0_clEv:
 1016|  27.9M|                  auto write_escape = [&]() {
 1017|       |                     if constexpr (check_escape_control_characters(Opts)) {
 1018|       |                        if (const auto escaped = char_escape_table[uint8_t(*c)]; escaped) {
 1019|       |                           std::memcpy(data, &escaped, 2);
 1020|       |                           data += 2;
 1021|       |                        }
 1022|       |                        else {
 1023|       |                           char unicode_escape[6] = {'\\', 'u', '0', '0', '0', '0'};
 1024|       |                           constexpr char hex_digits[] = "0123456789ABCDEF";
 1025|       |                           unicode_escape[4] = hex_digits[(uint8_t(*c) >> 4) & 0xF];
 1026|       |                           unicode_escape[5] = hex_digits[uint8_t(*c) & 0xF];
 1027|       |                           std::memcpy(data, unicode_escape, 6);
 1028|       |                           data += 6;
 1029|       |                        }
 1030|       |                     }
 1031|  27.9M|                     else {
 1032|       |                        if constexpr (check_reject_control_characters(Opts)) {
 1033|       |                           // A control character with no two-character escape cannot be written
 1034|       |                           // without \uXXXX. The table entry is zero, so the memcpy below would
 1035|       |                           // put two NULs where one byte was. Flag it and let the loop finish:
 1036|       |                           // returning early here would leave c un-advanced and the SIMD scan
 1037|       |                           // would find the same byte forever. The output is abandoned anyway.
 1038|       |                           if (char_escape_table[uint8_t(*c)] == 0) [[unlikely]] {
 1039|       |                              ctx.error = error_code::invalid_control_character;
 1040|       |                           }
 1041|       |                        }
 1042|  27.9M|                        std::memcpy(data, &char_escape_table[uint8_t(*c)], 2);
 1043|  27.9M|                        data += 2;
 1044|  27.9M|                     }
 1045|  27.9M|                     ++c;
 1046|  27.9M|                  };
_ZZN3glz2toILj10ENSt3__17variantIJDnNS1_17basic_string_viewIcNS1_11char_traitsIcEEEElEEEE2opITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERNS1_12basic_stringIcS5_NS1_9allocatorIcEEEERS7_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_ENKUlOT_E_clIRlEEDaSS_:
 1957|  32.8k|            [&](auto&& val) {
 1958|  32.8k|               using V = std::decay_t<decltype(val)>;
 1959|       |
 1960|       |               if constexpr (check_write_type_info(Opts) && tagging == variant_tagging_kind::internal &&
 1961|       |                             custom_write<V>) {
 1962|       |                  // Custom alternative: the user's serializer emits the object body, into which we
 1963|       |                  // merge the variant tag. For this to produce valid JSON the custom to<> must (1)
 1964|       |                  // write an object body and (2) honor opening_and_closing_handled (suppress its own
 1965|       |                  // braces) so the tag shares the alternative's object. A custom writer that emits a
 1966|       |                  // scalar/array, or that ignores those flags, would yield malformed output.
 1967|       |                  //
 1968|       |                  // The tag-emission below mirrors the reflected-object branch that follows; keep the
 1969|       |                  // two in sync. The body size is not known at compile time, so we always write the
 1970|       |                  // tag separator and then drop it at runtime if the body turned out empty.
 1971|       |                  if (missing_id(value, ctx)) {
 1972|       |                     return;
 1973|       |                  }
 1974|       |                  using id_type = std::decay_t<decltype(ids_v<T>[value.index()])>;
 1975|       |                  if constexpr (Opts.prettify) {
 1976|       |                     dump("{\n", b, ix);
 1977|       |                     ctx.depth += check_indentation_width(Opts);
 1978|       |                     dumpn(check_indentation_char(Opts), ctx.depth, b, ix);
 1979|       |                     dump('"', b, ix);
 1980|       |                     dump_maybe_empty(tag_v<T>, b, ix);
 1981|       |                     if constexpr (std::integral<id_type>) {
 1982|       |                        dump("\": ", b, ix);
 1983|       |                        serialize<JSON>::op<Opts>(ids_v<T>[value.index()], ctx, b, ix);
 1984|       |                     }
 1985|       |                     else {
 1986|       |                        dump("\": \"", b, ix);
 1987|       |                        dump_maybe_empty(ids_v<T>[value.index()], b, ix);
 1988|       |                        dump('"', b, ix);
 1989|       |                     }
 1990|       |                     const auto pos_after_tag = ix;
 1991|       |                     dump(",\n", b, ix);
 1992|       |                     dumpn(check_indentation_char(Opts), ctx.depth, b, ix);
 1993|       |                     const auto pos_body_start = ix;
 1994|       |                     to<JSON, V>::template op<opening_and_closing_handled<Opts>()>(val, ctx, b, ix);
 1995|       |                     if (ix == pos_body_start) {
 1996|       |                        ix = pos_after_tag; // custom body was empty: undo the tag separator
 1997|       |                     }
 1998|       |                     ctx.depth -= check_indentation_width(Opts);
 1999|       |                     if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] {
 2000|       |                        return;
 2001|       |                     }
 2002|       |                     std::memcpy(&b[ix], "\n", 1);
 2003|       |                     ++ix;
 2004|       |                     std::memset(&b[ix], check_indentation_char(Opts), ctx.depth);
 2005|       |                     ix += ctx.depth;
 2006|       |                     std::memcpy(&b[ix], "}", 1);
 2007|       |                     ++ix;
 2008|       |                  }
 2009|       |                  else {
 2010|       |                     dump("{\"", b, ix);
 2011|       |                     dump_maybe_empty(tag_v<T>, b, ix);
 2012|       |                     if constexpr (std::integral<id_type>) {
 2013|       |                        dump("\":", b, ix);
 2014|       |                        serialize<JSON>::op<Opts>(ids_v<T>[value.index()], ctx, b, ix);
 2015|       |                     }
 2016|       |                     else {
 2017|       |                        dump("\":\"", b, ix);
 2018|       |                        dump_maybe_empty(ids_v<T>[value.index()], b, ix);
 2019|       |                        dump('"', b, ix);
 2020|       |                     }
 2021|       |                     const auto pos_after_tag = ix;
 2022|       |                     dump(',', b, ix);
 2023|       |                     const auto pos_body_start = ix;
 2024|       |                     to<JSON, V>::template op<opening_and_closing_handled<Opts>()>(val, ctx, b, ix);
 2025|       |                     if (ix == pos_body_start) {
 2026|       |                        ix = pos_after_tag; // custom body was empty: undo the tag separator
 2027|       |                     }
 2028|       |                     dump('}', b, ix);
 2029|       |                  }
 2030|       |               }
 2031|       |               else if constexpr (check_write_type_info(Opts) && tagging == variant_tagging_kind::internal &&
 2032|       |                                  variant_unit_alternative<V>) {
 2033|       |                  // A unit alternative carries no data, so internal tagging renders it as the
 2034|       |                  // discriminator alone -- the same object an empty struct alternative produces.
 2035|       |                  if (missing_id(value, ctx)) {
 2036|       |                     return;
 2037|       |                  }
 2038|       |                  if constexpr (Opts.prettify) {
 2039|       |                     dump("{\n", b, ix);
 2040|       |                     ctx.depth += check_indentation_width(Opts);
 2041|       |                     dumpn(check_indentation_char(Opts), ctx.depth, b, ix);
 2042|       |                     dump('"', b, ix);
 2043|       |                     dump_maybe_empty(tag_v<T>, b, ix);
 2044|       |                     dump("\": ", b, ix);
 2045|       |                     write_id<Opts>(value, ctx, b, ix);
 2046|       |                     ctx.depth -= check_indentation_width(Opts);
 2047|       |                     if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] {
 2048|       |                        return;
 2049|       |                     }
 2050|       |                     std::memcpy(&b[ix], "\n", 1);
 2051|       |                     ++ix;
 2052|       |                     std::memset(&b[ix], check_indentation_char(Opts), ctx.depth);
 2053|       |                     ix += ctx.depth;
 2054|       |                     std::memcpy(&b[ix], "}", 1);
 2055|       |                     ++ix;
 2056|       |                  }
 2057|       |                  else {
 2058|       |                     dump("{\"", b, ix);
 2059|       |                     dump_maybe_empty(tag_v<T>, b, ix);
 2060|       |                     dump("\":", b, ix);
 2061|       |                     write_id<Opts>(value, ctx, b, ix);
 2062|       |                     dump('}', b, ix);
 2063|       |                  }
 2064|       |               }
 2065|       |               else if constexpr (check_write_type_info(Opts) && tagging == variant_tagging_kind::internal &&
 2066|       |                                  (glaze_object_t<V> || reflectable<V> || is_memory_object<V>) &&
 2067|       |                                  (not alternative_declares_key<V>(tag_v<T>))) {
 2068|       |                  // An alternative that declares a member named like the discriminator carries the
 2069|       |                  // discriminator itself, so no tag is merged here and the bare-write branch below
 2070|       |                  // handles it. Previously only `reflectable` alternatives were excluded; a
 2071|       |                  // `glaze_object_t` one fell through to this branch and emitted the key twice.
 2072|       |                  if (missing_id(value, ctx)) {
 2073|       |                     return;
 2074|       |                  }
 2075|       |                  constexpr auto N = []() {
 2076|       |                     if constexpr (is_memory_object<V>) {
 2077|       |                        return reflect<memory_type<V>>::size;
 2078|       |                     }
 2079|       |                     else {
 2080|       |                        return reflect<V>::size;
 2081|       |                     }
 2082|       |                  }();
 2083|       |
 2084|       |                  // must first write out type
 2085|       |                  if constexpr (Opts.prettify) {
 2086|       |                     dump("{\n", b, ix);
 2087|       |                     ctx.depth += check_indentation_width(Opts);
 2088|       |                     dumpn(check_indentation_char(Opts), ctx.depth, b, ix);
 2089|       |                     dump('"', b, ix);
 2090|       |                     dump_maybe_empty(tag_v<T>, b, ix);
 2091|       |
 2092|       |                     using id_type = std::decay_t<decltype(ids_v<T>[value.index()])>;
 2093|       |
 2094|       |                     if constexpr (std::integral<id_type>) {
 2095|       |                        dump("\": ", b, ix);
 2096|       |                        serialize<JSON>::op<Opts>(ids_v<T>[value.index()], ctx, b, ix);
 2097|       |                        if constexpr (N > 0) {
 2098|       |                           dump(",\n", b, ix);
 2099|       |                           dumpn(check_indentation_char(Opts), ctx.depth, b, ix);
 2100|       |                        }
 2101|       |                     }
 2102|       |                     else {
 2103|       |                        dump("\": \"", b, ix);
 2104|       |                        dump_maybe_empty(ids_v<T>[value.index()], b, ix);
 2105|       |                        if constexpr (N == 0) {
 2106|       |                           dump('"', b, ix);
 2107|       |                        }
 2108|       |                        else {
 2109|       |                           dump("\",\n", b, ix);
 2110|       |                           dumpn(check_indentation_char(Opts), ctx.depth, b, ix);
 2111|       |                        }
 2112|       |                     }
 2113|       |                  }
 2114|       |                  else {
 2115|       |                     using id_type = std::decay_t<decltype(ids_v<T>[value.index()])>;
 2116|       |
 2117|       |                     dump("{\"", b, ix);
 2118|       |                     dump_maybe_empty(tag_v<T>, b, ix);
 2119|       |
 2120|       |                     if constexpr (std::integral<id_type>) {
 2121|       |                        dump("\":", b, ix);
 2122|       |                        serialize<JSON>::op<Opts>(ids_v<T>[value.index()], ctx, b, ix);
 2123|       |                        if constexpr (N > 0) {
 2124|       |                           dump(',', b, ix);
 2125|       |                        }
 2126|       |                     }
 2127|       |                     else {
 2128|       |                        dump("\":\"", b, ix);
 2129|       |                        dump_maybe_empty(ids_v<T>[value.index()], b, ix);
 2130|       |                        if constexpr (N == 0) {
 2131|       |                           dump('"', b, ix);
 2132|       |                        }
 2133|       |                        else {
 2134|       |                           dump("\",", b, ix);
 2135|       |                        }
 2136|       |                     }
 2137|       |                  }
 2138|       |                  if constexpr (is_memory_object<V>) {
 2139|       |                     if (!val) [[unlikely]] {
 2140|       |                        ctx.error = error_code::invalid_variant_object;
 2141|       |                        return;
 2142|       |                     }
 2143|       |                     to<JSON, memory_type<V>>::template op<opening_and_closing_handled<Opts>()>(*val, ctx, b, ix);
 2144|       |                  }
 2145|       |                  else {
 2146|       |                     to<JSON, V>::template op<opening_and_closing_handled<Opts>()>(val, ctx, b, ix);
 2147|       |                  }
 2148|       |                  // If we skip everything then we may have an extra comma, which we want to revert
 2149|       |                  if constexpr (Opts.skip_null_members) {
 2150|       |                     if (b[ix - 1] == ',') {
 2151|       |                        --ix;
 2152|       |                     }
 2153|       |                  }
 2154|       |
 2155|       |                  if constexpr (Opts.prettify) {
 2156|       |                     ctx.depth -= check_indentation_width(Opts);
 2157|       |                     if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] {
 2158|       |                        return;
 2159|       |                     }
 2160|       |                     std::memcpy(&b[ix], "\n", 1);
 2161|       |                     ++ix;
 2162|       |                     std::memset(&b[ix], check_indentation_char(Opts), ctx.depth);
 2163|       |                     ix += ctx.depth;
 2164|       |                     std::memcpy(&b[ix], "}", 1);
 2165|       |                     ++ix;
 2166|       |                  }
 2167|       |                  else {
 2168|       |                     dump('}', b, ix);
 2169|       |                  }
 2170|       |               }
 2171|  32.8k|               else {
 2172|  32.8k|                  to<JSON, V>::template op<Opts>(val, ctx, b, ix);
 2173|  32.8k|               }
 2174|  32.8k|            },
_ZN3glz2toILj10ElE2opITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERlTkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_:
  814|  32.8k|      {
  815|  32.8k|         if constexpr (not check_write_unchecked(Opts)) {
  816|  32.8k|            static_assert(required_padding<T>());
  817|  32.8k|            if (!ensure_space(ctx, b, ix + required_padding<T>())) [[unlikely]] {
  ------------------
  |  Branch (817:17): [True: 0, False: 32.8k]
  ------------------
  818|      0|               return;
  819|      0|            }
  820|  32.8k|         }
  821|       |
  822|  32.8k|         static constexpr auto O = write_unchecked_on<Opts>();
  823|       |
  824|       |         if constexpr (check_quoted_num(Opts)) {
  825|       |            std::memcpy(&b[ix], "\"", 1);
  826|       |            ++ix;
  827|       |            write_chars::op<O>(value, ctx, b, ix);
  828|       |            std::memcpy(&b[ix], "\"", 1);
  829|       |            ++ix;
  830|       |         }
  831|  32.8k|         else {
  832|  32.8k|            write_chars::op<O>(value, ctx, b, ix);
  833|  32.8k|         }
  834|  32.8k|      }
_ZN3glz16required_paddingIlEEmv:
  538|  32.8k|   {
  539|  32.8k|      constexpr auto value = []() -> size_t {
  540|  32.8k|         if constexpr (boolean_like<T>) {
  541|  32.8k|            return 8;
  542|  32.8k|         }
  543|  32.8k|         else if constexpr (num_t<T>) {
  544|  32.8k|            if constexpr (std::floating_point<T>) {
  545|  32.8k|               if constexpr (sizeof(T) > 8) {
  546|  32.8k|                  return 64;
  547|  32.8k|               }
  548|  32.8k|               else if constexpr (sizeof(T) > 4) {
  549|       |                  // zmij scratch + 4 for optional quotes and trailing comma.
  550|  32.8k|                  return zmij::double_buffer_size + 4;
  551|  32.8k|               }
  552|  32.8k|               else {
  553|  32.8k|                  return zmij::float_buffer_size + 4;
  554|  32.8k|               }
  555|  32.8k|            }
  556|  32.8k|            else if constexpr (sizeof(T) > 4) {
  557|  32.8k|               return 24;
  558|  32.8k|            }
  559|  32.8k|            else if constexpr (sizeof(T) > 2) {
  560|  32.8k|               return 16;
  561|  32.8k|            }
  562|  32.8k|            else {
  563|  32.8k|               return 8;
  564|  32.8k|            }
  565|  32.8k|         }
  566|  32.8k|         else if constexpr (nullable_like<T>) {
  567|  32.8k|            if constexpr (has_value_type<T>) {
  568|  32.8k|               return required_padding<typename T::value_type>();
  569|  32.8k|            }
  570|  32.8k|            else if constexpr (has_element_type<T>) {
  571|  32.8k|               return required_padding<typename T::element_type>();
  572|  32.8k|            }
  573|  32.8k|            else {
  574|  32.8k|               return 0;
  575|  32.8k|            }
  576|  32.8k|         }
  577|  32.8k|         else if constexpr (always_null_t<T>) {
  578|  32.8k|            return 8;
  579|  32.8k|         }
  580|  32.8k|         else {
  581|  32.8k|            return 0;
  582|  32.8k|         }
  583|  32.8k|      }();
  584|       |
  585|       |      if constexpr (value >= (write_padding_bytes - 16)) {
  586|       |         // we always require 16 bytes available from write_padding_bytes
  587|       |         // for opening and closing characters
  588|       |         return 0;
  589|       |      }
  590|  32.8k|      return value;
  591|  32.8k|   }
_ZN3glz2toILj10EiE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj128EEERNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERiTkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_:
  814|    142|      {
  815|       |         if constexpr (not check_write_unchecked(Opts)) {
  816|       |            static_assert(required_padding<T>());
  817|       |            if (!ensure_space(ctx, b, ix + required_padding<T>())) [[unlikely]] {
  818|       |               return;
  819|       |            }
  820|       |         }
  821|       |
  822|    142|         static constexpr auto O = write_unchecked_on<Opts>();
  823|       |
  824|       |         if constexpr (check_quoted_num(Opts)) {
  825|       |            std::memcpy(&b[ix], "\"", 1);
  826|       |            ++ix;
  827|       |            write_chars::op<O>(value, ctx, b, ix);
  828|       |            std::memcpy(&b[ix], "\"", 1);
  829|       |            ++ix;
  830|       |         }
  831|    142|         else {
  832|    142|            write_chars::op<O>(value, ctx, b, ix);
  833|    142|         }
  834|    142|      }
_ZN3glz2toILj10EiE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERiTkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_:
  814|    337|      {
  815|    337|         if constexpr (not check_write_unchecked(Opts)) {
  816|    337|            static_assert(required_padding<T>());
  817|    337|            if (!ensure_space(ctx, b, ix + required_padding<T>())) [[unlikely]] {
  ------------------
  |  Branch (817:17): [True: 0, False: 337]
  ------------------
  818|      0|               return;
  819|      0|            }
  820|    337|         }
  821|       |
  822|    337|         static constexpr auto O = write_unchecked_on<Opts>();
  823|       |
  824|       |         if constexpr (check_quoted_num(Opts)) {
  825|       |            std::memcpy(&b[ix], "\"", 1);
  826|       |            ++ix;
  827|       |            write_chars::op<O>(value, ctx, b, ix);
  828|       |            std::memcpy(&b[ix], "\"", 1);
  829|       |            ++ix;
  830|       |         }
  831|    337|         else {
  832|    337|            write_chars::op<O>(value, ctx, b, ix);
  833|    337|         }
  834|    337|      }
_ZN3glz16required_paddingIiEEmv:
  538|    684|   {
  539|    684|      constexpr auto value = []() -> size_t {
  540|    684|         if constexpr (boolean_like<T>) {
  541|    684|            return 8;
  542|    684|         }
  543|    684|         else if constexpr (num_t<T>) {
  544|    684|            if constexpr (std::floating_point<T>) {
  545|    684|               if constexpr (sizeof(T) > 8) {
  546|    684|                  return 64;
  547|    684|               }
  548|    684|               else if constexpr (sizeof(T) > 4) {
  549|       |                  // zmij scratch + 4 for optional quotes and trailing comma.
  550|    684|                  return zmij::double_buffer_size + 4;
  551|    684|               }
  552|    684|               else {
  553|    684|                  return zmij::float_buffer_size + 4;
  554|    684|               }
  555|    684|            }
  556|    684|            else if constexpr (sizeof(T) > 4) {
  557|    684|               return 24;
  558|    684|            }
  559|    684|            else if constexpr (sizeof(T) > 2) {
  560|    684|               return 16;
  561|    684|            }
  562|    684|            else {
  563|    684|               return 8;
  564|    684|            }
  565|    684|         }
  566|    684|         else if constexpr (nullable_like<T>) {
  567|    684|            if constexpr (has_value_type<T>) {
  568|    684|               return required_padding<typename T::value_type>();
  569|    684|            }
  570|    684|            else if constexpr (has_element_type<T>) {
  571|    684|               return required_padding<typename T::element_type>();
  572|    684|            }
  573|    684|            else {
  574|    684|               return 0;
  575|    684|            }
  576|    684|         }
  577|    684|         else if constexpr (always_null_t<T>) {
  578|    684|            return 8;
  579|    684|         }
  580|    684|         else {
  581|    684|            return 0;
  582|    684|         }
  583|    684|      }();
  584|       |
  585|       |      if constexpr (value >= (write_padding_bytes - 16)) {
  586|       |         // we always require 16 bytes available from write_padding_bytes
  587|       |         // for opening and closing characters
  588|       |         return 0;
  589|       |      }
  590|    684|      return value;
  591|    684|   }
_ZN3glz2toILj10EiE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEiTkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_:
  814|    347|      {
  815|    347|         if constexpr (not check_write_unchecked(Opts)) {
  816|    347|            static_assert(required_padding<T>());
  817|    347|            if (!ensure_space(ctx, b, ix + required_padding<T>())) [[unlikely]] {
  ------------------
  |  Branch (817:17): [True: 0, False: 347]
  ------------------
  818|      0|               return;
  819|      0|            }
  820|    347|         }
  821|       |
  822|    347|         static constexpr auto O = write_unchecked_on<Opts>();
  823|       |
  824|       |         if constexpr (check_quoted_num(Opts)) {
  825|       |            std::memcpy(&b[ix], "\"", 1);
  826|       |            ++ix;
  827|       |            write_chars::op<O>(value, ctx, b, ix);
  828|       |            std::memcpy(&b[ix], "\"", 1);
  829|       |            ++ix;
  830|       |         }
  831|    347|         else {
  832|    347|            write_chars::op<O>(value, ctx, b, ix);
  833|    347|         }
  834|    347|      }
_ZN3glz2toILj10EN12jsonrpc_fuzz5pointEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEES2_RNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_:
 2465|    161|      {
 2466|    161|         using ValueType = std::decay_t<V>;
 2467|       |         if constexpr (has_unknown_writer<ValueType> && not check_disable_write_unknown(Options)) {
 2468|       |            constexpr auto& writer = meta_unknown_write_v<ValueType>;
 2469|       |
 2470|       |            using WriterType = meta_unknown_write_t<ValueType>;
 2471|       |            if constexpr (std::is_member_object_pointer_v<WriterType>) {
 2472|       |               decltype(auto) unknown_writer = value.*writer;
 2473|       |               if (unknown_writer.size() > 0) {
 2474|       |                  // TODO: This intermediate is added to get GCC 14 to build
 2475|       |                  decltype(auto) merged = glz::merge{value, unknown_writer};
 2476|       |                  serialize<JSON>::op<disable_write_unknown_on<Options>()>(std::move(merged), ctx, b, ix);
 2477|       |               }
 2478|       |               else {
 2479|       |                  serialize<JSON>::op<disable_write_unknown_on<Options>()>(value, ctx, b, ix);
 2480|       |               }
 2481|       |            }
 2482|       |            else if constexpr (std::is_member_function_pointer_v<WriterType>) {
 2483|       |               decltype(auto) unknown_writer = (value.*writer)();
 2484|       |               if (unknown_writer.size() > 0) {
 2485|       |                  // TODO: This intermediate is added to get GCC 14 to build
 2486|       |                  decltype(auto) merged = glz::merge{value, unknown_writer};
 2487|       |                  serialize<JSON>::op<disable_write_unknown_on<Options>()>(std::move(merged), ctx, b, ix);
 2488|       |               }
 2489|       |               else {
 2490|       |                  serialize<JSON>::op<disable_write_unknown_on<Options>()>(value, ctx, b, ix);
 2491|       |               }
 2492|       |            }
 2493|       |            else {
 2494|       |               static_assert(false_v<T>, "unknown_write type not handled");
 2495|       |            }
 2496|       |         }
 2497|    161|         else {
 2498|       |            // handles glaze_object_t without extra unknown fields
 2499|    161|            static constexpr auto Opts =
 2500|    161|               disable_write_unknown_off<opening_and_closing_handled_off<ws_handled_off<Options>()>()>();
 2501|       |
 2502|    161|            if constexpr (not check_opening_handled(Options)) {
 2503|       |               if constexpr (Options.prettify) {
 2504|       |                  ctx.depth += check_indentation_width(Options);
 2505|       |                  if constexpr (not check_write_unchecked(Options)) {
 2506|       |                     if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] {
 2507|       |                        return;
 2508|       |                     }
 2509|       |                  }
 2510|       |                  std::memcpy(&b[ix], "{\n", 2);
 2511|       |                  ix += 2;
 2512|       |                  std::memset(&b[ix], check_indentation_char(Opts), ctx.depth);
 2513|       |                  ix += ctx.depth;
 2514|       |               }
 2515|    161|               else {
 2516|    161|                  if constexpr (not check_write_unchecked(Options)) {
 2517|    161|                     if (!ensure_space(ctx, b, ix + 1)) [[unlikely]] {
  ------------------
  |  Branch (2517:26): [True: 0, False: 161]
  ------------------
 2518|      0|                        return;
 2519|      0|                     }
 2520|    161|                  }
 2521|    161|                  dump<not check_write_unchecked(Options)>('{', b, ix);
 2522|    161|               }
 2523|    161|            }
 2524|       |
 2525|      0|            static constexpr auto N = reflect<T>::size;
 2526|       |
 2527|    161|            decltype(auto) t = [&]() -> decltype(auto) {
 2528|    161|               if constexpr (reflectable<T>) {
 2529|    161|                  return to_tie(value);
 2530|    161|               }
 2531|    161|               else {
 2532|    161|                  return nullptr;
 2533|    161|               }
 2534|    161|            }();
 2535|       |
 2536|    161|            static constexpr auto padding = round_up_to_nearest_16(maximum_key_size<T> + write_padding_bytes);
 2537|       |            if constexpr (maybe_skipped<Opts, T>) {
 2538|       |               bool first = true;
 2539|       |               for_each<N>([&]<size_t I>() {
 2540|       |                  using val_t = field_t<T, I>;
 2541|       |
 2542|       |                  // `meta<T>::skip` joins the other compile-time exclusions here rather than returning
 2543|       |                  // early, so that a skipped field's writer is never instantiated -- see
 2544|       |                  // `skipped_by_meta`.
 2545|       |                  constexpr bool write_function_pointers = check_write_function_pointers(Opts);
 2546|       |                  if constexpr (skipped_by_meta<T, I, operation::serialize> || always_skipped<val_t> ||
 2547|       |                                (!write_function_pointers && is_any_function_ptr<val_t>)) {
 2548|       |                     return;
 2549|       |                  }
 2550|       |                  else {
 2551|       |                     if constexpr (meta_has_skip_if<T>) {
 2552|       |                        static constexpr auto skip_if_key = glz::get<I>(reflect<T>::keys);
 2553|       |                        static constexpr meta_context mctx{.op = operation::serialize};
 2554|       |                        decltype(auto) field_value = [&]() -> decltype(auto) {
 2555|       |                           if constexpr (reflectable<T>) {
 2556|       |                              return get<I>(t);
 2557|       |                           }
 2558|       |                           else {
 2559|       |                              return get_member(value, glz::get<I>(reflect<T>::values));
 2560|       |                           }
 2561|       |                        }();
 2562|       |                        if (meta<T>::skip_if(field_value, skip_if_key, mctx)) return;
 2563|       |                     }
 2564|       |
 2565|       |                     if constexpr (null_t<val_t> && Opts.skip_null_members) {
 2566|       |                        if constexpr (always_null_t<val_t>)
 2567|       |                           return;
 2568|       |                        else {
 2569|       |                           const auto is_null = [&]() {
 2570|       |                              decltype(auto) element = [&]() -> decltype(auto) {
 2571|       |                                 if constexpr (reflectable<T>) {
 2572|       |                                    return get<I>(t);
 2573|       |                                 }
 2574|       |                                 else {
 2575|       |                                    return get<I>(reflect<T>::values);
 2576|       |                                 }
 2577|       |                              };
 2578|       |
 2579|       |                              if constexpr (nullable_wrapper<val_t>) {
 2580|       |                                 return !bool(element()(value).val);
 2581|       |                              }
 2582|       |                              else if constexpr (nullable_value_t<val_t>) {
 2583|       |                                 return !get_member(value, element()).has_value();
 2584|       |                              }
 2585|       |                              else {
 2586|       |                                 return !bool(get_member(value, element()));
 2587|       |                              }
 2588|       |                           }();
 2589|       |                           if (is_null) return;
 2590|       |                        }
 2591|       |                     }
 2592|       |                     else if constexpr (is_specialization_v<val_t, custom_t> && Opts.skip_null_members &&
 2593|       |                                        custom_getter_returns_nullable<val_t>()) {
 2594|       |                        if (is_custom_field_null<T, I>(value, t, ctx)) return;
 2595|       |                     }
 2596|       |                     else if constexpr (Opts.skip_null_members && glaze_value_is_nullable<val_t>()) {
 2597|       |                        if (is_glaze_value_field_null<T, I>(value, t)) return;
 2598|       |                     }
 2599|       |
 2600|       |                     if constexpr (check_skip_default_members(Opts) && has_skippable_default<val_t>) {
 2601|       |                        decltype(auto) member = [&]() -> decltype(auto) {
 2602|       |                           if constexpr (reflectable<T>) {
 2603|       |                              return get_member(value, get<I>(t));
 2604|       |                           }
 2605|       |                           else {
 2606|       |                              return get_member(value, get<I>(reflect<T>::values));
 2607|       |                           }
 2608|       |                        }();
 2609|       |                        if (is_default_value(member)) return;
 2610|       |                     }
 2611|       |
 2612|       |                     if constexpr (Opts.prettify) {
 2613|       |                        if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] {
 2614|       |                           return;
 2615|       |                        }
 2616|       |                     }
 2617|       |                     else {
 2618|       |                        if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] {
 2619|       |                           return;
 2620|       |                        }
 2621|       |                     }
 2622|       |
 2623|       |                     if (first) {
 2624|       |                        first = false;
 2625|       |                     }
 2626|       |                     else {
 2627|       |                        // Null members may be skipped so we can't just write it out for all but the last member
 2628|       |                        if constexpr (Opts.prettify) {
 2629|       |                           std::memcpy(&b[ix], ",\n", 2);
 2630|       |                           ix += 2;
 2631|       |                           std::memset(&b[ix], check_indentation_char(Opts), ctx.depth);
 2632|       |                           ix += ctx.depth;
 2633|       |                        }
 2634|       |                        else {
 2635|       |                           std::memcpy(&b[ix], ",", 1);
 2636|       |                           ++ix;
 2637|       |                        }
 2638|       |                        if constexpr (is_output_streaming<B>) {
 2639|       |                           flush_buffer(b, ix);
 2640|       |                        }
 2641|       |                     }
 2642|       |
 2643|       |                     // MSVC requires get<I> rather than keys[I]
 2644|       |                     static constexpr auto key = glz::get<I>(reflect<T>::keys); // GCC 14 requires auto here
 2645|       |                     static constexpr auto quoted_key = quoted_key_v<key, Opts.prettify>;
 2646|       |                     static constexpr auto n = quoted_key.size();
 2647|       |                     std::memcpy(&b[ix], quoted_key.data(), n);
 2648|       |                     ix += n;
 2649|       |
 2650|       |                     static constexpr auto check_opts = required_padding<val_t>() ? write_unchecked_on<Opts>() : Opts;
 2651|       |                     if constexpr (reflectable<T>) {
 2652|       |                        to<JSON, val_t>::template op<check_opts>(get_member(value, get<I>(t)), ctx, b, ix);
 2653|       |                     }
 2654|       |                     else {
 2655|       |                        to<JSON, val_t>::template op<check_opts>(get_member(value, get<I>(reflect<T>::values)), ctx, b,
 2656|       |                                                                 ix);
 2657|       |                     }
 2658|       |                  }
 2659|       |               });
 2660|       |            }
 2661|    161|            else {
 2662|    161|               static constexpr size_t fixed_max_size = Opts.prettify ? 0 : fixed_padding<T>;
  ------------------
  |  Branch (2662:57): [Folded, False: 161]
  ------------------
 2663|    161|               if constexpr (fixed_max_size && not check_write_unchecked(Options)) {
 2664|    161|                  if (!ensure_space(ctx, b, ix + fixed_max_size)) [[unlikely]] {
  ------------------
  |  Branch (2664:23): [True: 0, False: 161]
  ------------------
 2665|      0|                     return;
 2666|      0|                  }
 2667|    161|               }
 2668|       |
 2669|    161|               for_each<N>([&]<size_t I>() {
 2670|    161|                  if constexpr (write_can_error<T>()) {
 2671|    161|                     if (bool(ctx.error)) [[unlikely]] {
 2672|    161|                        return;
 2673|    161|                     }
 2674|    161|                  }
 2675|    161|                  if constexpr (not fixed_max_size) {
 2676|    161|                     if constexpr (Opts.prettify) {
 2677|    161|                        if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] {
 2678|    161|                           return;
 2679|    161|                        }
 2680|    161|                     }
 2681|    161|                     else {
 2682|    161|                        if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] {
 2683|    161|                           return;
 2684|    161|                        }
 2685|    161|                     }
 2686|    161|                  }
 2687|       |
 2688|    161|                  if constexpr (I != 0 && Opts.prettify) {
 2689|    161|                     std::memcpy(&b[ix], ",\n", 2);
 2690|    161|                     ix += 2;
 2691|    161|                     std::memset(&b[ix], check_indentation_char(Opts), ctx.depth);
 2692|    161|                     ix += ctx.depth;
 2693|    161|                  }
 2694|       |
 2695|    161|                  using val_t = field_t<T, I>;
 2696|       |
 2697|       |                  // MSVC requires get<I> rather than keys[I]
 2698|    161|                  static constexpr auto key = glz::get<I>(reflect<T>::keys); // GCC 14 requires auto here
 2699|    161|                  if constexpr (always_null_t<val_t>) {
 2700|    161|                     if constexpr (I == 0 || Opts.prettify) {
 2701|    161|                        static constexpr auto quoted_key = join_v<quoted_key_v<key, Opts.prettify>, chars<"null">>;
 2702|    161|                        static constexpr auto n = quoted_key.size();
 2703|    161|                        std::memcpy(&b[ix], quoted_key.data(), n);
 2704|    161|                        ix += n;
 2705|    161|                     }
 2706|    161|                     else {
 2707|    161|                        static constexpr auto quoted_key = join_v<chars<",">, quoted_key_v<key>, chars<"null">>;
 2708|    161|                        static constexpr auto n = quoted_key.size();
 2709|    161|                        std::memcpy(&b[ix], quoted_key.data(), n);
 2710|    161|                        ix += n;
 2711|    161|                     }
 2712|    161|                  }
 2713|    161|                  else {
 2714|    161|                     if constexpr (I == 0 || Opts.prettify) {
 2715|    161|                        static constexpr auto quoted_key = quoted_key_v<key, Opts.prettify>;
 2716|    161|                        static constexpr auto n = quoted_key.size();
 2717|    161|                        std::memcpy(&b[ix], quoted_key.data(), n);
 2718|    161|                        ix += n;
 2719|    161|                     }
 2720|    161|                     else {
 2721|    161|                        static constexpr auto quoted_key = join_v<chars<",">, quoted_key_v<key>>;
 2722|    161|                        static constexpr auto n = quoted_key.size();
 2723|    161|                        std::memcpy(&b[ix], quoted_key.data(), n);
 2724|    161|                        ix += n;
 2725|    161|                     }
 2726|       |
 2727|    161|                     static constexpr auto check_opts = required_padding<val_t>() ? write_unchecked_on<Opts>() : Opts;
 2728|    161|                     if constexpr (reflectable<T>) {
 2729|    161|                        to<JSON, val_t>::template op<check_opts>(get_member(value, get<I>(t)), ctx, b, ix);
 2730|    161|                     }
 2731|    161|                     else {
 2732|    161|                        to<JSON, val_t>::template op<check_opts>(get_member(value, get<I>(reflect<T>::values)), ctx, b,
 2733|    161|                                                                 ix);
 2734|    161|                     }
 2735|    161|                  }
 2736|    161|               });
 2737|    161|            }
 2738|       |
 2739|       |            // Options is required here, because it must be the top level
 2740|    161|            if constexpr (not check_closing_handled(Options)) {
 2741|       |               if constexpr (Options.prettify) {
 2742|       |                  ctx.depth -= check_indentation_width(Options);
 2743|       |                  if constexpr (not check_write_unchecked(Options)) {
 2744|       |                     if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] {
 2745|       |                        return;
 2746|       |                     }
 2747|       |                  }
 2748|       |                  std::memcpy(&b[ix], "\n", 1);
 2749|       |                  ++ix;
 2750|       |                  std::memset(&b[ix], check_indentation_char(Opts), ctx.depth);
 2751|       |                  ix += ctx.depth;
 2752|       |                  std::memcpy(&b[ix], "}", 1);
 2753|       |                  ++ix;
 2754|       |               }
 2755|    161|               else {
 2756|    161|                  dump<not(fixed_padding<T> || check_write_unchecked(Options))>('}', b, ix);
 2757|    161|               }
 2758|    161|            }
 2759|    161|         }
 2760|    161|      }
_ZZN3glz2toILj10EN12jsonrpc_fuzz5pointEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEES2_RNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlvE_clEv:
 2527|    161|            decltype(auto) t = [&]() -> decltype(auto) {
 2528|    161|               if constexpr (reflectable<T>) {
 2529|    161|                  return to_tie(value);
 2530|       |               }
 2531|       |               else {
 2532|       |                  return nullptr;
 2533|       |               }
 2534|    161|            }();
_ZZN3glz2toILj10EN12jsonrpc_fuzz5pointEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEES2_RNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlTnmvE_clILm0EEEDav:
 2669|    161|               for_each<N>([&]<size_t I>() {
 2670|       |                  if constexpr (write_can_error<T>()) {
 2671|       |                     if (bool(ctx.error)) [[unlikely]] {
 2672|       |                        return;
 2673|       |                     }
 2674|       |                  }
 2675|       |                  if constexpr (not fixed_max_size) {
 2676|       |                     if constexpr (Opts.prettify) {
 2677|       |                        if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] {
 2678|       |                           return;
 2679|       |                        }
 2680|       |                     }
 2681|       |                     else {
 2682|       |                        if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] {
 2683|       |                           return;
 2684|       |                        }
 2685|       |                     }
 2686|       |                  }
 2687|       |
 2688|       |                  if constexpr (I != 0 && Opts.prettify) {
 2689|       |                     std::memcpy(&b[ix], ",\n", 2);
 2690|       |                     ix += 2;
 2691|       |                     std::memset(&b[ix], check_indentation_char(Opts), ctx.depth);
 2692|       |                     ix += ctx.depth;
 2693|       |                  }
 2694|       |
 2695|    161|                  using val_t = field_t<T, I>;
 2696|       |
 2697|       |                  // MSVC requires get<I> rather than keys[I]
 2698|    161|                  static constexpr auto key = glz::get<I>(reflect<T>::keys); // GCC 14 requires auto here
 2699|       |                  if constexpr (always_null_t<val_t>) {
 2700|       |                     if constexpr (I == 0 || Opts.prettify) {
 2701|       |                        static constexpr auto quoted_key = join_v<quoted_key_v<key, Opts.prettify>, chars<"null">>;
 2702|       |                        static constexpr auto n = quoted_key.size();
 2703|       |                        std::memcpy(&b[ix], quoted_key.data(), n);
 2704|       |                        ix += n;
 2705|       |                     }
 2706|       |                     else {
 2707|       |                        static constexpr auto quoted_key = join_v<chars<",">, quoted_key_v<key>, chars<"null">>;
 2708|       |                        static constexpr auto n = quoted_key.size();
 2709|       |                        std::memcpy(&b[ix], quoted_key.data(), n);
 2710|       |                        ix += n;
 2711|       |                     }
 2712|       |                  }
 2713|    161|                  else {
 2714|    161|                     if constexpr (I == 0 || Opts.prettify) {
 2715|    161|                        static constexpr auto quoted_key = quoted_key_v<key, Opts.prettify>;
 2716|    161|                        static constexpr auto n = quoted_key.size();
 2717|    161|                        std::memcpy(&b[ix], quoted_key.data(), n);
 2718|    161|                        ix += n;
 2719|       |                     }
 2720|       |                     else {
 2721|       |                        static constexpr auto quoted_key = join_v<chars<",">, quoted_key_v<key>>;
 2722|       |                        static constexpr auto n = quoted_key.size();
 2723|       |                        std::memcpy(&b[ix], quoted_key.data(), n);
 2724|       |                        ix += n;
 2725|       |                     }
 2726|       |
 2727|    161|                     static constexpr auto check_opts = required_padding<val_t>() ? write_unchecked_on<Opts>() : Opts;
  ------------------
  |  Branch (2727:57): [True: 0, Folded]
  ------------------
 2728|    161|                     if constexpr (reflectable<T>) {
 2729|    161|                        to<JSON, val_t>::template op<check_opts>(get_member(value, get<I>(t)), ctx, b, ix);
 2730|       |                     }
 2731|       |                     else {
 2732|       |                        to<JSON, val_t>::template op<check_opts>(get_member(value, get<I>(reflect<T>::values)), ctx, b,
 2733|       |                                                                 ix);
 2734|       |                     }
 2735|    161|                  }
 2736|    161|               });
_ZN3glz2toILj10EdE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj128EEERNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERdTkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_:
  814|    846|      {
  815|       |         if constexpr (not check_write_unchecked(Opts)) {
  816|       |            static_assert(required_padding<T>());
  817|       |            if (!ensure_space(ctx, b, ix + required_padding<T>())) [[unlikely]] {
  818|       |               return;
  819|       |            }
  820|       |         }
  821|       |
  822|    846|         static constexpr auto O = write_unchecked_on<Opts>();
  823|       |
  824|       |         if constexpr (check_quoted_num(Opts)) {
  825|       |            std::memcpy(&b[ix], "\"", 1);
  826|       |            ++ix;
  827|       |            write_chars::op<O>(value, ctx, b, ix);
  828|       |            std::memcpy(&b[ix], "\"", 1);
  829|       |            ++ix;
  830|       |         }
  831|    846|         else {
  832|    846|            write_chars::op<O>(value, ctx, b, ix);
  833|    846|         }
  834|    846|      }
_ZZN3glz2toILj10EN12jsonrpc_fuzz5pointEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEES2_RNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlTnmvE_clILm1EEEDav:
 2669|    161|               for_each<N>([&]<size_t I>() {
 2670|       |                  if constexpr (write_can_error<T>()) {
 2671|       |                     if (bool(ctx.error)) [[unlikely]] {
 2672|       |                        return;
 2673|       |                     }
 2674|       |                  }
 2675|       |                  if constexpr (not fixed_max_size) {
 2676|       |                     if constexpr (Opts.prettify) {
 2677|       |                        if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] {
 2678|       |                           return;
 2679|       |                        }
 2680|       |                     }
 2681|       |                     else {
 2682|       |                        if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] {
 2683|       |                           return;
 2684|       |                        }
 2685|       |                     }
 2686|       |                  }
 2687|       |
 2688|       |                  if constexpr (I != 0 && Opts.prettify) {
 2689|       |                     std::memcpy(&b[ix], ",\n", 2);
 2690|       |                     ix += 2;
 2691|       |                     std::memset(&b[ix], check_indentation_char(Opts), ctx.depth);
 2692|       |                     ix += ctx.depth;
 2693|       |                  }
 2694|       |
 2695|    161|                  using val_t = field_t<T, I>;
 2696|       |
 2697|       |                  // MSVC requires get<I> rather than keys[I]
 2698|    161|                  static constexpr auto key = glz::get<I>(reflect<T>::keys); // GCC 14 requires auto here
 2699|       |                  if constexpr (always_null_t<val_t>) {
 2700|       |                     if constexpr (I == 0 || Opts.prettify) {
 2701|       |                        static constexpr auto quoted_key = join_v<quoted_key_v<key, Opts.prettify>, chars<"null">>;
 2702|       |                        static constexpr auto n = quoted_key.size();
 2703|       |                        std::memcpy(&b[ix], quoted_key.data(), n);
 2704|       |                        ix += n;
 2705|       |                     }
 2706|       |                     else {
 2707|       |                        static constexpr auto quoted_key = join_v<chars<",">, quoted_key_v<key>, chars<"null">>;
 2708|       |                        static constexpr auto n = quoted_key.size();
 2709|       |                        std::memcpy(&b[ix], quoted_key.data(), n);
 2710|       |                        ix += n;
 2711|       |                     }
 2712|       |                  }
 2713|    161|                  else {
 2714|       |                     if constexpr (I == 0 || Opts.prettify) {
 2715|       |                        static constexpr auto quoted_key = quoted_key_v<key, Opts.prettify>;
 2716|       |                        static constexpr auto n = quoted_key.size();
 2717|       |                        std::memcpy(&b[ix], quoted_key.data(), n);
 2718|       |                        ix += n;
 2719|       |                     }
 2720|    161|                     else {
 2721|    161|                        static constexpr auto quoted_key = join_v<chars<",">, quoted_key_v<key>>;
 2722|    161|                        static constexpr auto n = quoted_key.size();
 2723|    161|                        std::memcpy(&b[ix], quoted_key.data(), n);
 2724|    161|                        ix += n;
 2725|    161|                     }
 2726|       |
 2727|    161|                     static constexpr auto check_opts = required_padding<val_t>() ? write_unchecked_on<Opts>() : Opts;
  ------------------
  |  Branch (2727:57): [True: 0, Folded]
  ------------------
 2728|    161|                     if constexpr (reflectable<T>) {
 2729|    161|                        to<JSON, val_t>::template op<check_opts>(get_member(value, get<I>(t)), ctx, b, ix);
 2730|       |                     }
 2731|       |                     else {
 2732|       |                        to<JSON, val_t>::template op<check_opts>(get_member(value, get<I>(reflect<T>::values)), ctx, b,
 2733|       |                                                                 ix);
 2734|       |                     }
 2735|    161|                  }
 2736|    161|               });
_ZN3glz2toILj10EN12jsonrpc_fuzz8fuzz_apiEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_:
 2465|     43|      {
 2466|     43|         using ValueType = std::decay_t<V>;
 2467|       |         if constexpr (has_unknown_writer<ValueType> && not check_disable_write_unknown(Options)) {
 2468|       |            constexpr auto& writer = meta_unknown_write_v<ValueType>;
 2469|       |
 2470|       |            using WriterType = meta_unknown_write_t<ValueType>;
 2471|       |            if constexpr (std::is_member_object_pointer_v<WriterType>) {
 2472|       |               decltype(auto) unknown_writer = value.*writer;
 2473|       |               if (unknown_writer.size() > 0) {
 2474|       |                  // TODO: This intermediate is added to get GCC 14 to build
 2475|       |                  decltype(auto) merged = glz::merge{value, unknown_writer};
 2476|       |                  serialize<JSON>::op<disable_write_unknown_on<Options>()>(std::move(merged), ctx, b, ix);
 2477|       |               }
 2478|       |               else {
 2479|       |                  serialize<JSON>::op<disable_write_unknown_on<Options>()>(value, ctx, b, ix);
 2480|       |               }
 2481|       |            }
 2482|       |            else if constexpr (std::is_member_function_pointer_v<WriterType>) {
 2483|       |               decltype(auto) unknown_writer = (value.*writer)();
 2484|       |               if (unknown_writer.size() > 0) {
 2485|       |                  // TODO: This intermediate is added to get GCC 14 to build
 2486|       |                  decltype(auto) merged = glz::merge{value, unknown_writer};
 2487|       |                  serialize<JSON>::op<disable_write_unknown_on<Options>()>(std::move(merged), ctx, b, ix);
 2488|       |               }
 2489|       |               else {
 2490|       |                  serialize<JSON>::op<disable_write_unknown_on<Options>()>(value, ctx, b, ix);
 2491|       |               }
 2492|       |            }
 2493|       |            else {
 2494|       |               static_assert(false_v<T>, "unknown_write type not handled");
 2495|       |            }
 2496|       |         }
 2497|     43|         else {
 2498|       |            // handles glaze_object_t without extra unknown fields
 2499|     43|            static constexpr auto Opts =
 2500|     43|               disable_write_unknown_off<opening_and_closing_handled_off<ws_handled_off<Options>()>()>();
 2501|       |
 2502|     43|            if constexpr (not check_opening_handled(Options)) {
 2503|       |               if constexpr (Options.prettify) {
 2504|       |                  ctx.depth += check_indentation_width(Options);
 2505|       |                  if constexpr (not check_write_unchecked(Options)) {
 2506|       |                     if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] {
 2507|       |                        return;
 2508|       |                     }
 2509|       |                  }
 2510|       |                  std::memcpy(&b[ix], "{\n", 2);
 2511|       |                  ix += 2;
 2512|       |                  std::memset(&b[ix], check_indentation_char(Opts), ctx.depth);
 2513|       |                  ix += ctx.depth;
 2514|       |               }
 2515|     43|               else {
 2516|     43|                  if constexpr (not check_write_unchecked(Options)) {
 2517|     43|                     if (!ensure_space(ctx, b, ix + 1)) [[unlikely]] {
  ------------------
  |  Branch (2517:26): [True: 0, False: 43]
  ------------------
 2518|      0|                        return;
 2519|      0|                     }
 2520|     43|                  }
 2521|     43|                  dump<not check_write_unchecked(Options)>('{', b, ix);
 2522|     43|               }
 2523|     43|            }
 2524|       |
 2525|      0|            static constexpr auto N = reflect<T>::size;
 2526|       |
 2527|     43|            decltype(auto) t = [&]() -> decltype(auto) {
 2528|     43|               if constexpr (reflectable<T>) {
 2529|     43|                  return to_tie(value);
 2530|     43|               }
 2531|     43|               else {
 2532|     43|                  return nullptr;
 2533|     43|               }
 2534|     43|            }();
 2535|       |
 2536|     43|            static constexpr auto padding = round_up_to_nearest_16(maximum_key_size<T> + write_padding_bytes);
 2537|     43|            if constexpr (maybe_skipped<Opts, T>) {
 2538|     43|               bool first = true;
 2539|     43|               for_each<N>([&]<size_t I>() {
 2540|     43|                  using val_t = field_t<T, I>;
 2541|       |
 2542|       |                  // `meta<T>::skip` joins the other compile-time exclusions here rather than returning
 2543|       |                  // early, so that a skipped field's writer is never instantiated -- see
 2544|       |                  // `skipped_by_meta`.
 2545|     43|                  constexpr bool write_function_pointers = check_write_function_pointers(Opts);
 2546|     43|                  if constexpr (skipped_by_meta<T, I, operation::serialize> || always_skipped<val_t> ||
 2547|     43|                                (!write_function_pointers && is_any_function_ptr<val_t>)) {
 2548|     43|                     return;
 2549|     43|                  }
 2550|     43|                  else {
 2551|     43|                     if constexpr (meta_has_skip_if<T>) {
 2552|     43|                        static constexpr auto skip_if_key = glz::get<I>(reflect<T>::keys);
 2553|     43|                        static constexpr meta_context mctx{.op = operation::serialize};
 2554|     43|                        decltype(auto) field_value = [&]() -> decltype(auto) {
 2555|     43|                           if constexpr (reflectable<T>) {
 2556|     43|                              return get<I>(t);
 2557|     43|                           }
 2558|     43|                           else {
 2559|     43|                              return get_member(value, glz::get<I>(reflect<T>::values));
 2560|     43|                           }
 2561|     43|                        }();
 2562|     43|                        if (meta<T>::skip_if(field_value, skip_if_key, mctx)) return;
 2563|     43|                     }
 2564|       |
 2565|     43|                     if constexpr (null_t<val_t> && Opts.skip_null_members) {
 2566|     43|                        if constexpr (always_null_t<val_t>)
 2567|     43|                           return;
 2568|     43|                        else {
 2569|     43|                           const auto is_null = [&]() {
 2570|     43|                              decltype(auto) element = [&]() -> decltype(auto) {
 2571|     43|                                 if constexpr (reflectable<T>) {
 2572|     43|                                    return get<I>(t);
 2573|     43|                                 }
 2574|     43|                                 else {
 2575|     43|                                    return get<I>(reflect<T>::values);
 2576|     43|                                 }
 2577|     43|                              };
 2578|       |
 2579|     43|                              if constexpr (nullable_wrapper<val_t>) {
 2580|     43|                                 return !bool(element()(value).val);
 2581|     43|                              }
 2582|     43|                              else if constexpr (nullable_value_t<val_t>) {
 2583|     43|                                 return !get_member(value, element()).has_value();
 2584|     43|                              }
 2585|     43|                              else {
 2586|     43|                                 return !bool(get_member(value, element()));
 2587|     43|                              }
 2588|     43|                           }();
 2589|     43|                           if (is_null) return;
 2590|     43|                        }
 2591|     43|                     }
 2592|     43|                     else if constexpr (is_specialization_v<val_t, custom_t> && Opts.skip_null_members &&
 2593|     43|                                        custom_getter_returns_nullable<val_t>()) {
 2594|     43|                        if (is_custom_field_null<T, I>(value, t, ctx)) return;
 2595|     43|                     }
 2596|     43|                     else if constexpr (Opts.skip_null_members && glaze_value_is_nullable<val_t>()) {
 2597|     43|                        if (is_glaze_value_field_null<T, I>(value, t)) return;
 2598|     43|                     }
 2599|       |
 2600|     43|                     if constexpr (check_skip_default_members(Opts) && has_skippable_default<val_t>) {
 2601|     43|                        decltype(auto) member = [&]() -> decltype(auto) {
 2602|     43|                           if constexpr (reflectable<T>) {
 2603|     43|                              return get_member(value, get<I>(t));
 2604|     43|                           }
 2605|     43|                           else {
 2606|     43|                              return get_member(value, get<I>(reflect<T>::values));
 2607|     43|                           }
 2608|     43|                        }();
 2609|     43|                        if (is_default_value(member)) return;
 2610|     43|                     }
 2611|       |
 2612|     43|                     if constexpr (Opts.prettify) {
 2613|     43|                        if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] {
 2614|     43|                           return;
 2615|     43|                        }
 2616|     43|                     }
 2617|     43|                     else {
 2618|     43|                        if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] {
 2619|     43|                           return;
 2620|     43|                        }
 2621|     43|                     }
 2622|       |
 2623|     43|                     if (first) {
 2624|     43|                        first = false;
 2625|     43|                     }
 2626|     43|                     else {
 2627|       |                        // Null members may be skipped so we can't just write it out for all but the last member
 2628|     43|                        if constexpr (Opts.prettify) {
 2629|     43|                           std::memcpy(&b[ix], ",\n", 2);
 2630|     43|                           ix += 2;
 2631|     43|                           std::memset(&b[ix], check_indentation_char(Opts), ctx.depth);
 2632|     43|                           ix += ctx.depth;
 2633|     43|                        }
 2634|     43|                        else {
 2635|     43|                           std::memcpy(&b[ix], ",", 1);
 2636|     43|                           ++ix;
 2637|     43|                        }
 2638|     43|                        if constexpr (is_output_streaming<B>) {
 2639|     43|                           flush_buffer(b, ix);
 2640|     43|                        }
 2641|     43|                     }
 2642|       |
 2643|       |                     // MSVC requires get<I> rather than keys[I]
 2644|     43|                     static constexpr auto key = glz::get<I>(reflect<T>::keys); // GCC 14 requires auto here
 2645|     43|                     static constexpr auto quoted_key = quoted_key_v<key, Opts.prettify>;
 2646|     43|                     static constexpr auto n = quoted_key.size();
 2647|     43|                     std::memcpy(&b[ix], quoted_key.data(), n);
 2648|     43|                     ix += n;
 2649|       |
 2650|     43|                     static constexpr auto check_opts = required_padding<val_t>() ? write_unchecked_on<Opts>() : Opts;
 2651|     43|                     if constexpr (reflectable<T>) {
 2652|     43|                        to<JSON, val_t>::template op<check_opts>(get_member(value, get<I>(t)), ctx, b, ix);
 2653|     43|                     }
 2654|     43|                     else {
 2655|     43|                        to<JSON, val_t>::template op<check_opts>(get_member(value, get<I>(reflect<T>::values)), ctx, b,
 2656|     43|                                                                 ix);
 2657|     43|                     }
 2658|     43|                  }
 2659|     43|               });
 2660|       |            }
 2661|       |            else {
 2662|       |               static constexpr size_t fixed_max_size = Opts.prettify ? 0 : fixed_padding<T>;
 2663|       |               if constexpr (fixed_max_size && not check_write_unchecked(Options)) {
 2664|       |                  if (!ensure_space(ctx, b, ix + fixed_max_size)) [[unlikely]] {
 2665|       |                     return;
 2666|       |                  }
 2667|       |               }
 2668|       |
 2669|       |               for_each<N>([&]<size_t I>() {
 2670|       |                  if constexpr (write_can_error<T>()) {
 2671|       |                     if (bool(ctx.error)) [[unlikely]] {
 2672|       |                        return;
 2673|       |                     }
 2674|       |                  }
 2675|       |                  if constexpr (not fixed_max_size) {
 2676|       |                     if constexpr (Opts.prettify) {
 2677|       |                        if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] {
 2678|       |                           return;
 2679|       |                        }
 2680|       |                     }
 2681|       |                     else {
 2682|       |                        if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] {
 2683|       |                           return;
 2684|       |                        }
 2685|       |                     }
 2686|       |                  }
 2687|       |
 2688|       |                  if constexpr (I != 0 && Opts.prettify) {
 2689|       |                     std::memcpy(&b[ix], ",\n", 2);
 2690|       |                     ix += 2;
 2691|       |                     std::memset(&b[ix], check_indentation_char(Opts), ctx.depth);
 2692|       |                     ix += ctx.depth;
 2693|       |                  }
 2694|       |
 2695|       |                  using val_t = field_t<T, I>;
 2696|       |
 2697|       |                  // MSVC requires get<I> rather than keys[I]
 2698|       |                  static constexpr auto key = glz::get<I>(reflect<T>::keys); // GCC 14 requires auto here
 2699|       |                  if constexpr (always_null_t<val_t>) {
 2700|       |                     if constexpr (I == 0 || Opts.prettify) {
 2701|       |                        static constexpr auto quoted_key = join_v<quoted_key_v<key, Opts.prettify>, chars<"null">>;
 2702|       |                        static constexpr auto n = quoted_key.size();
 2703|       |                        std::memcpy(&b[ix], quoted_key.data(), n);
 2704|       |                        ix += n;
 2705|       |                     }
 2706|       |                     else {
 2707|       |                        static constexpr auto quoted_key = join_v<chars<",">, quoted_key_v<key>, chars<"null">>;
 2708|       |                        static constexpr auto n = quoted_key.size();
 2709|       |                        std::memcpy(&b[ix], quoted_key.data(), n);
 2710|       |                        ix += n;
 2711|       |                     }
 2712|       |                  }
 2713|       |                  else {
 2714|       |                     if constexpr (I == 0 || Opts.prettify) {
 2715|       |                        static constexpr auto quoted_key = quoted_key_v<key, Opts.prettify>;
 2716|       |                        static constexpr auto n = quoted_key.size();
 2717|       |                        std::memcpy(&b[ix], quoted_key.data(), n);
 2718|       |                        ix += n;
 2719|       |                     }
 2720|       |                     else {
 2721|       |                        static constexpr auto quoted_key = join_v<chars<",">, quoted_key_v<key>>;
 2722|       |                        static constexpr auto n = quoted_key.size();
 2723|       |                        std::memcpy(&b[ix], quoted_key.data(), n);
 2724|       |                        ix += n;
 2725|       |                     }
 2726|       |
 2727|       |                     static constexpr auto check_opts = required_padding<val_t>() ? write_unchecked_on<Opts>() : Opts;
 2728|       |                     if constexpr (reflectable<T>) {
 2729|       |                        to<JSON, val_t>::template op<check_opts>(get_member(value, get<I>(t)), ctx, b, ix);
 2730|       |                     }
 2731|       |                     else {
 2732|       |                        to<JSON, val_t>::template op<check_opts>(get_member(value, get<I>(reflect<T>::values)), ctx, b,
 2733|       |                                                                 ix);
 2734|       |                     }
 2735|       |                  }
 2736|       |               });
 2737|       |            }
 2738|       |
 2739|       |            // Options is required here, because it must be the top level
 2740|     43|            if constexpr (not check_closing_handled(Options)) {
 2741|       |               if constexpr (Options.prettify) {
 2742|       |                  ctx.depth -= check_indentation_width(Options);
 2743|       |                  if constexpr (not check_write_unchecked(Options)) {
 2744|       |                     if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] {
 2745|       |                        return;
 2746|       |                     }
 2747|       |                  }
 2748|       |                  std::memcpy(&b[ix], "\n", 1);
 2749|       |                  ++ix;
 2750|       |                  std::memset(&b[ix], check_indentation_char(Opts), ctx.depth);
 2751|       |                  ix += ctx.depth;
 2752|       |                  std::memcpy(&b[ix], "}", 1);
 2753|       |                  ++ix;
 2754|       |               }
 2755|     43|               else {
 2756|     43|                  dump<not(fixed_padding<T> || check_write_unchecked(Options))>('}', b, ix);
 2757|     43|               }
 2758|     43|            }
 2759|     43|         }
 2760|     43|      }
_ZZN3glz2toILj10EN12jsonrpc_fuzz8fuzz_apiEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlvE_clEv:
 2527|     43|            decltype(auto) t = [&]() -> decltype(auto) {
 2528|     43|               if constexpr (reflectable<T>) {
 2529|     43|                  return to_tie(value);
 2530|       |               }
 2531|       |               else {
 2532|       |                  return nullptr;
 2533|       |               }
 2534|     43|            }();
_ZZN3glz2toILj10EN12jsonrpc_fuzz8fuzz_apiEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlTnmvE_clILm0EEEDav:
 2539|     43|               for_each<N>([&]<size_t I>() {
 2540|     43|                  using val_t = field_t<T, I>;
 2541|       |
 2542|       |                  // `meta<T>::skip` joins the other compile-time exclusions here rather than returning
 2543|       |                  // early, so that a skipped field's writer is never instantiated -- see
 2544|       |                  // `skipped_by_meta`.
 2545|     43|                  constexpr bool write_function_pointers = check_write_function_pointers(Opts);
 2546|       |                  if constexpr (skipped_by_meta<T, I, operation::serialize> || always_skipped<val_t> ||
 2547|       |                                (!write_function_pointers && is_any_function_ptr<val_t>)) {
 2548|       |                     return;
 2549|       |                  }
 2550|     43|                  else {
 2551|       |                     if constexpr (meta_has_skip_if<T>) {
 2552|       |                        static constexpr auto skip_if_key = glz::get<I>(reflect<T>::keys);
 2553|       |                        static constexpr meta_context mctx{.op = operation::serialize};
 2554|       |                        decltype(auto) field_value = [&]() -> decltype(auto) {
 2555|       |                           if constexpr (reflectable<T>) {
 2556|       |                              return get<I>(t);
 2557|       |                           }
 2558|       |                           else {
 2559|       |                              return get_member(value, glz::get<I>(reflect<T>::values));
 2560|       |                           }
 2561|       |                        }();
 2562|       |                        if (meta<T>::skip_if(field_value, skip_if_key, mctx)) return;
 2563|       |                     }
 2564|       |
 2565|       |                     if constexpr (null_t<val_t> && Opts.skip_null_members) {
 2566|       |                        if constexpr (always_null_t<val_t>)
 2567|       |                           return;
 2568|       |                        else {
 2569|       |                           const auto is_null = [&]() {
 2570|       |                              decltype(auto) element = [&]() -> decltype(auto) {
 2571|       |                                 if constexpr (reflectable<T>) {
 2572|       |                                    return get<I>(t);
 2573|       |                                 }
 2574|       |                                 else {
 2575|       |                                    return get<I>(reflect<T>::values);
 2576|       |                                 }
 2577|       |                              };
 2578|       |
 2579|       |                              if constexpr (nullable_wrapper<val_t>) {
 2580|       |                                 return !bool(element()(value).val);
 2581|       |                              }
 2582|       |                              else if constexpr (nullable_value_t<val_t>) {
 2583|       |                                 return !get_member(value, element()).has_value();
 2584|       |                              }
 2585|       |                              else {
 2586|       |                                 return !bool(get_member(value, element()));
 2587|       |                              }
 2588|       |                           }();
 2589|       |                           if (is_null) return;
 2590|       |                        }
 2591|       |                     }
 2592|       |                     else if constexpr (is_specialization_v<val_t, custom_t> && Opts.skip_null_members &&
 2593|       |                                        custom_getter_returns_nullable<val_t>()) {
 2594|       |                        if (is_custom_field_null<T, I>(value, t, ctx)) return;
 2595|       |                     }
 2596|     43|                     else if constexpr (Opts.skip_null_members && glaze_value_is_nullable<val_t>()) {
 2597|     43|                        if (is_glaze_value_field_null<T, I>(value, t)) return;
 2598|     43|                     }
 2599|       |
 2600|       |                     if constexpr (check_skip_default_members(Opts) && has_skippable_default<val_t>) {
 2601|       |                        decltype(auto) member = [&]() -> decltype(auto) {
 2602|       |                           if constexpr (reflectable<T>) {
 2603|       |                              return get_member(value, get<I>(t));
 2604|       |                           }
 2605|       |                           else {
 2606|       |                              return get_member(value, get<I>(reflect<T>::values));
 2607|       |                           }
 2608|       |                        }();
 2609|       |                        if (is_default_value(member)) return;
 2610|       |                     }
 2611|       |
 2612|       |                     if constexpr (Opts.prettify) {
 2613|       |                        if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] {
 2614|       |                           return;
 2615|       |                        }
 2616|       |                     }
 2617|     43|                     else {
 2618|     43|                        if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] {
  ------------------
  |  Branch (2618:29): [True: 0, False: 43]
  ------------------
 2619|      0|                           return;
 2620|      0|                        }
 2621|     43|                     }
 2622|       |
 2623|     43|                     if (first) {
  ------------------
  |  Branch (2623:26): [True: 43, False: 0]
  ------------------
 2624|     43|                        first = false;
 2625|     43|                     }
 2626|      0|                     else {
 2627|       |                        // Null members may be skipped so we can't just write it out for all but the last member
 2628|       |                        if constexpr (Opts.prettify) {
 2629|       |                           std::memcpy(&b[ix], ",\n", 2);
 2630|       |                           ix += 2;
 2631|       |                           std::memset(&b[ix], check_indentation_char(Opts), ctx.depth);
 2632|       |                           ix += ctx.depth;
 2633|       |                        }
 2634|      0|                        else {
 2635|      0|                           std::memcpy(&b[ix], ",", 1);
 2636|      0|                           ++ix;
 2637|      0|                        }
 2638|       |                        if constexpr (is_output_streaming<B>) {
 2639|       |                           flush_buffer(b, ix);
 2640|       |                        }
 2641|      0|                     }
 2642|       |
 2643|       |                     // MSVC requires get<I> rather than keys[I]
 2644|     43|                     static constexpr auto key = glz::get<I>(reflect<T>::keys); // GCC 14 requires auto here
 2645|     43|                     static constexpr auto quoted_key = quoted_key_v<key, Opts.prettify>;
 2646|     43|                     static constexpr auto n = quoted_key.size();
 2647|     43|                     std::memcpy(&b[ix], quoted_key.data(), n);
 2648|     43|                     ix += n;
 2649|       |
 2650|     43|                     static constexpr auto check_opts = required_padding<val_t>() ? write_unchecked_on<Opts>() : Opts;
  ------------------
  |  Branch (2650:57): [True: 0, Folded]
  ------------------
 2651|     43|                     if constexpr (reflectable<T>) {
 2652|     43|                        to<JSON, val_t>::template op<check_opts>(get_member(value, get<I>(t)), ctx, b, ix);
 2653|       |                     }
 2654|       |                     else {
 2655|       |                        to<JSON, val_t>::template op<check_opts>(get_member(value, get<I>(reflect<T>::values)), ctx, b,
 2656|       |                                                                 ix);
 2657|       |                     }
 2658|     43|                  }
 2659|     43|               });
_ZZN3glz2toILj10EN12jsonrpc_fuzz8fuzz_apiEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlTnmvE_clILm1EEEDav:
 2539|     43|               for_each<N>([&]<size_t I>() {
 2540|     43|                  using val_t = field_t<T, I>;
 2541|       |
 2542|       |                  // `meta<T>::skip` joins the other compile-time exclusions here rather than returning
 2543|       |                  // early, so that a skipped field's writer is never instantiated -- see
 2544|       |                  // `skipped_by_meta`.
 2545|     43|                  constexpr bool write_function_pointers = check_write_function_pointers(Opts);
 2546|       |                  if constexpr (skipped_by_meta<T, I, operation::serialize> || always_skipped<val_t> ||
 2547|       |                                (!write_function_pointers && is_any_function_ptr<val_t>)) {
 2548|       |                     return;
 2549|       |                  }
 2550|     43|                  else {
 2551|       |                     if constexpr (meta_has_skip_if<T>) {
 2552|       |                        static constexpr auto skip_if_key = glz::get<I>(reflect<T>::keys);
 2553|       |                        static constexpr meta_context mctx{.op = operation::serialize};
 2554|       |                        decltype(auto) field_value = [&]() -> decltype(auto) {
 2555|       |                           if constexpr (reflectable<T>) {
 2556|       |                              return get<I>(t);
 2557|       |                           }
 2558|       |                           else {
 2559|       |                              return get_member(value, glz::get<I>(reflect<T>::values));
 2560|       |                           }
 2561|       |                        }();
 2562|       |                        if (meta<T>::skip_if(field_value, skip_if_key, mctx)) return;
 2563|       |                     }
 2564|       |
 2565|       |                     if constexpr (null_t<val_t> && Opts.skip_null_members) {
 2566|       |                        if constexpr (always_null_t<val_t>)
 2567|       |                           return;
 2568|       |                        else {
 2569|       |                           const auto is_null = [&]() {
 2570|       |                              decltype(auto) element = [&]() -> decltype(auto) {
 2571|       |                                 if constexpr (reflectable<T>) {
 2572|       |                                    return get<I>(t);
 2573|       |                                 }
 2574|       |                                 else {
 2575|       |                                    return get<I>(reflect<T>::values);
 2576|       |                                 }
 2577|       |                              };
 2578|       |
 2579|       |                              if constexpr (nullable_wrapper<val_t>) {
 2580|       |                                 return !bool(element()(value).val);
 2581|       |                              }
 2582|       |                              else if constexpr (nullable_value_t<val_t>) {
 2583|       |                                 return !get_member(value, element()).has_value();
 2584|       |                              }
 2585|       |                              else {
 2586|       |                                 return !bool(get_member(value, element()));
 2587|       |                              }
 2588|       |                           }();
 2589|       |                           if (is_null) return;
 2590|       |                        }
 2591|       |                     }
 2592|       |                     else if constexpr (is_specialization_v<val_t, custom_t> && Opts.skip_null_members &&
 2593|       |                                        custom_getter_returns_nullable<val_t>()) {
 2594|       |                        if (is_custom_field_null<T, I>(value, t, ctx)) return;
 2595|       |                     }
 2596|     43|                     else if constexpr (Opts.skip_null_members && glaze_value_is_nullable<val_t>()) {
 2597|     43|                        if (is_glaze_value_field_null<T, I>(value, t)) return;
 2598|     43|                     }
 2599|       |
 2600|       |                     if constexpr (check_skip_default_members(Opts) && has_skippable_default<val_t>) {
 2601|       |                        decltype(auto) member = [&]() -> decltype(auto) {
 2602|       |                           if constexpr (reflectable<T>) {
 2603|       |                              return get_member(value, get<I>(t));
 2604|       |                           }
 2605|       |                           else {
 2606|       |                              return get_member(value, get<I>(reflect<T>::values));
 2607|       |                           }
 2608|       |                        }();
 2609|       |                        if (is_default_value(member)) return;
 2610|       |                     }
 2611|       |
 2612|       |                     if constexpr (Opts.prettify) {
 2613|       |                        if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] {
 2614|       |                           return;
 2615|       |                        }
 2616|       |                     }
 2617|     43|                     else {
 2618|     43|                        if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] {
  ------------------
  |  Branch (2618:29): [True: 0, False: 43]
  ------------------
 2619|      0|                           return;
 2620|      0|                        }
 2621|     43|                     }
 2622|       |
 2623|     43|                     if (first) {
  ------------------
  |  Branch (2623:26): [True: 0, False: 43]
  ------------------
 2624|      0|                        first = false;
 2625|      0|                     }
 2626|     43|                     else {
 2627|       |                        // Null members may be skipped so we can't just write it out for all but the last member
 2628|       |                        if constexpr (Opts.prettify) {
 2629|       |                           std::memcpy(&b[ix], ",\n", 2);
 2630|       |                           ix += 2;
 2631|       |                           std::memset(&b[ix], check_indentation_char(Opts), ctx.depth);
 2632|       |                           ix += ctx.depth;
 2633|       |                        }
 2634|     43|                        else {
 2635|     43|                           std::memcpy(&b[ix], ",", 1);
 2636|     43|                           ++ix;
 2637|     43|                        }
 2638|       |                        if constexpr (is_output_streaming<B>) {
 2639|       |                           flush_buffer(b, ix);
 2640|       |                        }
 2641|     43|                     }
 2642|       |
 2643|       |                     // MSVC requires get<I> rather than keys[I]
 2644|     43|                     static constexpr auto key = glz::get<I>(reflect<T>::keys); // GCC 14 requires auto here
 2645|     43|                     static constexpr auto quoted_key = quoted_key_v<key, Opts.prettify>;
 2646|     43|                     static constexpr auto n = quoted_key.size();
 2647|     43|                     std::memcpy(&b[ix], quoted_key.data(), n);
 2648|     43|                     ix += n;
 2649|       |
 2650|     43|                     static constexpr auto check_opts = required_padding<val_t>() ? write_unchecked_on<Opts>() : Opts;
  ------------------
  |  Branch (2650:57): [Folded, False: 43]
  ------------------
 2651|     43|                     if constexpr (reflectable<T>) {
 2652|     43|                        to<JSON, val_t>::template op<check_opts>(get_member(value, get<I>(t)), ctx, b, ix);
 2653|       |                     }
 2654|       |                     else {
 2655|       |                        to<JSON, val_t>::template op<check_opts>(get_member(value, get<I>(reflect<T>::values)), ctx, b,
 2656|       |                                                                 ix);
 2657|       |                     }
 2658|     43|                  }
 2659|     43|               });
_ZN3glz2toILj10ENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS7_SB_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_:
  845|    859|      {
  846|       |         if constexpr (check_string_as_number(Opts)) {
  847|       |            const sv str = [&]() -> const sv {
  848|       |               if constexpr (array_char_t<T>) {
  849|       |                  const auto* start = value.data();
  850|       |                  const auto* end = static_cast<const char*>(std::memchr(start, '\0', value.size()));
  851|       |                  return sv{start, end ? size_t(end - start) : value.size()};
  852|       |               }
  853|       |               else if constexpr (u8str_t<T>) {
  854|       |                  return sv{reinterpret_cast<const char*>(value.data()), value.size()};
  855|       |               }
  856|       |               else {
  857|       |                  return str_view<T>(value);
  858|       |               }
  859|       |            }();
  860|       |            if (!ensure_space(ctx, b, ix + str.size() + write_padding_bytes)) [[unlikely]] {
  861|       |               return;
  862|       |            }
  863|       |            dump_maybe_empty<false>(str, b, ix);
  864|       |         }
  865|       |         else if constexpr (char_t<T>) {
  866|       |            if constexpr (check_unquoted(Opts)) {
  867|       |               dump(value, b, ix);
  868|       |            }
  869|       |            else {
  870|       |               // 8 bytes is enough for quotes and escaped character (worst case: \uXXXX = 6 + 2 quotes)
  871|       |               if (!ensure_space(ctx, b, ix + 8)) [[unlikely]] {
  872|       |                  return;
  873|       |               }
  874|       |
  875|       |               std::memcpy(&b[ix], "\"", 1);
  876|       |               ++ix;
  877|       |               if (const auto escaped = char_escape_table[uint8_t(value)]; escaped) {
  878|       |                  std::memcpy(&b[ix], &escaped, 2);
  879|       |                  ix += 2;
  880|       |               }
  881|       |               else if (value == '\0') {
  882|       |                  // null character treated as empty string
  883|       |               }
  884|       |               else if constexpr (check_escape_control_characters(Opts)) {
  885|       |                  if (uint8_t(value) < 0x20) {
  886|       |                     // Write as \uXXXX format
  887|       |                     char unicode_escape[6] = {'\\', 'u', '0', '0', '0', '0'};
  888|       |                     constexpr char hex_digits[] = "0123456789ABCDEF";
  889|       |                     unicode_escape[4] = hex_digits[(value >> 4) & 0xF];
  890|       |                     unicode_escape[5] = hex_digits[value & 0xF];
  891|       |                     std::memcpy(&b[ix], unicode_escape, 6);
  892|       |                     ix += 6;
  893|       |                  }
  894|       |                  else {
  895|       |                     std::memcpy(&b[ix], &value, 1);
  896|       |                     ++ix;
  897|       |                  }
  898|       |               }
  899|       |               else {
  900|       |                  if constexpr (check_reject_control_characters(Opts)) {
  901|       |                     if (uint8_t(value) < 0x20) [[unlikely]] {
  902|       |                        ctx.error = error_code::invalid_control_character;
  903|       |                     }
  904|       |                  }
  905|       |                  std::memcpy(&b[ix], &value, 1);
  906|       |                  ++ix;
  907|       |               }
  908|       |               std::memcpy(&b[ix], "\"", 1);
  909|       |               ++ix;
  910|       |            }
  911|       |         }
  912|    859|         else {
  913|       |            if constexpr (check_raw_string(Opts)) {
  914|       |               const sv str = [&]() -> const sv {
  915|       |                  if constexpr (u8str_t<T>) {
  916|       |                     return sv{reinterpret_cast<const char*>(value.data()), value.size()};
  917|       |                  }
  918|       |                  else {
  919|       |                     return str_view<T>(value);
  920|       |                  }
  921|       |               }();
  922|       |
  923|       |               // We need space for quotes and the string length: 2 + n.
  924|       |               // Use +8 for extra buffer
  925|       |               if (!ensure_space(ctx, b, ix + 8 + str.size())) [[unlikely]] {
  926|       |                  return;
  927|       |               }
  928|       |               // now we don't have to check writing
  929|       |
  930|       |               if constexpr (not check_unquoted(Opts)) {
  931|       |                  std::memcpy(&b[ix], "\"", 1);
  932|       |                  ++ix;
  933|       |               }
  934|       |               if (str.size()) [[likely]] {
  935|       |                  const auto n = str.size();
  936|       |                  std::memcpy(&b[ix], str.data(), n);
  937|       |                  ix += n;
  938|       |               }
  939|       |               if constexpr (not check_unquoted(Opts)) {
  940|       |                  std::memcpy(&b[ix], "\"", 1);
  941|       |                  ++ix;
  942|       |               }
  943|       |            }
  944|    859|            else {
  945|    859|               const sv str = [&]() -> const sv {
  946|    859|                  if constexpr (array_char_t<T>) {
  947|    859|                     return sv{value.data(), value.size()};
  948|    859|                  }
  949|    859|                  else if constexpr (u8str_t<T>) {
  950|    859|                     return sv{reinterpret_cast<const char*>(value.data()), value.size()};
  951|    859|                  }
  952|    859|                  else {
  953|    859|                     return str_view<T>(value);
  954|    859|                  }
  955|    859|               }();
  956|    859|               const auto n = str.size();
  957|       |
  958|       |               // In the case n == 0 we need two characters for quotes.
  959|       |               // For each individual character we need room for two characters to handle escapes.
  960|       |               // When using Unicode escapes, we might need up to 6 characters (\uXXXX) per character
  961|       |               if constexpr (check_escape_control_characters(Opts)) {
  962|       |                  if constexpr (has_bounded_capacity<B>) {
  963|       |                     // 6 bytes per character is a ceiling only a string of nothing but control
  964|       |                     // characters reaches. A resizable buffer merely over-allocates against it,
  965|       |                     // but a fixed buffer has nowhere to grow, so the ceiling would reject output
  966|       |                     // that fits. Measuring the string answers exactly, at the cost of a pass over
  967|       |                     // it, so bracket the measurement between two O(1) bounds and only pay it when
  968|       |                     // the answer is still in doubt: the ceiling fitting means yes, and the floor
  969|       |                     // of one byte per character not fitting means no.
  970|       |                     const size_t capacity = buffer_traits<std::remove_cvref_t<B>>::capacity(b);
  971|       |                     size_t required = ix + 10 + 6 * n;
  972|       |                     if (required > capacity) [[unlikely]] {
  973|       |                        required = ix + 10 + n;
  974|       |                        if (required <= capacity) {
  975|       |                           required = ix + 10 + detail::escaped_string_size(str);
  976|       |                        }
  977|       |                     }
  978|       |                     if (!ensure_space(ctx, b, required)) [[unlikely]] {
  979|       |                        return;
  980|       |                     }
  981|       |                  }
  982|       |                  // We need 2 + 6 * n characters in the worst case (all control chars)
  983|       |                  else if (!ensure_space(ctx, b, ix + 10 + 6 * n)) [[unlikely]] {
  984|       |                     return;
  985|       |                  }
  986|       |               }
  987|    859|               else {
  988|       |                  // Using the original sizing
  989|    859|                  if (!ensure_space(ctx, b, ix + 10 + 2 * n)) [[unlikely]] {
  ------------------
  |  Branch (989:23): [True: 0, False: 859]
  ------------------
  990|      0|                     return;
  991|      0|                  }
  992|    859|               }
  993|       |               // now we don't have to check writing
  994|       |
  995|       |               if constexpr (check_unquoted(Opts)) {
  996|       |                  if (n) {
  997|       |                     std::memcpy(&b[ix], str.data(), n);
  998|       |                     ix += n;
  999|       |                  }
 1000|       |               }
 1001|    859|               else {
 1002|    859|                  std::memcpy(&b[ix], "\"", 1);
 1003|    859|                  ++ix;
 1004|       |
 1005|    859|                  const auto* c = str.data();
 1006|    859|                  const auto* const e = c + n;
 1007|    859|                  const auto start = &b[ix];
 1008|    859|                  auto data = start;
 1009|       |
 1010|       |                  // By default we don't escape control characters for performance. Invalid JSON characters
 1011|       |                  // result in null characters in the output, making the JSON invalid — these would then be
 1012|       |                  // detected upon reading. Enable the `escape_control_characters` option to properly escape
 1013|       |                  // control characters (0x00–0x1F) as \uXXXX sequences.
 1014|       |
 1015|       |                  // Escape handler: writes the escaped form of *c into data, advances both pointers
 1016|    859|                  auto write_escape = [&]() {
 1017|    859|                     if constexpr (check_escape_control_characters(Opts)) {
 1018|    859|                        if (const auto escaped = char_escape_table[uint8_t(*c)]; escaped) {
 1019|    859|                           std::memcpy(data, &escaped, 2);
 1020|    859|                           data += 2;
 1021|    859|                        }
 1022|    859|                        else {
 1023|    859|                           char unicode_escape[6] = {'\\', 'u', '0', '0', '0', '0'};
 1024|    859|                           constexpr char hex_digits[] = "0123456789ABCDEF";
 1025|    859|                           unicode_escape[4] = hex_digits[(uint8_t(*c) >> 4) & 0xF];
 1026|    859|                           unicode_escape[5] = hex_digits[uint8_t(*c) & 0xF];
 1027|    859|                           std::memcpy(data, unicode_escape, 6);
 1028|    859|                           data += 6;
 1029|    859|                        }
 1030|    859|                     }
 1031|    859|                     else {
 1032|    859|                        if constexpr (check_reject_control_characters(Opts)) {
 1033|       |                           // A control character with no two-character escape cannot be written
 1034|       |                           // without \uXXXX. The table entry is zero, so the memcpy below would
 1035|       |                           // put two NULs where one byte was. Flag it and let the loop finish:
 1036|       |                           // returning early here would leave c un-advanced and the SIMD scan
 1037|       |                           // would find the same byte forever. The output is abandoned anyway.
 1038|    859|                           if (char_escape_table[uint8_t(*c)] == 0) [[unlikely]] {
 1039|    859|                              ctx.error = error_code::invalid_control_character;
 1040|    859|                           }
 1041|    859|                        }
 1042|    859|                        std::memcpy(data, &char_escape_table[uint8_t(*c)], 2);
 1043|    859|                        data += 2;
 1044|    859|                     }
 1045|    859|                     ++c;
 1046|    859|                  };
 1047|       |
 1048|       |                  // Adding a helper here means adding a branch to string_escape_simd() in
 1049|       |                  // simd/backends.hpp, which names the widest one this cascade invokes, and a row
 1050|       |                  // to known_builds in tests/json_test/utf8_validation_test.cpp, which checks it.
 1051|       |#if defined(GLZ_USE_AVX2)
 1052|       |                  detail::avx2_string_escape(c, e, data, n, write_escape);
 1053|       |#endif
 1054|    859|#if defined(GLZ_USE_SSE2)
 1055|    859|                  detail::sse2_string_escape(c, e, data, n, write_escape);
 1056|       |#elif defined(GLZ_USE_NEON)
 1057|       |                  detail::neon_string_escape(c, e, data, n, write_escape);
 1058|       |#endif
 1059|       |
 1060|       |                  // SWAR: 8 bytes at a time
 1061|    859|                  if (n > 7) {
  ------------------
  |  Branch (1061:23): [True: 332, False: 527]
  ------------------
 1062|    717|                     for (const auto end_m7 = e - 7; c < end_m7;) {
  ------------------
  |  Branch (1062:54): [True: 385, False: 332]
  ------------------
 1063|    385|                        std::memcpy(data, c, 8);
 1064|    385|                        uint64_t swar;
 1065|    385|                        std::memcpy(&swar, c, 8);
 1066|       |                        if constexpr (std::endian::native == std::endian::big) {
 1067|       |                           swar = std::byteswap(swar);
 1068|       |                        }
 1069|       |
 1070|    385|                        constexpr uint64_t lo7_mask = repeat_byte8(0b01111111);
 1071|    385|                        const uint64_t lo7 = swar & lo7_mask;
 1072|    385|                        const uint64_t quote = (lo7 ^ repeat_byte8('"')) + lo7_mask;
 1073|    385|                        const uint64_t backslash = (lo7 ^ repeat_byte8('\\')) + lo7_mask;
 1074|    385|                        const uint64_t less_32 = (swar & repeat_byte8(0b01100000)) + lo7_mask;
 1075|    385|                        uint64_t next = ~((quote & backslash & less_32) | swar);
 1076|       |
 1077|    385|                        next &= repeat_byte8(0b10000000);
 1078|    385|                        if (next == 0) {
  ------------------
  |  Branch (1078:29): [True: 186, False: 199]
  ------------------
 1079|    186|                           data += 8;
 1080|    186|                           c += 8;
 1081|    186|                           continue;
 1082|    186|                        }
 1083|       |
 1084|    199|                        const auto length = (countr_zero(next) >> 3);
 1085|    199|                        c += length;
 1086|    199|                        data += length;
 1087|    199|                        write_escape();
 1088|    199|                     }
 1089|    332|                  }
 1090|       |
 1091|       |                  // Scalar tail
 1092|  3.07k|                  for (; c < e; ++c) {
  ------------------
  |  Branch (1092:26): [True: 2.21k, False: 859]
  ------------------
 1093|  2.21k|                     if (const auto escaped = char_escape_table[uint8_t(*c)]; escaped) {
  ------------------
  |  Branch (1093:79): [True: 242, False: 1.97k]
  ------------------
 1094|    242|                        std::memcpy(data, &escaped, 2);
 1095|    242|                        data += 2;
 1096|    242|                     }
 1097|       |                     else if constexpr (check_escape_control_characters(Opts)) {
 1098|       |                        if (uint8_t(*c) < 0x20) {
 1099|       |                           char unicode_escape[6] = {'\\', 'u', '0', '0', '0', '0'};
 1100|       |                           constexpr char hex_digits[] = "0123456789ABCDEF";
 1101|       |                           unicode_escape[4] = hex_digits[(uint8_t(*c) >> 4) & 0xF];
 1102|       |                           unicode_escape[5] = hex_digits[uint8_t(*c) & 0xF];
 1103|       |                           std::memcpy(data, unicode_escape, 6);
 1104|       |                           data += 6;
 1105|       |                        }
 1106|       |                        else {
 1107|       |                           std::memcpy(data, c, 1);
 1108|       |                           ++data;
 1109|       |                        }
 1110|       |                     }
 1111|  1.97k|                     else {
 1112|       |                        if constexpr (check_reject_control_characters(Opts)) {
 1113|       |                           if (uint8_t(*c) < 0x20) [[unlikely]] {
 1114|       |                              ctx.error = error_code::invalid_control_character;
 1115|       |                           }
 1116|       |                        }
 1117|  1.97k|                        std::memcpy(data, c, 1);
 1118|  1.97k|                        ++data;
 1119|  1.97k|                     }
 1120|  2.21k|                  }
 1121|       |
 1122|    859|                  ix += size_t(data - start);
 1123|       |
 1124|    859|                  std::memcpy(&b[ix], "\"", 1);
 1125|    859|                  ++ix;
 1126|    859|               }
 1127|    859|            }
 1128|    859|         }
 1129|    859|      }
_ZZN3glz2toILj10ENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS7_SB_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_ENKUlvE_clEv:
  945|    859|               const sv str = [&]() -> const sv {
  946|       |                  if constexpr (array_char_t<T>) {
  947|       |                     return sv{value.data(), value.size()};
  948|       |                  }
  949|       |                  else if constexpr (u8str_t<T>) {
  950|       |                     return sv{reinterpret_cast<const char*>(value.data()), value.size()};
  951|       |                  }
  952|    859|                  else {
  953|    859|                     return str_view<T>(value);
  954|    859|                  }
  955|    859|               }();
_ZZN3glz2toILj10ENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS7_SB_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_ENKUlvE0_clEv:
 1016|  8.99k|                  auto write_escape = [&]() {
 1017|       |                     if constexpr (check_escape_control_characters(Opts)) {
 1018|       |                        if (const auto escaped = char_escape_table[uint8_t(*c)]; escaped) {
 1019|       |                           std::memcpy(data, &escaped, 2);
 1020|       |                           data += 2;
 1021|       |                        }
 1022|       |                        else {
 1023|       |                           char unicode_escape[6] = {'\\', 'u', '0', '0', '0', '0'};
 1024|       |                           constexpr char hex_digits[] = "0123456789ABCDEF";
 1025|       |                           unicode_escape[4] = hex_digits[(uint8_t(*c) >> 4) & 0xF];
 1026|       |                           unicode_escape[5] = hex_digits[uint8_t(*c) & 0xF];
 1027|       |                           std::memcpy(data, unicode_escape, 6);
 1028|       |                           data += 6;
 1029|       |                        }
 1030|       |                     }
 1031|  8.99k|                     else {
 1032|       |                        if constexpr (check_reject_control_characters(Opts)) {
 1033|       |                           // A control character with no two-character escape cannot be written
 1034|       |                           // without \uXXXX. The table entry is zero, so the memcpy below would
 1035|       |                           // put two NULs where one byte was. Flag it and let the loop finish:
 1036|       |                           // returning early here would leave c un-advanced and the SIMD scan
 1037|       |                           // would find the same byte forever. The output is abandoned anyway.
 1038|       |                           if (char_escape_table[uint8_t(*c)] == 0) [[unlikely]] {
 1039|       |                              ctx.error = error_code::invalid_control_character;
 1040|       |                           }
 1041|       |                        }
 1042|  8.99k|                        std::memcpy(data, &char_escape_table[uint8_t(*c)], 2);
 1043|  8.99k|                        data += 2;
 1044|  8.99k|                     }
 1045|  8.99k|                     ++c;
 1046|  8.99k|                  };
_ZZN3glz2toILj10EN12jsonrpc_fuzz8fuzz_apiEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlTnmvE_clILm2EEEDav:
 2539|     43|               for_each<N>([&]<size_t I>() {
 2540|     43|                  using val_t = field_t<T, I>;
 2541|       |
 2542|       |                  // `meta<T>::skip` joins the other compile-time exclusions here rather than returning
 2543|       |                  // early, so that a skipped field's writer is never instantiated -- see
 2544|       |                  // `skipped_by_meta`.
 2545|     43|                  constexpr bool write_function_pointers = check_write_function_pointers(Opts);
 2546|       |                  if constexpr (skipped_by_meta<T, I, operation::serialize> || always_skipped<val_t> ||
 2547|       |                                (!write_function_pointers && is_any_function_ptr<val_t>)) {
 2548|       |                     return;
 2549|       |                  }
 2550|     43|                  else {
 2551|       |                     if constexpr (meta_has_skip_if<T>) {
 2552|       |                        static constexpr auto skip_if_key = glz::get<I>(reflect<T>::keys);
 2553|       |                        static constexpr meta_context mctx{.op = operation::serialize};
 2554|       |                        decltype(auto) field_value = [&]() -> decltype(auto) {
 2555|       |                           if constexpr (reflectable<T>) {
 2556|       |                              return get<I>(t);
 2557|       |                           }
 2558|       |                           else {
 2559|       |                              return get_member(value, glz::get<I>(reflect<T>::values));
 2560|       |                           }
 2561|       |                        }();
 2562|       |                        if (meta<T>::skip_if(field_value, skip_if_key, mctx)) return;
 2563|       |                     }
 2564|       |
 2565|       |                     if constexpr (null_t<val_t> && Opts.skip_null_members) {
 2566|       |                        if constexpr (always_null_t<val_t>)
 2567|       |                           return;
 2568|       |                        else {
 2569|       |                           const auto is_null = [&]() {
 2570|       |                              decltype(auto) element = [&]() -> decltype(auto) {
 2571|       |                                 if constexpr (reflectable<T>) {
 2572|       |                                    return get<I>(t);
 2573|       |                                 }
 2574|       |                                 else {
 2575|       |                                    return get<I>(reflect<T>::values);
 2576|       |                                 }
 2577|       |                              };
 2578|       |
 2579|       |                              if constexpr (nullable_wrapper<val_t>) {
 2580|       |                                 return !bool(element()(value).val);
 2581|       |                              }
 2582|       |                              else if constexpr (nullable_value_t<val_t>) {
 2583|       |                                 return !get_member(value, element()).has_value();
 2584|       |                              }
 2585|       |                              else {
 2586|       |                                 return !bool(get_member(value, element()));
 2587|       |                              }
 2588|       |                           }();
 2589|       |                           if (is_null) return;
 2590|       |                        }
 2591|       |                     }
 2592|       |                     else if constexpr (is_specialization_v<val_t, custom_t> && Opts.skip_null_members &&
 2593|       |                                        custom_getter_returns_nullable<val_t>()) {
 2594|       |                        if (is_custom_field_null<T, I>(value, t, ctx)) return;
 2595|       |                     }
 2596|     43|                     else if constexpr (Opts.skip_null_members && glaze_value_is_nullable<val_t>()) {
 2597|     43|                        if (is_glaze_value_field_null<T, I>(value, t)) return;
 2598|     43|                     }
 2599|       |
 2600|       |                     if constexpr (check_skip_default_members(Opts) && has_skippable_default<val_t>) {
 2601|       |                        decltype(auto) member = [&]() -> decltype(auto) {
 2602|       |                           if constexpr (reflectable<T>) {
 2603|       |                              return get_member(value, get<I>(t));
 2604|       |                           }
 2605|       |                           else {
 2606|       |                              return get_member(value, get<I>(reflect<T>::values));
 2607|       |                           }
 2608|       |                        }();
 2609|       |                        if (is_default_value(member)) return;
 2610|       |                     }
 2611|       |
 2612|       |                     if constexpr (Opts.prettify) {
 2613|       |                        if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] {
 2614|       |                           return;
 2615|       |                        }
 2616|       |                     }
 2617|     43|                     else {
 2618|     43|                        if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] {
  ------------------
  |  Branch (2618:29): [True: 0, False: 43]
  ------------------
 2619|      0|                           return;
 2620|      0|                        }
 2621|     43|                     }
 2622|       |
 2623|     43|                     if (first) {
  ------------------
  |  Branch (2623:26): [True: 0, False: 43]
  ------------------
 2624|      0|                        first = false;
 2625|      0|                     }
 2626|     43|                     else {
 2627|       |                        // Null members may be skipped so we can't just write it out for all but the last member
 2628|       |                        if constexpr (Opts.prettify) {
 2629|       |                           std::memcpy(&b[ix], ",\n", 2);
 2630|       |                           ix += 2;
 2631|       |                           std::memset(&b[ix], check_indentation_char(Opts), ctx.depth);
 2632|       |                           ix += ctx.depth;
 2633|       |                        }
 2634|     43|                        else {
 2635|     43|                           std::memcpy(&b[ix], ",", 1);
 2636|     43|                           ++ix;
 2637|     43|                        }
 2638|       |                        if constexpr (is_output_streaming<B>) {
 2639|       |                           flush_buffer(b, ix);
 2640|       |                        }
 2641|     43|                     }
 2642|       |
 2643|       |                     // MSVC requires get<I> rather than keys[I]
 2644|     43|                     static constexpr auto key = glz::get<I>(reflect<T>::keys); // GCC 14 requires auto here
 2645|     43|                     static constexpr auto quoted_key = quoted_key_v<key, Opts.prettify>;
 2646|     43|                     static constexpr auto n = quoted_key.size();
 2647|     43|                     std::memcpy(&b[ix], quoted_key.data(), n);
 2648|     43|                     ix += n;
 2649|       |
 2650|     43|                     static constexpr auto check_opts = required_padding<val_t>() ? write_unchecked_on<Opts>() : Opts;
  ------------------
  |  Branch (2650:57): [Folded, False: 43]
  ------------------
 2651|     43|                     if constexpr (reflectable<T>) {
 2652|     43|                        to<JSON, val_t>::template op<check_opts>(get_member(value, get<I>(t)), ctx, b, ix);
 2653|       |                     }
 2654|       |                     else {
 2655|       |                        to<JSON, val_t>::template op<check_opts>(get_member(value, get<I>(reflect<T>::values)), ctx, b,
 2656|       |                                                                 ix);
 2657|       |                     }
 2658|     43|                  }
 2659|     43|               });
_ZN3glz2toILj10EN12jsonrpc_fuzz5pointEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_:
 2465|    262|      {
 2466|    262|         using ValueType = std::decay_t<V>;
 2467|       |         if constexpr (has_unknown_writer<ValueType> && not check_disable_write_unknown(Options)) {
 2468|       |            constexpr auto& writer = meta_unknown_write_v<ValueType>;
 2469|       |
 2470|       |            using WriterType = meta_unknown_write_t<ValueType>;
 2471|       |            if constexpr (std::is_member_object_pointer_v<WriterType>) {
 2472|       |               decltype(auto) unknown_writer = value.*writer;
 2473|       |               if (unknown_writer.size() > 0) {
 2474|       |                  // TODO: This intermediate is added to get GCC 14 to build
 2475|       |                  decltype(auto) merged = glz::merge{value, unknown_writer};
 2476|       |                  serialize<JSON>::op<disable_write_unknown_on<Options>()>(std::move(merged), ctx, b, ix);
 2477|       |               }
 2478|       |               else {
 2479|       |                  serialize<JSON>::op<disable_write_unknown_on<Options>()>(value, ctx, b, ix);
 2480|       |               }
 2481|       |            }
 2482|       |            else if constexpr (std::is_member_function_pointer_v<WriterType>) {
 2483|       |               decltype(auto) unknown_writer = (value.*writer)();
 2484|       |               if (unknown_writer.size() > 0) {
 2485|       |                  // TODO: This intermediate is added to get GCC 14 to build
 2486|       |                  decltype(auto) merged = glz::merge{value, unknown_writer};
 2487|       |                  serialize<JSON>::op<disable_write_unknown_on<Options>()>(std::move(merged), ctx, b, ix);
 2488|       |               }
 2489|       |               else {
 2490|       |                  serialize<JSON>::op<disable_write_unknown_on<Options>()>(value, ctx, b, ix);
 2491|       |               }
 2492|       |            }
 2493|       |            else {
 2494|       |               static_assert(false_v<T>, "unknown_write type not handled");
 2495|       |            }
 2496|       |         }
 2497|    262|         else {
 2498|       |            // handles glaze_object_t without extra unknown fields
 2499|    262|            static constexpr auto Opts =
 2500|    262|               disable_write_unknown_off<opening_and_closing_handled_off<ws_handled_off<Options>()>()>();
 2501|       |
 2502|    262|            if constexpr (not check_opening_handled(Options)) {
 2503|       |               if constexpr (Options.prettify) {
 2504|       |                  ctx.depth += check_indentation_width(Options);
 2505|       |                  if constexpr (not check_write_unchecked(Options)) {
 2506|       |                     if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] {
 2507|       |                        return;
 2508|       |                     }
 2509|       |                  }
 2510|       |                  std::memcpy(&b[ix], "{\n", 2);
 2511|       |                  ix += 2;
 2512|       |                  std::memset(&b[ix], check_indentation_char(Opts), ctx.depth);
 2513|       |                  ix += ctx.depth;
 2514|       |               }
 2515|    262|               else {
 2516|    262|                  if constexpr (not check_write_unchecked(Options)) {
 2517|    262|                     if (!ensure_space(ctx, b, ix + 1)) [[unlikely]] {
  ------------------
  |  Branch (2517:26): [True: 0, False: 262]
  ------------------
 2518|      0|                        return;
 2519|      0|                     }
 2520|    262|                  }
 2521|    262|                  dump<not check_write_unchecked(Options)>('{', b, ix);
 2522|    262|               }
 2523|    262|            }
 2524|       |
 2525|      0|            static constexpr auto N = reflect<T>::size;
 2526|       |
 2527|    262|            decltype(auto) t = [&]() -> decltype(auto) {
 2528|    262|               if constexpr (reflectable<T>) {
 2529|    262|                  return to_tie(value);
 2530|    262|               }
 2531|    262|               else {
 2532|    262|                  return nullptr;
 2533|    262|               }
 2534|    262|            }();
 2535|       |
 2536|    262|            static constexpr auto padding = round_up_to_nearest_16(maximum_key_size<T> + write_padding_bytes);
 2537|       |            if constexpr (maybe_skipped<Opts, T>) {
 2538|       |               bool first = true;
 2539|       |               for_each<N>([&]<size_t I>() {
 2540|       |                  using val_t = field_t<T, I>;
 2541|       |
 2542|       |                  // `meta<T>::skip` joins the other compile-time exclusions here rather than returning
 2543|       |                  // early, so that a skipped field's writer is never instantiated -- see
 2544|       |                  // `skipped_by_meta`.
 2545|       |                  constexpr bool write_function_pointers = check_write_function_pointers(Opts);
 2546|       |                  if constexpr (skipped_by_meta<T, I, operation::serialize> || always_skipped<val_t> ||
 2547|       |                                (!write_function_pointers && is_any_function_ptr<val_t>)) {
 2548|       |                     return;
 2549|       |                  }
 2550|       |                  else {
 2551|       |                     if constexpr (meta_has_skip_if<T>) {
 2552|       |                        static constexpr auto skip_if_key = glz::get<I>(reflect<T>::keys);
 2553|       |                        static constexpr meta_context mctx{.op = operation::serialize};
 2554|       |                        decltype(auto) field_value = [&]() -> decltype(auto) {
 2555|       |                           if constexpr (reflectable<T>) {
 2556|       |                              return get<I>(t);
 2557|       |                           }
 2558|       |                           else {
 2559|       |                              return get_member(value, glz::get<I>(reflect<T>::values));
 2560|       |                           }
 2561|       |                        }();
 2562|       |                        if (meta<T>::skip_if(field_value, skip_if_key, mctx)) return;
 2563|       |                     }
 2564|       |
 2565|       |                     if constexpr (null_t<val_t> && Opts.skip_null_members) {
 2566|       |                        if constexpr (always_null_t<val_t>)
 2567|       |                           return;
 2568|       |                        else {
 2569|       |                           const auto is_null = [&]() {
 2570|       |                              decltype(auto) element = [&]() -> decltype(auto) {
 2571|       |                                 if constexpr (reflectable<T>) {
 2572|       |                                    return get<I>(t);
 2573|       |                                 }
 2574|       |                                 else {
 2575|       |                                    return get<I>(reflect<T>::values);
 2576|       |                                 }
 2577|       |                              };
 2578|       |
 2579|       |                              if constexpr (nullable_wrapper<val_t>) {
 2580|       |                                 return !bool(element()(value).val);
 2581|       |                              }
 2582|       |                              else if constexpr (nullable_value_t<val_t>) {
 2583|       |                                 return !get_member(value, element()).has_value();
 2584|       |                              }
 2585|       |                              else {
 2586|       |                                 return !bool(get_member(value, element()));
 2587|       |                              }
 2588|       |                           }();
 2589|       |                           if (is_null) return;
 2590|       |                        }
 2591|       |                     }
 2592|       |                     else if constexpr (is_specialization_v<val_t, custom_t> && Opts.skip_null_members &&
 2593|       |                                        custom_getter_returns_nullable<val_t>()) {
 2594|       |                        if (is_custom_field_null<T, I>(value, t, ctx)) return;
 2595|       |                     }
 2596|       |                     else if constexpr (Opts.skip_null_members && glaze_value_is_nullable<val_t>()) {
 2597|       |                        if (is_glaze_value_field_null<T, I>(value, t)) return;
 2598|       |                     }
 2599|       |
 2600|       |                     if constexpr (check_skip_default_members(Opts) && has_skippable_default<val_t>) {
 2601|       |                        decltype(auto) member = [&]() -> decltype(auto) {
 2602|       |                           if constexpr (reflectable<T>) {
 2603|       |                              return get_member(value, get<I>(t));
 2604|       |                           }
 2605|       |                           else {
 2606|       |                              return get_member(value, get<I>(reflect<T>::values));
 2607|       |                           }
 2608|       |                        }();
 2609|       |                        if (is_default_value(member)) return;
 2610|       |                     }
 2611|       |
 2612|       |                     if constexpr (Opts.prettify) {
 2613|       |                        if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] {
 2614|       |                           return;
 2615|       |                        }
 2616|       |                     }
 2617|       |                     else {
 2618|       |                        if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] {
 2619|       |                           return;
 2620|       |                        }
 2621|       |                     }
 2622|       |
 2623|       |                     if (first) {
 2624|       |                        first = false;
 2625|       |                     }
 2626|       |                     else {
 2627|       |                        // Null members may be skipped so we can't just write it out for all but the last member
 2628|       |                        if constexpr (Opts.prettify) {
 2629|       |                           std::memcpy(&b[ix], ",\n", 2);
 2630|       |                           ix += 2;
 2631|       |                           std::memset(&b[ix], check_indentation_char(Opts), ctx.depth);
 2632|       |                           ix += ctx.depth;
 2633|       |                        }
 2634|       |                        else {
 2635|       |                           std::memcpy(&b[ix], ",", 1);
 2636|       |                           ++ix;
 2637|       |                        }
 2638|       |                        if constexpr (is_output_streaming<B>) {
 2639|       |                           flush_buffer(b, ix);
 2640|       |                        }
 2641|       |                     }
 2642|       |
 2643|       |                     // MSVC requires get<I> rather than keys[I]
 2644|       |                     static constexpr auto key = glz::get<I>(reflect<T>::keys); // GCC 14 requires auto here
 2645|       |                     static constexpr auto quoted_key = quoted_key_v<key, Opts.prettify>;
 2646|       |                     static constexpr auto n = quoted_key.size();
 2647|       |                     std::memcpy(&b[ix], quoted_key.data(), n);
 2648|       |                     ix += n;
 2649|       |
 2650|       |                     static constexpr auto check_opts = required_padding<val_t>() ? write_unchecked_on<Opts>() : Opts;
 2651|       |                     if constexpr (reflectable<T>) {
 2652|       |                        to<JSON, val_t>::template op<check_opts>(get_member(value, get<I>(t)), ctx, b, ix);
 2653|       |                     }
 2654|       |                     else {
 2655|       |                        to<JSON, val_t>::template op<check_opts>(get_member(value, get<I>(reflect<T>::values)), ctx, b,
 2656|       |                                                                 ix);
 2657|       |                     }
 2658|       |                  }
 2659|       |               });
 2660|       |            }
 2661|    262|            else {
 2662|    262|               static constexpr size_t fixed_max_size = Opts.prettify ? 0 : fixed_padding<T>;
  ------------------
  |  Branch (2662:57): [Folded, False: 262]
  ------------------
 2663|    262|               if constexpr (fixed_max_size && not check_write_unchecked(Options)) {
 2664|    262|                  if (!ensure_space(ctx, b, ix + fixed_max_size)) [[unlikely]] {
  ------------------
  |  Branch (2664:23): [True: 0, False: 262]
  ------------------
 2665|      0|                     return;
 2666|      0|                  }
 2667|    262|               }
 2668|       |
 2669|    262|               for_each<N>([&]<size_t I>() {
 2670|    262|                  if constexpr (write_can_error<T>()) {
 2671|    262|                     if (bool(ctx.error)) [[unlikely]] {
 2672|    262|                        return;
 2673|    262|                     }
 2674|    262|                  }
 2675|    262|                  if constexpr (not fixed_max_size) {
 2676|    262|                     if constexpr (Opts.prettify) {
 2677|    262|                        if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] {
 2678|    262|                           return;
 2679|    262|                        }
 2680|    262|                     }
 2681|    262|                     else {
 2682|    262|                        if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] {
 2683|    262|                           return;
 2684|    262|                        }
 2685|    262|                     }
 2686|    262|                  }
 2687|       |
 2688|    262|                  if constexpr (I != 0 && Opts.prettify) {
 2689|    262|                     std::memcpy(&b[ix], ",\n", 2);
 2690|    262|                     ix += 2;
 2691|    262|                     std::memset(&b[ix], check_indentation_char(Opts), ctx.depth);
 2692|    262|                     ix += ctx.depth;
 2693|    262|                  }
 2694|       |
 2695|    262|                  using val_t = field_t<T, I>;
 2696|       |
 2697|       |                  // MSVC requires get<I> rather than keys[I]
 2698|    262|                  static constexpr auto key = glz::get<I>(reflect<T>::keys); // GCC 14 requires auto here
 2699|    262|                  if constexpr (always_null_t<val_t>) {
 2700|    262|                     if constexpr (I == 0 || Opts.prettify) {
 2701|    262|                        static constexpr auto quoted_key = join_v<quoted_key_v<key, Opts.prettify>, chars<"null">>;
 2702|    262|                        static constexpr auto n = quoted_key.size();
 2703|    262|                        std::memcpy(&b[ix], quoted_key.data(), n);
 2704|    262|                        ix += n;
 2705|    262|                     }
 2706|    262|                     else {
 2707|    262|                        static constexpr auto quoted_key = join_v<chars<",">, quoted_key_v<key>, chars<"null">>;
 2708|    262|                        static constexpr auto n = quoted_key.size();
 2709|    262|                        std::memcpy(&b[ix], quoted_key.data(), n);
 2710|    262|                        ix += n;
 2711|    262|                     }
 2712|    262|                  }
 2713|    262|                  else {
 2714|    262|                     if constexpr (I == 0 || Opts.prettify) {
 2715|    262|                        static constexpr auto quoted_key = quoted_key_v<key, Opts.prettify>;
 2716|    262|                        static constexpr auto n = quoted_key.size();
 2717|    262|                        std::memcpy(&b[ix], quoted_key.data(), n);
 2718|    262|                        ix += n;
 2719|    262|                     }
 2720|    262|                     else {
 2721|    262|                        static constexpr auto quoted_key = join_v<chars<",">, quoted_key_v<key>>;
 2722|    262|                        static constexpr auto n = quoted_key.size();
 2723|    262|                        std::memcpy(&b[ix], quoted_key.data(), n);
 2724|    262|                        ix += n;
 2725|    262|                     }
 2726|       |
 2727|    262|                     static constexpr auto check_opts = required_padding<val_t>() ? write_unchecked_on<Opts>() : Opts;
 2728|    262|                     if constexpr (reflectable<T>) {
 2729|    262|                        to<JSON, val_t>::template op<check_opts>(get_member(value, get<I>(t)), ctx, b, ix);
 2730|    262|                     }
 2731|    262|                     else {
 2732|    262|                        to<JSON, val_t>::template op<check_opts>(get_member(value, get<I>(reflect<T>::values)), ctx, b,
 2733|    262|                                                                 ix);
 2734|    262|                     }
 2735|    262|                  }
 2736|    262|               });
 2737|    262|            }
 2738|       |
 2739|       |            // Options is required here, because it must be the top level
 2740|    262|            if constexpr (not check_closing_handled(Options)) {
 2741|       |               if constexpr (Options.prettify) {
 2742|       |                  ctx.depth -= check_indentation_width(Options);
 2743|       |                  if constexpr (not check_write_unchecked(Options)) {
 2744|       |                     if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] {
 2745|       |                        return;
 2746|       |                     }
 2747|       |                  }
 2748|       |                  std::memcpy(&b[ix], "\n", 1);
 2749|       |                  ++ix;
 2750|       |                  std::memset(&b[ix], check_indentation_char(Opts), ctx.depth);
 2751|       |                  ix += ctx.depth;
 2752|       |                  std::memcpy(&b[ix], "}", 1);
 2753|       |                  ++ix;
 2754|       |               }
 2755|    262|               else {
 2756|    262|                  dump<not(fixed_padding<T> || check_write_unchecked(Options))>('}', b, ix);
 2757|    262|               }
 2758|    262|            }
 2759|    262|         }
 2760|    262|      }
_ZZN3glz2toILj10EN12jsonrpc_fuzz5pointEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlvE_clEv:
 2527|    262|            decltype(auto) t = [&]() -> decltype(auto) {
 2528|    262|               if constexpr (reflectable<T>) {
 2529|    262|                  return to_tie(value);
 2530|       |               }
 2531|       |               else {
 2532|       |                  return nullptr;
 2533|       |               }
 2534|    262|            }();
_ZZN3glz2toILj10EN12jsonrpc_fuzz5pointEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlTnmvE_clILm0EEEDav:
 2669|    262|               for_each<N>([&]<size_t I>() {
 2670|       |                  if constexpr (write_can_error<T>()) {
 2671|       |                     if (bool(ctx.error)) [[unlikely]] {
 2672|       |                        return;
 2673|       |                     }
 2674|       |                  }
 2675|       |                  if constexpr (not fixed_max_size) {
 2676|       |                     if constexpr (Opts.prettify) {
 2677|       |                        if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] {
 2678|       |                           return;
 2679|       |                        }
 2680|       |                     }
 2681|       |                     else {
 2682|       |                        if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] {
 2683|       |                           return;
 2684|       |                        }
 2685|       |                     }
 2686|       |                  }
 2687|       |
 2688|       |                  if constexpr (I != 0 && Opts.prettify) {
 2689|       |                     std::memcpy(&b[ix], ",\n", 2);
 2690|       |                     ix += 2;
 2691|       |                     std::memset(&b[ix], check_indentation_char(Opts), ctx.depth);
 2692|       |                     ix += ctx.depth;
 2693|       |                  }
 2694|       |
 2695|    262|                  using val_t = field_t<T, I>;
 2696|       |
 2697|       |                  // MSVC requires get<I> rather than keys[I]
 2698|    262|                  static constexpr auto key = glz::get<I>(reflect<T>::keys); // GCC 14 requires auto here
 2699|       |                  if constexpr (always_null_t<val_t>) {
 2700|       |                     if constexpr (I == 0 || Opts.prettify) {
 2701|       |                        static constexpr auto quoted_key = join_v<quoted_key_v<key, Opts.prettify>, chars<"null">>;
 2702|       |                        static constexpr auto n = quoted_key.size();
 2703|       |                        std::memcpy(&b[ix], quoted_key.data(), n);
 2704|       |                        ix += n;
 2705|       |                     }
 2706|       |                     else {
 2707|       |                        static constexpr auto quoted_key = join_v<chars<",">, quoted_key_v<key>, chars<"null">>;
 2708|       |                        static constexpr auto n = quoted_key.size();
 2709|       |                        std::memcpy(&b[ix], quoted_key.data(), n);
 2710|       |                        ix += n;
 2711|       |                     }
 2712|       |                  }
 2713|    262|                  else {
 2714|    262|                     if constexpr (I == 0 || Opts.prettify) {
 2715|    262|                        static constexpr auto quoted_key = quoted_key_v<key, Opts.prettify>;
 2716|    262|                        static constexpr auto n = quoted_key.size();
 2717|    262|                        std::memcpy(&b[ix], quoted_key.data(), n);
 2718|    262|                        ix += n;
 2719|       |                     }
 2720|       |                     else {
 2721|       |                        static constexpr auto quoted_key = join_v<chars<",">, quoted_key_v<key>>;
 2722|       |                        static constexpr auto n = quoted_key.size();
 2723|       |                        std::memcpy(&b[ix], quoted_key.data(), n);
 2724|       |                        ix += n;
 2725|       |                     }
 2726|       |
 2727|    262|                     static constexpr auto check_opts = required_padding<val_t>() ? write_unchecked_on<Opts>() : Opts;
  ------------------
  |  Branch (2727:57): [True: 0, Folded]
  ------------------
 2728|    262|                     if constexpr (reflectable<T>) {
 2729|    262|                        to<JSON, val_t>::template op<check_opts>(get_member(value, get<I>(t)), ctx, b, ix);
 2730|       |                     }
 2731|       |                     else {
 2732|       |                        to<JSON, val_t>::template op<check_opts>(get_member(value, get<I>(reflect<T>::values)), ctx, b,
 2733|       |                                                                 ix);
 2734|       |                     }
 2735|    262|                  }
 2736|    262|               });
_ZZN3glz2toILj10EN12jsonrpc_fuzz5pointEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlTnmvE_clILm1EEEDav:
 2669|    262|               for_each<N>([&]<size_t I>() {
 2670|       |                  if constexpr (write_can_error<T>()) {
 2671|       |                     if (bool(ctx.error)) [[unlikely]] {
 2672|       |                        return;
 2673|       |                     }
 2674|       |                  }
 2675|       |                  if constexpr (not fixed_max_size) {
 2676|       |                     if constexpr (Opts.prettify) {
 2677|       |                        if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] {
 2678|       |                           return;
 2679|       |                        }
 2680|       |                     }
 2681|       |                     else {
 2682|       |                        if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] {
 2683|       |                           return;
 2684|       |                        }
 2685|       |                     }
 2686|       |                  }
 2687|       |
 2688|       |                  if constexpr (I != 0 && Opts.prettify) {
 2689|       |                     std::memcpy(&b[ix], ",\n", 2);
 2690|       |                     ix += 2;
 2691|       |                     std::memset(&b[ix], check_indentation_char(Opts), ctx.depth);
 2692|       |                     ix += ctx.depth;
 2693|       |                  }
 2694|       |
 2695|    262|                  using val_t = field_t<T, I>;
 2696|       |
 2697|       |                  // MSVC requires get<I> rather than keys[I]
 2698|    262|                  static constexpr auto key = glz::get<I>(reflect<T>::keys); // GCC 14 requires auto here
 2699|       |                  if constexpr (always_null_t<val_t>) {
 2700|       |                     if constexpr (I == 0 || Opts.prettify) {
 2701|       |                        static constexpr auto quoted_key = join_v<quoted_key_v<key, Opts.prettify>, chars<"null">>;
 2702|       |                        static constexpr auto n = quoted_key.size();
 2703|       |                        std::memcpy(&b[ix], quoted_key.data(), n);
 2704|       |                        ix += n;
 2705|       |                     }
 2706|       |                     else {
 2707|       |                        static constexpr auto quoted_key = join_v<chars<",">, quoted_key_v<key>, chars<"null">>;
 2708|       |                        static constexpr auto n = quoted_key.size();
 2709|       |                        std::memcpy(&b[ix], quoted_key.data(), n);
 2710|       |                        ix += n;
 2711|       |                     }
 2712|       |                  }
 2713|    262|                  else {
 2714|       |                     if constexpr (I == 0 || Opts.prettify) {
 2715|       |                        static constexpr auto quoted_key = quoted_key_v<key, Opts.prettify>;
 2716|       |                        static constexpr auto n = quoted_key.size();
 2717|       |                        std::memcpy(&b[ix], quoted_key.data(), n);
 2718|       |                        ix += n;
 2719|       |                     }
 2720|    262|                     else {
 2721|    262|                        static constexpr auto quoted_key = join_v<chars<",">, quoted_key_v<key>>;
 2722|    262|                        static constexpr auto n = quoted_key.size();
 2723|    262|                        std::memcpy(&b[ix], quoted_key.data(), n);
 2724|    262|                        ix += n;
 2725|    262|                     }
 2726|       |
 2727|    262|                     static constexpr auto check_opts = required_padding<val_t>() ? write_unchecked_on<Opts>() : Opts;
  ------------------
  |  Branch (2727:57): [True: 0, Folded]
  ------------------
 2728|    262|                     if constexpr (reflectable<T>) {
 2729|    262|                        to<JSON, val_t>::template op<check_opts>(get_member(value, get<I>(t)), ctx, b, ix);
 2730|       |                     }
 2731|       |                     else {
 2732|       |                        to<JSON, val_t>::template op<check_opts>(get_member(value, get<I>(reflect<T>::values)), ctx, b,
 2733|       |                                                                 ix);
 2734|       |                     }
 2735|    262|                  }
 2736|    262|               });
_ZZN3glz2toILj10EN12jsonrpc_fuzz8fuzz_apiEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlTnmvE_clILm3EEEDav:
 2539|     43|               for_each<N>([&]<size_t I>() {
 2540|     43|                  using val_t = field_t<T, I>;
 2541|       |
 2542|       |                  // `meta<T>::skip` joins the other compile-time exclusions here rather than returning
 2543|       |                  // early, so that a skipped field's writer is never instantiated -- see
 2544|       |                  // `skipped_by_meta`.
 2545|     43|                  constexpr bool write_function_pointers = check_write_function_pointers(Opts);
 2546|       |                  if constexpr (skipped_by_meta<T, I, operation::serialize> || always_skipped<val_t> ||
 2547|       |                                (!write_function_pointers && is_any_function_ptr<val_t>)) {
 2548|       |                     return;
 2549|       |                  }
 2550|     43|                  else {
 2551|       |                     if constexpr (meta_has_skip_if<T>) {
 2552|       |                        static constexpr auto skip_if_key = glz::get<I>(reflect<T>::keys);
 2553|       |                        static constexpr meta_context mctx{.op = operation::serialize};
 2554|       |                        decltype(auto) field_value = [&]() -> decltype(auto) {
 2555|       |                           if constexpr (reflectable<T>) {
 2556|       |                              return get<I>(t);
 2557|       |                           }
 2558|       |                           else {
 2559|       |                              return get_member(value, glz::get<I>(reflect<T>::values));
 2560|       |                           }
 2561|       |                        }();
 2562|       |                        if (meta<T>::skip_if(field_value, skip_if_key, mctx)) return;
 2563|       |                     }
 2564|       |
 2565|       |                     if constexpr (null_t<val_t> && Opts.skip_null_members) {
 2566|       |                        if constexpr (always_null_t<val_t>)
 2567|       |                           return;
 2568|       |                        else {
 2569|       |                           const auto is_null = [&]() {
 2570|       |                              decltype(auto) element = [&]() -> decltype(auto) {
 2571|       |                                 if constexpr (reflectable<T>) {
 2572|       |                                    return get<I>(t);
 2573|       |                                 }
 2574|       |                                 else {
 2575|       |                                    return get<I>(reflect<T>::values);
 2576|       |                                 }
 2577|       |                              };
 2578|       |
 2579|       |                              if constexpr (nullable_wrapper<val_t>) {
 2580|       |                                 return !bool(element()(value).val);
 2581|       |                              }
 2582|       |                              else if constexpr (nullable_value_t<val_t>) {
 2583|       |                                 return !get_member(value, element()).has_value();
 2584|       |                              }
 2585|       |                              else {
 2586|       |                                 return !bool(get_member(value, element()));
 2587|       |                              }
 2588|       |                           }();
 2589|       |                           if (is_null) return;
 2590|       |                        }
 2591|       |                     }
 2592|       |                     else if constexpr (is_specialization_v<val_t, custom_t> && Opts.skip_null_members &&
 2593|       |                                        custom_getter_returns_nullable<val_t>()) {
 2594|       |                        if (is_custom_field_null<T, I>(value, t, ctx)) return;
 2595|       |                     }
 2596|     43|                     else if constexpr (Opts.skip_null_members && glaze_value_is_nullable<val_t>()) {
 2597|     43|                        if (is_glaze_value_field_null<T, I>(value, t)) return;
 2598|     43|                     }
 2599|       |
 2600|       |                     if constexpr (check_skip_default_members(Opts) && has_skippable_default<val_t>) {
 2601|       |                        decltype(auto) member = [&]() -> decltype(auto) {
 2602|       |                           if constexpr (reflectable<T>) {
 2603|       |                              return get_member(value, get<I>(t));
 2604|       |                           }
 2605|       |                           else {
 2606|       |                              return get_member(value, get<I>(reflect<T>::values));
 2607|       |                           }
 2608|       |                        }();
 2609|       |                        if (is_default_value(member)) return;
 2610|       |                     }
 2611|       |
 2612|       |                     if constexpr (Opts.prettify) {
 2613|       |                        if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] {
 2614|       |                           return;
 2615|       |                        }
 2616|       |                     }
 2617|     43|                     else {
 2618|     43|                        if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] {
  ------------------
  |  Branch (2618:29): [True: 0, False: 43]
  ------------------
 2619|      0|                           return;
 2620|      0|                        }
 2621|     43|                     }
 2622|       |
 2623|     43|                     if (first) {
  ------------------
  |  Branch (2623:26): [True: 0, False: 43]
  ------------------
 2624|      0|                        first = false;
 2625|      0|                     }
 2626|     43|                     else {
 2627|       |                        // Null members may be skipped so we can't just write it out for all but the last member
 2628|       |                        if constexpr (Opts.prettify) {
 2629|       |                           std::memcpy(&b[ix], ",\n", 2);
 2630|       |                           ix += 2;
 2631|       |                           std::memset(&b[ix], check_indentation_char(Opts), ctx.depth);
 2632|       |                           ix += ctx.depth;
 2633|       |                        }
 2634|     43|                        else {
 2635|     43|                           std::memcpy(&b[ix], ",", 1);
 2636|     43|                           ++ix;
 2637|     43|                        }
 2638|       |                        if constexpr (is_output_streaming<B>) {
 2639|       |                           flush_buffer(b, ix);
 2640|       |                        }
 2641|     43|                     }
 2642|       |
 2643|       |                     // MSVC requires get<I> rather than keys[I]
 2644|     43|                     static constexpr auto key = glz::get<I>(reflect<T>::keys); // GCC 14 requires auto here
 2645|     43|                     static constexpr auto quoted_key = quoted_key_v<key, Opts.prettify>;
 2646|     43|                     static constexpr auto n = quoted_key.size();
 2647|     43|                     std::memcpy(&b[ix], quoted_key.data(), n);
 2648|     43|                     ix += n;
 2649|       |
 2650|     43|                     static constexpr auto check_opts = required_padding<val_t>() ? write_unchecked_on<Opts>() : Opts;
  ------------------
  |  Branch (2650:57): [Folded, False: 43]
  ------------------
 2651|     43|                     if constexpr (reflectable<T>) {
 2652|     43|                        to<JSON, val_t>::template op<check_opts>(get_member(value, get<I>(t)), ctx, b, ix);
 2653|       |                     }
 2654|       |                     else {
 2655|       |                        to<JSON, val_t>::template op<check_opts>(get_member(value, get<I>(reflect<T>::values)), ctx, b,
 2656|       |                                                                 ix);
 2657|       |                     }
 2658|     43|                  }
 2659|     43|               });
_ZN3glz2toILj10EN12jsonrpc_fuzz6nestedEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_:
 2465|     99|      {
 2466|     99|         using ValueType = std::decay_t<V>;
 2467|       |         if constexpr (has_unknown_writer<ValueType> && not check_disable_write_unknown(Options)) {
 2468|       |            constexpr auto& writer = meta_unknown_write_v<ValueType>;
 2469|       |
 2470|       |            using WriterType = meta_unknown_write_t<ValueType>;
 2471|       |            if constexpr (std::is_member_object_pointer_v<WriterType>) {
 2472|       |               decltype(auto) unknown_writer = value.*writer;
 2473|       |               if (unknown_writer.size() > 0) {
 2474|       |                  // TODO: This intermediate is added to get GCC 14 to build
 2475|       |                  decltype(auto) merged = glz::merge{value, unknown_writer};
 2476|       |                  serialize<JSON>::op<disable_write_unknown_on<Options>()>(std::move(merged), ctx, b, ix);
 2477|       |               }
 2478|       |               else {
 2479|       |                  serialize<JSON>::op<disable_write_unknown_on<Options>()>(value, ctx, b, ix);
 2480|       |               }
 2481|       |            }
 2482|       |            else if constexpr (std::is_member_function_pointer_v<WriterType>) {
 2483|       |               decltype(auto) unknown_writer = (value.*writer)();
 2484|       |               if (unknown_writer.size() > 0) {
 2485|       |                  // TODO: This intermediate is added to get GCC 14 to build
 2486|       |                  decltype(auto) merged = glz::merge{value, unknown_writer};
 2487|       |                  serialize<JSON>::op<disable_write_unknown_on<Options>()>(std::move(merged), ctx, b, ix);
 2488|       |               }
 2489|       |               else {
 2490|       |                  serialize<JSON>::op<disable_write_unknown_on<Options>()>(value, ctx, b, ix);
 2491|       |               }
 2492|       |            }
 2493|       |            else {
 2494|       |               static_assert(false_v<T>, "unknown_write type not handled");
 2495|       |            }
 2496|       |         }
 2497|     99|         else {
 2498|       |            // handles glaze_object_t without extra unknown fields
 2499|     99|            static constexpr auto Opts =
 2500|     99|               disable_write_unknown_off<opening_and_closing_handled_off<ws_handled_off<Options>()>()>();
 2501|       |
 2502|     99|            if constexpr (not check_opening_handled(Options)) {
 2503|       |               if constexpr (Options.prettify) {
 2504|       |                  ctx.depth += check_indentation_width(Options);
 2505|       |                  if constexpr (not check_write_unchecked(Options)) {
 2506|       |                     if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] {
 2507|       |                        return;
 2508|       |                     }
 2509|       |                  }
 2510|       |                  std::memcpy(&b[ix], "{\n", 2);
 2511|       |                  ix += 2;
 2512|       |                  std::memset(&b[ix], check_indentation_char(Opts), ctx.depth);
 2513|       |                  ix += ctx.depth;
 2514|       |               }
 2515|     99|               else {
 2516|     99|                  if constexpr (not check_write_unchecked(Options)) {
 2517|     99|                     if (!ensure_space(ctx, b, ix + 1)) [[unlikely]] {
  ------------------
  |  Branch (2517:26): [True: 0, False: 99]
  ------------------
 2518|      0|                        return;
 2519|      0|                     }
 2520|     99|                  }
 2521|     99|                  dump<not check_write_unchecked(Options)>('{', b, ix);
 2522|     99|               }
 2523|     99|            }
 2524|       |
 2525|      0|            static constexpr auto N = reflect<T>::size;
 2526|       |
 2527|     99|            decltype(auto) t = [&]() -> decltype(auto) {
 2528|     99|               if constexpr (reflectable<T>) {
 2529|     99|                  return to_tie(value);
 2530|     99|               }
 2531|     99|               else {
 2532|     99|                  return nullptr;
 2533|     99|               }
 2534|     99|            }();
 2535|       |
 2536|     99|            static constexpr auto padding = round_up_to_nearest_16(maximum_key_size<T> + write_padding_bytes);
 2537|       |            if constexpr (maybe_skipped<Opts, T>) {
 2538|       |               bool first = true;
 2539|       |               for_each<N>([&]<size_t I>() {
 2540|       |                  using val_t = field_t<T, I>;
 2541|       |
 2542|       |                  // `meta<T>::skip` joins the other compile-time exclusions here rather than returning
 2543|       |                  // early, so that a skipped field's writer is never instantiated -- see
 2544|       |                  // `skipped_by_meta`.
 2545|       |                  constexpr bool write_function_pointers = check_write_function_pointers(Opts);
 2546|       |                  if constexpr (skipped_by_meta<T, I, operation::serialize> || always_skipped<val_t> ||
 2547|       |                                (!write_function_pointers && is_any_function_ptr<val_t>)) {
 2548|       |                     return;
 2549|       |                  }
 2550|       |                  else {
 2551|       |                     if constexpr (meta_has_skip_if<T>) {
 2552|       |                        static constexpr auto skip_if_key = glz::get<I>(reflect<T>::keys);
 2553|       |                        static constexpr meta_context mctx{.op = operation::serialize};
 2554|       |                        decltype(auto) field_value = [&]() -> decltype(auto) {
 2555|       |                           if constexpr (reflectable<T>) {
 2556|       |                              return get<I>(t);
 2557|       |                           }
 2558|       |                           else {
 2559|       |                              return get_member(value, glz::get<I>(reflect<T>::values));
 2560|       |                           }
 2561|       |                        }();
 2562|       |                        if (meta<T>::skip_if(field_value, skip_if_key, mctx)) return;
 2563|       |                     }
 2564|       |
 2565|       |                     if constexpr (null_t<val_t> && Opts.skip_null_members) {
 2566|       |                        if constexpr (always_null_t<val_t>)
 2567|       |                           return;
 2568|       |                        else {
 2569|       |                           const auto is_null = [&]() {
 2570|       |                              decltype(auto) element = [&]() -> decltype(auto) {
 2571|       |                                 if constexpr (reflectable<T>) {
 2572|       |                                    return get<I>(t);
 2573|       |                                 }
 2574|       |                                 else {
 2575|       |                                    return get<I>(reflect<T>::values);
 2576|       |                                 }
 2577|       |                              };
 2578|       |
 2579|       |                              if constexpr (nullable_wrapper<val_t>) {
 2580|       |                                 return !bool(element()(value).val);
 2581|       |                              }
 2582|       |                              else if constexpr (nullable_value_t<val_t>) {
 2583|       |                                 return !get_member(value, element()).has_value();
 2584|       |                              }
 2585|       |                              else {
 2586|       |                                 return !bool(get_member(value, element()));
 2587|       |                              }
 2588|       |                           }();
 2589|       |                           if (is_null) return;
 2590|       |                        }
 2591|       |                     }
 2592|       |                     else if constexpr (is_specialization_v<val_t, custom_t> && Opts.skip_null_members &&
 2593|       |                                        custom_getter_returns_nullable<val_t>()) {
 2594|       |                        if (is_custom_field_null<T, I>(value, t, ctx)) return;
 2595|       |                     }
 2596|       |                     else if constexpr (Opts.skip_null_members && glaze_value_is_nullable<val_t>()) {
 2597|       |                        if (is_glaze_value_field_null<T, I>(value, t)) return;
 2598|       |                     }
 2599|       |
 2600|       |                     if constexpr (check_skip_default_members(Opts) && has_skippable_default<val_t>) {
 2601|       |                        decltype(auto) member = [&]() -> decltype(auto) {
 2602|       |                           if constexpr (reflectable<T>) {
 2603|       |                              return get_member(value, get<I>(t));
 2604|       |                           }
 2605|       |                           else {
 2606|       |                              return get_member(value, get<I>(reflect<T>::values));
 2607|       |                           }
 2608|       |                        }();
 2609|       |                        if (is_default_value(member)) return;
 2610|       |                     }
 2611|       |
 2612|       |                     if constexpr (Opts.prettify) {
 2613|       |                        if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] {
 2614|       |                           return;
 2615|       |                        }
 2616|       |                     }
 2617|       |                     else {
 2618|       |                        if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] {
 2619|       |                           return;
 2620|       |                        }
 2621|       |                     }
 2622|       |
 2623|       |                     if (first) {
 2624|       |                        first = false;
 2625|       |                     }
 2626|       |                     else {
 2627|       |                        // Null members may be skipped so we can't just write it out for all but the last member
 2628|       |                        if constexpr (Opts.prettify) {
 2629|       |                           std::memcpy(&b[ix], ",\n", 2);
 2630|       |                           ix += 2;
 2631|       |                           std::memset(&b[ix], check_indentation_char(Opts), ctx.depth);
 2632|       |                           ix += ctx.depth;
 2633|       |                        }
 2634|       |                        else {
 2635|       |                           std::memcpy(&b[ix], ",", 1);
 2636|       |                           ++ix;
 2637|       |                        }
 2638|       |                        if constexpr (is_output_streaming<B>) {
 2639|       |                           flush_buffer(b, ix);
 2640|       |                        }
 2641|       |                     }
 2642|       |
 2643|       |                     // MSVC requires get<I> rather than keys[I]
 2644|       |                     static constexpr auto key = glz::get<I>(reflect<T>::keys); // GCC 14 requires auto here
 2645|       |                     static constexpr auto quoted_key = quoted_key_v<key, Opts.prettify>;
 2646|       |                     static constexpr auto n = quoted_key.size();
 2647|       |                     std::memcpy(&b[ix], quoted_key.data(), n);
 2648|       |                     ix += n;
 2649|       |
 2650|       |                     static constexpr auto check_opts = required_padding<val_t>() ? write_unchecked_on<Opts>() : Opts;
 2651|       |                     if constexpr (reflectable<T>) {
 2652|       |                        to<JSON, val_t>::template op<check_opts>(get_member(value, get<I>(t)), ctx, b, ix);
 2653|       |                     }
 2654|       |                     else {
 2655|       |                        to<JSON, val_t>::template op<check_opts>(get_member(value, get<I>(reflect<T>::values)), ctx, b,
 2656|       |                                                                 ix);
 2657|       |                     }
 2658|       |                  }
 2659|       |               });
 2660|       |            }
 2661|     99|            else {
 2662|     99|               static constexpr size_t fixed_max_size = Opts.prettify ? 0 : fixed_padding<T>;
  ------------------
  |  Branch (2662:57): [Folded, False: 99]
  ------------------
 2663|       |               if constexpr (fixed_max_size && not check_write_unchecked(Options)) {
 2664|       |                  if (!ensure_space(ctx, b, ix + fixed_max_size)) [[unlikely]] {
 2665|       |                     return;
 2666|       |                  }
 2667|       |               }
 2668|       |
 2669|     99|               for_each<N>([&]<size_t I>() {
 2670|     99|                  if constexpr (write_can_error<T>()) {
 2671|     99|                     if (bool(ctx.error)) [[unlikely]] {
 2672|     99|                        return;
 2673|     99|                     }
 2674|     99|                  }
 2675|     99|                  if constexpr (not fixed_max_size) {
 2676|     99|                     if constexpr (Opts.prettify) {
 2677|     99|                        if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] {
 2678|     99|                           return;
 2679|     99|                        }
 2680|     99|                     }
 2681|     99|                     else {
 2682|     99|                        if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] {
 2683|     99|                           return;
 2684|     99|                        }
 2685|     99|                     }
 2686|     99|                  }
 2687|       |
 2688|     99|                  if constexpr (I != 0 && Opts.prettify) {
 2689|     99|                     std::memcpy(&b[ix], ",\n", 2);
 2690|     99|                     ix += 2;
 2691|     99|                     std::memset(&b[ix], check_indentation_char(Opts), ctx.depth);
 2692|     99|                     ix += ctx.depth;
 2693|     99|                  }
 2694|       |
 2695|     99|                  using val_t = field_t<T, I>;
 2696|       |
 2697|       |                  // MSVC requires get<I> rather than keys[I]
 2698|     99|                  static constexpr auto key = glz::get<I>(reflect<T>::keys); // GCC 14 requires auto here
 2699|     99|                  if constexpr (always_null_t<val_t>) {
 2700|     99|                     if constexpr (I == 0 || Opts.prettify) {
 2701|     99|                        static constexpr auto quoted_key = join_v<quoted_key_v<key, Opts.prettify>, chars<"null">>;
 2702|     99|                        static constexpr auto n = quoted_key.size();
 2703|     99|                        std::memcpy(&b[ix], quoted_key.data(), n);
 2704|     99|                        ix += n;
 2705|     99|                     }
 2706|     99|                     else {
 2707|     99|                        static constexpr auto quoted_key = join_v<chars<",">, quoted_key_v<key>, chars<"null">>;
 2708|     99|                        static constexpr auto n = quoted_key.size();
 2709|     99|                        std::memcpy(&b[ix], quoted_key.data(), n);
 2710|     99|                        ix += n;
 2711|     99|                     }
 2712|     99|                  }
 2713|     99|                  else {
 2714|     99|                     if constexpr (I == 0 || Opts.prettify) {
 2715|     99|                        static constexpr auto quoted_key = quoted_key_v<key, Opts.prettify>;
 2716|     99|                        static constexpr auto n = quoted_key.size();
 2717|     99|                        std::memcpy(&b[ix], quoted_key.data(), n);
 2718|     99|                        ix += n;
 2719|     99|                     }
 2720|     99|                     else {
 2721|     99|                        static constexpr auto quoted_key = join_v<chars<",">, quoted_key_v<key>>;
 2722|     99|                        static constexpr auto n = quoted_key.size();
 2723|     99|                        std::memcpy(&b[ix], quoted_key.data(), n);
 2724|     99|                        ix += n;
 2725|     99|                     }
 2726|       |
 2727|     99|                     static constexpr auto check_opts = required_padding<val_t>() ? write_unchecked_on<Opts>() : Opts;
 2728|     99|                     if constexpr (reflectable<T>) {
 2729|     99|                        to<JSON, val_t>::template op<check_opts>(get_member(value, get<I>(t)), ctx, b, ix);
 2730|     99|                     }
 2731|     99|                     else {
 2732|     99|                        to<JSON, val_t>::template op<check_opts>(get_member(value, get<I>(reflect<T>::values)), ctx, b,
 2733|     99|                                                                 ix);
 2734|     99|                     }
 2735|     99|                  }
 2736|     99|               });
 2737|     99|            }
 2738|       |
 2739|       |            // Options is required here, because it must be the top level
 2740|     99|            if constexpr (not check_closing_handled(Options)) {
 2741|       |               if constexpr (Options.prettify) {
 2742|       |                  ctx.depth -= check_indentation_width(Options);
 2743|       |                  if constexpr (not check_write_unchecked(Options)) {
 2744|       |                     if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] {
 2745|       |                        return;
 2746|       |                     }
 2747|       |                  }
 2748|       |                  std::memcpy(&b[ix], "\n", 1);
 2749|       |                  ++ix;
 2750|       |                  std::memset(&b[ix], check_indentation_char(Opts), ctx.depth);
 2751|       |                  ix += ctx.depth;
 2752|       |                  std::memcpy(&b[ix], "}", 1);
 2753|       |                  ++ix;
 2754|       |               }
 2755|     99|               else {
 2756|     99|                  dump<not(fixed_padding<T> || check_write_unchecked(Options))>('}', b, ix);
 2757|     99|               }
 2758|     99|            }
 2759|     99|         }
 2760|     99|      }
_ZZN3glz2toILj10EN12jsonrpc_fuzz6nestedEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlvE_clEv:
 2527|     99|            decltype(auto) t = [&]() -> decltype(auto) {
 2528|     99|               if constexpr (reflectable<T>) {
 2529|     99|                  return to_tie(value);
 2530|       |               }
 2531|       |               else {
 2532|       |                  return nullptr;
 2533|       |               }
 2534|     99|            }();
_ZZN3glz2toILj10EN12jsonrpc_fuzz6nestedEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlTnmvE_clILm0EEEDav:
 2669|     99|               for_each<N>([&]<size_t I>() {
 2670|       |                  if constexpr (write_can_error<T>()) {
 2671|       |                     if (bool(ctx.error)) [[unlikely]] {
 2672|       |                        return;
 2673|       |                     }
 2674|       |                  }
 2675|     99|                  if constexpr (not fixed_max_size) {
 2676|       |                     if constexpr (Opts.prettify) {
 2677|       |                        if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] {
 2678|       |                           return;
 2679|       |                        }
 2680|       |                     }
 2681|     99|                     else {
 2682|     99|                        if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] {
  ------------------
  |  Branch (2682:29): [True: 0, False: 99]
  ------------------
 2683|      0|                           return;
 2684|      0|                        }
 2685|     99|                     }
 2686|     99|                  }
 2687|       |
 2688|       |                  if constexpr (I != 0 && Opts.prettify) {
 2689|       |                     std::memcpy(&b[ix], ",\n", 2);
 2690|       |                     ix += 2;
 2691|       |                     std::memset(&b[ix], check_indentation_char(Opts), ctx.depth);
 2692|       |                     ix += ctx.depth;
 2693|       |                  }
 2694|       |
 2695|     99|                  using val_t = field_t<T, I>;
 2696|       |
 2697|       |                  // MSVC requires get<I> rather than keys[I]
 2698|     99|                  static constexpr auto key = glz::get<I>(reflect<T>::keys); // GCC 14 requires auto here
 2699|       |                  if constexpr (always_null_t<val_t>) {
 2700|       |                     if constexpr (I == 0 || Opts.prettify) {
 2701|       |                        static constexpr auto quoted_key = join_v<quoted_key_v<key, Opts.prettify>, chars<"null">>;
 2702|       |                        static constexpr auto n = quoted_key.size();
 2703|       |                        std::memcpy(&b[ix], quoted_key.data(), n);
 2704|       |                        ix += n;
 2705|       |                     }
 2706|       |                     else {
 2707|       |                        static constexpr auto quoted_key = join_v<chars<",">, quoted_key_v<key>, chars<"null">>;
 2708|       |                        static constexpr auto n = quoted_key.size();
 2709|       |                        std::memcpy(&b[ix], quoted_key.data(), n);
 2710|       |                        ix += n;
 2711|       |                     }
 2712|       |                  }
 2713|     99|                  else {
 2714|     99|                     if constexpr (I == 0 || Opts.prettify) {
 2715|     99|                        static constexpr auto quoted_key = quoted_key_v<key, Opts.prettify>;
 2716|     99|                        static constexpr auto n = quoted_key.size();
 2717|     99|                        std::memcpy(&b[ix], quoted_key.data(), n);
 2718|     99|                        ix += n;
 2719|       |                     }
 2720|       |                     else {
 2721|       |                        static constexpr auto quoted_key = join_v<chars<",">, quoted_key_v<key>>;
 2722|       |                        static constexpr auto n = quoted_key.size();
 2723|       |                        std::memcpy(&b[ix], quoted_key.data(), n);
 2724|       |                        ix += n;
 2725|       |                     }
 2726|       |
 2727|     99|                     static constexpr auto check_opts = required_padding<val_t>() ? write_unchecked_on<Opts>() : Opts;
  ------------------
  |  Branch (2727:57): [True: 0, Folded]
  ------------------
 2728|     99|                     if constexpr (reflectable<T>) {
 2729|     99|                        to<JSON, val_t>::template op<check_opts>(get_member(value, get<I>(t)), ctx, b, ix);
 2730|       |                     }
 2731|       |                     else {
 2732|       |                        to<JSON, val_t>::template op<check_opts>(get_member(value, get<I>(reflect<T>::values)), ctx, b,
 2733|       |                                                                 ix);
 2734|       |                     }
 2735|     99|                  }
 2736|     99|               });
_ZZN3glz2toILj10EN12jsonrpc_fuzz6nestedEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlTnmvE_clILm1EEEDav:
 2669|     99|               for_each<N>([&]<size_t I>() {
 2670|       |                  if constexpr (write_can_error<T>()) {
 2671|       |                     if (bool(ctx.error)) [[unlikely]] {
 2672|       |                        return;
 2673|       |                     }
 2674|       |                  }
 2675|     99|                  if constexpr (not fixed_max_size) {
 2676|       |                     if constexpr (Opts.prettify) {
 2677|       |                        if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] {
 2678|       |                           return;
 2679|       |                        }
 2680|       |                     }
 2681|     99|                     else {
 2682|     99|                        if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] {
  ------------------
  |  Branch (2682:29): [True: 0, False: 99]
  ------------------
 2683|      0|                           return;
 2684|      0|                        }
 2685|     99|                     }
 2686|     99|                  }
 2687|       |
 2688|       |                  if constexpr (I != 0 && Opts.prettify) {
 2689|       |                     std::memcpy(&b[ix], ",\n", 2);
 2690|       |                     ix += 2;
 2691|       |                     std::memset(&b[ix], check_indentation_char(Opts), ctx.depth);
 2692|       |                     ix += ctx.depth;
 2693|       |                  }
 2694|       |
 2695|     99|                  using val_t = field_t<T, I>;
 2696|       |
 2697|       |                  // MSVC requires get<I> rather than keys[I]
 2698|     99|                  static constexpr auto key = glz::get<I>(reflect<T>::keys); // GCC 14 requires auto here
 2699|       |                  if constexpr (always_null_t<val_t>) {
 2700|       |                     if constexpr (I == 0 || Opts.prettify) {
 2701|       |                        static constexpr auto quoted_key = join_v<quoted_key_v<key, Opts.prettify>, chars<"null">>;
 2702|       |                        static constexpr auto n = quoted_key.size();
 2703|       |                        std::memcpy(&b[ix], quoted_key.data(), n);
 2704|       |                        ix += n;
 2705|       |                     }
 2706|       |                     else {
 2707|       |                        static constexpr auto quoted_key = join_v<chars<",">, quoted_key_v<key>, chars<"null">>;
 2708|       |                        static constexpr auto n = quoted_key.size();
 2709|       |                        std::memcpy(&b[ix], quoted_key.data(), n);
 2710|       |                        ix += n;
 2711|       |                     }
 2712|       |                  }
 2713|     99|                  else {
 2714|       |                     if constexpr (I == 0 || Opts.prettify) {
 2715|       |                        static constexpr auto quoted_key = quoted_key_v<key, Opts.prettify>;
 2716|       |                        static constexpr auto n = quoted_key.size();
 2717|       |                        std::memcpy(&b[ix], quoted_key.data(), n);
 2718|       |                        ix += n;
 2719|       |                     }
 2720|     99|                     else {
 2721|     99|                        static constexpr auto quoted_key = join_v<chars<",">, quoted_key_v<key>>;
 2722|     99|                        static constexpr auto n = quoted_key.size();
 2723|     99|                        std::memcpy(&b[ix], quoted_key.data(), n);
 2724|     99|                        ix += n;
 2725|     99|                     }
 2726|       |
 2727|     99|                     static constexpr auto check_opts = required_padding<val_t>() ? write_unchecked_on<Opts>() : Opts;
  ------------------
  |  Branch (2727:57): [Folded, False: 99]
  ------------------
 2728|     99|                     if constexpr (reflectable<T>) {
 2729|     99|                        to<JSON, val_t>::template op<check_opts>(get_member(value, get<I>(t)), ctx, b, ix);
 2730|       |                     }
 2731|       |                     else {
 2732|       |                        to<JSON, val_t>::template op<check_opts>(get_member(value, get<I>(reflect<T>::values)), ctx, b,
 2733|       |                                                                 ix);
 2734|       |                     }
 2735|     99|                  }
 2736|     99|               });
_ZZN3glz2toILj10EN12jsonrpc_fuzz8fuzz_apiEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlTnmvE_clILm4EEEDav:
 2539|     43|               for_each<N>([&]<size_t I>() {
 2540|     43|                  using val_t = field_t<T, I>;
 2541|       |
 2542|       |                  // `meta<T>::skip` joins the other compile-time exclusions here rather than returning
 2543|       |                  // early, so that a skipped field's writer is never instantiated -- see
 2544|       |                  // `skipped_by_meta`.
 2545|     43|                  constexpr bool write_function_pointers = check_write_function_pointers(Opts);
 2546|       |                  if constexpr (skipped_by_meta<T, I, operation::serialize> || always_skipped<val_t> ||
 2547|       |                                (!write_function_pointers && is_any_function_ptr<val_t>)) {
 2548|       |                     return;
 2549|       |                  }
 2550|     43|                  else {
 2551|       |                     if constexpr (meta_has_skip_if<T>) {
 2552|       |                        static constexpr auto skip_if_key = glz::get<I>(reflect<T>::keys);
 2553|       |                        static constexpr meta_context mctx{.op = operation::serialize};
 2554|       |                        decltype(auto) field_value = [&]() -> decltype(auto) {
 2555|       |                           if constexpr (reflectable<T>) {
 2556|       |                              return get<I>(t);
 2557|       |                           }
 2558|       |                           else {
 2559|       |                              return get_member(value, glz::get<I>(reflect<T>::values));
 2560|       |                           }
 2561|       |                        }();
 2562|       |                        if (meta<T>::skip_if(field_value, skip_if_key, mctx)) return;
 2563|       |                     }
 2564|       |
 2565|       |                     if constexpr (null_t<val_t> && Opts.skip_null_members) {
 2566|       |                        if constexpr (always_null_t<val_t>)
 2567|       |                           return;
 2568|       |                        else {
 2569|       |                           const auto is_null = [&]() {
 2570|       |                              decltype(auto) element = [&]() -> decltype(auto) {
 2571|       |                                 if constexpr (reflectable<T>) {
 2572|       |                                    return get<I>(t);
 2573|       |                                 }
 2574|       |                                 else {
 2575|       |                                    return get<I>(reflect<T>::values);
 2576|       |                                 }
 2577|       |                              };
 2578|       |
 2579|       |                              if constexpr (nullable_wrapper<val_t>) {
 2580|       |                                 return !bool(element()(value).val);
 2581|       |                              }
 2582|       |                              else if constexpr (nullable_value_t<val_t>) {
 2583|       |                                 return !get_member(value, element()).has_value();
 2584|       |                              }
 2585|       |                              else {
 2586|       |                                 return !bool(get_member(value, element()));
 2587|       |                              }
 2588|       |                           }();
 2589|       |                           if (is_null) return;
 2590|       |                        }
 2591|       |                     }
 2592|       |                     else if constexpr (is_specialization_v<val_t, custom_t> && Opts.skip_null_members &&
 2593|       |                                        custom_getter_returns_nullable<val_t>()) {
 2594|       |                        if (is_custom_field_null<T, I>(value, t, ctx)) return;
 2595|       |                     }
 2596|     43|                     else if constexpr (Opts.skip_null_members && glaze_value_is_nullable<val_t>()) {
 2597|     43|                        if (is_glaze_value_field_null<T, I>(value, t)) return;
 2598|     43|                     }
 2599|       |
 2600|       |                     if constexpr (check_skip_default_members(Opts) && has_skippable_default<val_t>) {
 2601|       |                        decltype(auto) member = [&]() -> decltype(auto) {
 2602|       |                           if constexpr (reflectable<T>) {
 2603|       |                              return get_member(value, get<I>(t));
 2604|       |                           }
 2605|       |                           else {
 2606|       |                              return get_member(value, get<I>(reflect<T>::values));
 2607|       |                           }
 2608|       |                        }();
 2609|       |                        if (is_default_value(member)) return;
 2610|       |                     }
 2611|       |
 2612|       |                     if constexpr (Opts.prettify) {
 2613|       |                        if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] {
 2614|       |                           return;
 2615|       |                        }
 2616|       |                     }
 2617|     43|                     else {
 2618|     43|                        if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] {
  ------------------
  |  Branch (2618:29): [True: 0, False: 43]
  ------------------
 2619|      0|                           return;
 2620|      0|                        }
 2621|     43|                     }
 2622|       |
 2623|     43|                     if (first) {
  ------------------
  |  Branch (2623:26): [True: 0, False: 43]
  ------------------
 2624|      0|                        first = false;
 2625|      0|                     }
 2626|     43|                     else {
 2627|       |                        // Null members may be skipped so we can't just write it out for all but the last member
 2628|       |                        if constexpr (Opts.prettify) {
 2629|       |                           std::memcpy(&b[ix], ",\n", 2);
 2630|       |                           ix += 2;
 2631|       |                           std::memset(&b[ix], check_indentation_char(Opts), ctx.depth);
 2632|       |                           ix += ctx.depth;
 2633|       |                        }
 2634|     43|                        else {
 2635|     43|                           std::memcpy(&b[ix], ",", 1);
 2636|     43|                           ++ix;
 2637|     43|                        }
 2638|       |                        if constexpr (is_output_streaming<B>) {
 2639|       |                           flush_buffer(b, ix);
 2640|       |                        }
 2641|     43|                     }
 2642|       |
 2643|       |                     // MSVC requires get<I> rather than keys[I]
 2644|     43|                     static constexpr auto key = glz::get<I>(reflect<T>::keys); // GCC 14 requires auto here
 2645|     43|                     static constexpr auto quoted_key = quoted_key_v<key, Opts.prettify>;
 2646|     43|                     static constexpr auto n = quoted_key.size();
 2647|     43|                     std::memcpy(&b[ix], quoted_key.data(), n);
 2648|     43|                     ix += n;
 2649|       |
 2650|     43|                     static constexpr auto check_opts = required_padding<val_t>() ? write_unchecked_on<Opts>() : Opts;
  ------------------
  |  Branch (2650:57): [Folded, False: 43]
  ------------------
 2651|     43|                     if constexpr (reflectable<T>) {
 2652|     43|                        to<JSON, val_t>::template op<check_opts>(get_member(value, get<I>(t)), ctx, b, ix);
 2653|       |                     }
 2654|       |                     else {
 2655|       |                        to<JSON, val_t>::template op<check_opts>(get_member(value, get<I>(reflect<T>::values)), ctx, b,
 2656|       |                                                                 ix);
 2657|       |                     }
 2658|     43|                  }
 2659|     43|               });
_ZN3glz2toILj10ENSt3__16vectorIiNS1_9allocatorIiEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNS1_12basic_stringIcNS1_11char_traitsIcEENS3_IcEEEERS5_TkNS_10is_contextERNS_7contextEmQaa16writable_array_tIT_EquL_ZNS0_ILj10ESI_E14map_like_arrayEEeqcl17check_concatenateTL0__ELb0ELb1EEEvOT1_OT2_OT0_RT3_:
 1426|    190|      {
 1427|    190|         if (empty_range(value)) {
  ------------------
  |  Branch (1427:14): [True: 190, False: 0]
  ------------------
 1428|    190|            dump("[]", b, ix);
 1429|    190|         }
 1430|      0|         else {
 1431|       |            // For bounded buffers, skip pre-allocation path since value_padding is for SIMD, not actual size
 1432|      0|            if constexpr (has_size<T> && array_padding_known<T> && !has_bounded_capacity<B>) {
 1433|      0|               const auto n = value.size();
 1434|       |
 1435|      0|               static constexpr auto value_padding = []() -> size_t {
 1436|      0|                  if constexpr (required_padding<typename T::value_type>() > 0)
 1437|      0|                     return required_padding<typename T::value_type>();
 1438|      0|                  else
 1439|      0|                     return fixed_padding<typename T::value_type>;
 1440|      0|               }();
 1441|       |
 1442|       |               if constexpr (Opts.prettify) {
 1443|       |                  if constexpr (check_new_lines_in_arrays(Opts)) {
 1444|       |                     ctx.depth += check_indentation_width(Opts);
 1445|       |                  }
 1446|       |
 1447|       |                  // add space for '\n' and ',' characters for each element, hence `+ 2`
 1448|       |                  // use n + 1 because we put the end array character after the last element with whitespace
 1449|       |                  if (!ensure_space(ctx, b, ix + (n + 1) * (value_padding + ctx.depth + 2) + write_padding_bytes))
 1450|       |                     [[unlikely]] {
 1451|       |                     return;
 1452|       |                  }
 1453|       |
 1454|       |                  if constexpr (check_new_lines_in_arrays(Opts)) {
 1455|       |                     std::memcpy(&b[ix], "[\n", 2);
 1456|       |                     ix += 2;
 1457|       |                     std::memset(&b[ix], check_indentation_char(Opts), ctx.depth);
 1458|       |                     ix += ctx.depth;
 1459|       |                  }
 1460|       |                  else {
 1461|       |                     std::memcpy(&b[ix], "[", 1);
 1462|       |                     ++ix;
 1463|       |                  }
 1464|       |               }
 1465|      0|               else {
 1466|      0|                  static constexpr auto comma_padding = 1;
 1467|      0|                  if (!ensure_space(ctx, b, ix + n * (value_padding + comma_padding) + write_padding_bytes))
  ------------------
  |  Branch (1467:23): [True: 0, False: 0]
  ------------------
 1468|      0|                     [[unlikely]] {
 1469|      0|                     return;
 1470|      0|                  }
 1471|      0|                  std::memcpy(&b[ix], "[", 1);
 1472|      0|                  ++ix;
 1473|      0|               }
 1474|       |
 1475|      0|               auto it = std::begin(value);
 1476|      0|               using val_t = std::remove_cvref_t<decltype(*it)>;
 1477|      0|               to<JSON, val_t>::template op<write_unchecked_on<Opts>()>(*it, ctx, b, ix);
 1478|       |
 1479|      0|               ++it;
 1480|      0|               for (const auto fin = std::end(value); it != fin; ++it) {
  ------------------
  |  Branch (1480:55): [True: 0, False: 0]
  ------------------
 1481|       |                  if constexpr (Opts.prettify) {
 1482|       |                     if constexpr (check_new_lines_in_arrays(Opts)) {
 1483|       |                        std::memcpy(&b[ix], ",\n", 2);
 1484|       |                        ix += 2;
 1485|       |                        std::memset(&b[ix], check_indentation_char(Opts), ctx.depth);
 1486|       |                        ix += ctx.depth;
 1487|       |                     }
 1488|       |                     else {
 1489|       |                        std::memcpy(&b[ix], ", ", 2);
 1490|       |                        ix += 2;
 1491|       |                     }
 1492|       |                  }
 1493|      0|                  else {
 1494|      0|                     std::memcpy(&b[ix], ",", 1);
 1495|      0|                     ++ix;
 1496|      0|                  }
 1497|       |                  if constexpr (is_output_streaming<B>) {
 1498|       |                     flush_buffer(b, ix);
 1499|       |                  }
 1500|       |
 1501|      0|                  to<JSON, val_t>::template op<write_unchecked_on<Opts>()>(*it, ctx, b, ix);
 1502|      0|               }
 1503|       |               if constexpr (Opts.prettify && check_new_lines_in_arrays(Opts)) {
 1504|       |                  ctx.depth -= check_indentation_width(Opts);
 1505|       |                  std::memcpy(&b[ix], "\n", 1);
 1506|       |                  ++ix;
 1507|       |                  std::memset(&b[ix], check_indentation_char(Opts), ctx.depth);
 1508|       |                  ix += ctx.depth;
 1509|       |               }
 1510|       |
 1511|      0|               std::memcpy(&b[ix], "]", 1);
 1512|      0|               ++ix;
 1513|       |            }
 1514|       |            else {
 1515|       |               // we either can't get the size (std::forward_list) or we cannot compute the allocation size
 1516|       |
 1517|       |               if constexpr (Opts.prettify) {
 1518|       |                  if constexpr (check_new_lines_in_arrays(Opts)) {
 1519|       |                     ctx.depth += check_indentation_width(Opts);
 1520|       |                  }
 1521|       |
 1522|       |                  if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] {
 1523|       |                     return;
 1524|       |                  }
 1525|       |
 1526|       |                  if constexpr (check_new_lines_in_arrays(Opts)) {
 1527|       |                     std::memcpy(&b[ix], "[\n", 2);
 1528|       |                     ix += 2;
 1529|       |                     std::memset(&b[ix], check_indentation_char(Opts), ctx.depth);
 1530|       |                     ix += ctx.depth;
 1531|       |                  }
 1532|       |                  else {
 1533|       |                     std::memcpy(&b[ix], "[", 1);
 1534|       |                     ++ix;
 1535|       |                  }
 1536|       |               }
 1537|       |               else {
 1538|       |                  if (!ensure_space(ctx, b, ix + write_padding_bytes)) [[unlikely]] {
 1539|       |                     return;
 1540|       |                  }
 1541|       |                  std::memcpy(&b[ix], "[", 1);
 1542|       |                  ++ix;
 1543|       |               }
 1544|       |
 1545|       |               auto it = std::begin(value);
 1546|       |               using val_t = std::remove_cvref_t<decltype(*it)>;
 1547|       |               if constexpr (required_padding<val_t>()) {
 1548|       |                  to<JSON, val_t>::template op<write_unchecked_on<Opts>()>(*it, ctx, b, ix);
 1549|       |               }
 1550|       |               else {
 1551|       |                  to<JSON, val_t>::template op<Opts>(*it, ctx, b, ix);
 1552|       |                  if (bool(ctx.error)) [[unlikely]] {
 1553|       |                     return;
 1554|       |                  }
 1555|       |               }
 1556|       |
 1557|       |               ++it;
 1558|       |               for (const auto fin = std::end(value); it != fin; ++it) {
 1559|       |                  if constexpr (required_padding<val_t>()) {
 1560|       |                     if constexpr (Opts.prettify) {
 1561|       |                        if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] {
 1562|       |                           return;
 1563|       |                        }
 1564|       |                     }
 1565|       |                     else {
 1566|       |                        if (!ensure_space(ctx, b, ix + write_padding_bytes)) [[unlikely]] {
 1567|       |                           return;
 1568|       |                        }
 1569|       |                     }
 1570|       |
 1571|       |                     if constexpr (Opts.prettify) {
 1572|       |                        if constexpr (check_new_lines_in_arrays(Opts)) {
 1573|       |                           std::memcpy(&b[ix], ",\n", 2);
 1574|       |                           ix += 2;
 1575|       |                           std::memset(&b[ix], check_indentation_char(Opts), ctx.depth);
 1576|       |                           ix += ctx.depth;
 1577|       |                        }
 1578|       |                        else {
 1579|       |                           std::memcpy(&b[ix], ", ", 2);
 1580|       |                           ix += 2;
 1581|       |                        }
 1582|       |                     }
 1583|       |                     else {
 1584|       |                        std::memcpy(&b[ix], ",", 1);
 1585|       |                        ++ix;
 1586|       |                     }
 1587|       |                     if constexpr (is_output_streaming<B>) {
 1588|       |                        flush_buffer(b, ix);
 1589|       |                     }
 1590|       |
 1591|       |                     to<JSON, val_t>::template op<write_unchecked_on<Opts>()>(*it, ctx, b, ix);
 1592|       |                  }
 1593|       |                  else {
 1594|       |                     write_array_entry_separator<Opts>(ctx, b, ix);
 1595|       |                     to<JSON, val_t>::template op<Opts>(*it, ctx, b, ix);
 1596|       |                     if (bool(ctx.error)) [[unlikely]] {
 1597|       |                        return;
 1598|       |                     }
 1599|       |                  }
 1600|       |               }
 1601|       |               if constexpr (Opts.prettify && check_new_lines_in_arrays(Opts)) {
 1602|       |                  ctx.depth -= check_indentation_width(Opts);
 1603|       |                  dump_newline_indent(check_indentation_char(Opts), ctx.depth, b, ix);
 1604|       |               }
 1605|       |
 1606|       |               dump(']', b, ix);
 1607|       |            }
 1608|      0|         }
 1609|    190|      }
_ZZN3glz2toILj10EN12jsonrpc_fuzz8fuzz_apiEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlTnmvE_clILm5EEEDav:
 2539|     43|               for_each<N>([&]<size_t I>() {
 2540|     43|                  using val_t = field_t<T, I>;
 2541|       |
 2542|       |                  // `meta<T>::skip` joins the other compile-time exclusions here rather than returning
 2543|       |                  // early, so that a skipped field's writer is never instantiated -- see
 2544|       |                  // `skipped_by_meta`.
 2545|     43|                  constexpr bool write_function_pointers = check_write_function_pointers(Opts);
 2546|       |                  if constexpr (skipped_by_meta<T, I, operation::serialize> || always_skipped<val_t> ||
 2547|       |                                (!write_function_pointers && is_any_function_ptr<val_t>)) {
 2548|       |                     return;
 2549|       |                  }
 2550|     43|                  else {
 2551|       |                     if constexpr (meta_has_skip_if<T>) {
 2552|       |                        static constexpr auto skip_if_key = glz::get<I>(reflect<T>::keys);
 2553|       |                        static constexpr meta_context mctx{.op = operation::serialize};
 2554|       |                        decltype(auto) field_value = [&]() -> decltype(auto) {
 2555|       |                           if constexpr (reflectable<T>) {
 2556|       |                              return get<I>(t);
 2557|       |                           }
 2558|       |                           else {
 2559|       |                              return get_member(value, glz::get<I>(reflect<T>::values));
 2560|       |                           }
 2561|       |                        }();
 2562|       |                        if (meta<T>::skip_if(field_value, skip_if_key, mctx)) return;
 2563|       |                     }
 2564|       |
 2565|       |                     if constexpr (null_t<val_t> && Opts.skip_null_members) {
 2566|       |                        if constexpr (always_null_t<val_t>)
 2567|       |                           return;
 2568|       |                        else {
 2569|       |                           const auto is_null = [&]() {
 2570|       |                              decltype(auto) element = [&]() -> decltype(auto) {
 2571|       |                                 if constexpr (reflectable<T>) {
 2572|       |                                    return get<I>(t);
 2573|       |                                 }
 2574|       |                                 else {
 2575|       |                                    return get<I>(reflect<T>::values);
 2576|       |                                 }
 2577|       |                              };
 2578|       |
 2579|       |                              if constexpr (nullable_wrapper<val_t>) {
 2580|       |                                 return !bool(element()(value).val);
 2581|       |                              }
 2582|       |                              else if constexpr (nullable_value_t<val_t>) {
 2583|       |                                 return !get_member(value, element()).has_value();
 2584|       |                              }
 2585|       |                              else {
 2586|       |                                 return !bool(get_member(value, element()));
 2587|       |                              }
 2588|       |                           }();
 2589|       |                           if (is_null) return;
 2590|       |                        }
 2591|       |                     }
 2592|       |                     else if constexpr (is_specialization_v<val_t, custom_t> && Opts.skip_null_members &&
 2593|       |                                        custom_getter_returns_nullable<val_t>()) {
 2594|       |                        if (is_custom_field_null<T, I>(value, t, ctx)) return;
 2595|       |                     }
 2596|     43|                     else if constexpr (Opts.skip_null_members && glaze_value_is_nullable<val_t>()) {
 2597|     43|                        if (is_glaze_value_field_null<T, I>(value, t)) return;
 2598|     43|                     }
 2599|       |
 2600|       |                     if constexpr (check_skip_default_members(Opts) && has_skippable_default<val_t>) {
 2601|       |                        decltype(auto) member = [&]() -> decltype(auto) {
 2602|       |                           if constexpr (reflectable<T>) {
 2603|       |                              return get_member(value, get<I>(t));
 2604|       |                           }
 2605|       |                           else {
 2606|       |                              return get_member(value, get<I>(reflect<T>::values));
 2607|       |                           }
 2608|       |                        }();
 2609|       |                        if (is_default_value(member)) return;
 2610|       |                     }
 2611|       |
 2612|       |                     if constexpr (Opts.prettify) {
 2613|       |                        if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] {
 2614|       |                           return;
 2615|       |                        }
 2616|       |                     }
 2617|     43|                     else {
 2618|     43|                        if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] {
  ------------------
  |  Branch (2618:29): [True: 0, False: 43]
  ------------------
 2619|      0|                           return;
 2620|      0|                        }
 2621|     43|                     }
 2622|       |
 2623|     43|                     if (first) {
  ------------------
  |  Branch (2623:26): [True: 0, False: 43]
  ------------------
 2624|      0|                        first = false;
 2625|      0|                     }
 2626|     43|                     else {
 2627|       |                        // Null members may be skipped so we can't just write it out for all but the last member
 2628|       |                        if constexpr (Opts.prettify) {
 2629|       |                           std::memcpy(&b[ix], ",\n", 2);
 2630|       |                           ix += 2;
 2631|       |                           std::memset(&b[ix], check_indentation_char(Opts), ctx.depth);
 2632|       |                           ix += ctx.depth;
 2633|       |                        }
 2634|     43|                        else {
 2635|     43|                           std::memcpy(&b[ix], ",", 1);
 2636|     43|                           ++ix;
 2637|     43|                        }
 2638|       |                        if constexpr (is_output_streaming<B>) {
 2639|       |                           flush_buffer(b, ix);
 2640|       |                        }
 2641|     43|                     }
 2642|       |
 2643|       |                     // MSVC requires get<I> rather than keys[I]
 2644|     43|                     static constexpr auto key = glz::get<I>(reflect<T>::keys); // GCC 14 requires auto here
 2645|     43|                     static constexpr auto quoted_key = quoted_key_v<key, Opts.prettify>;
 2646|     43|                     static constexpr auto n = quoted_key.size();
 2647|     43|                     std::memcpy(&b[ix], quoted_key.data(), n);
 2648|     43|                     ix += n;
 2649|       |
 2650|     43|                     static constexpr auto check_opts = required_padding<val_t>() ? write_unchecked_on<Opts>() : Opts;
  ------------------
  |  Branch (2650:57): [Folded, False: 43]
  ------------------
 2651|     43|                     if constexpr (reflectable<T>) {
 2652|     43|                        to<JSON, val_t>::template op<check_opts>(get_member(value, get<I>(t)), ctx, b, ix);
 2653|       |                     }
 2654|       |                     else {
 2655|       |                        to<JSON, val_t>::template op<check_opts>(get_member(value, get<I>(reflect<T>::values)), ctx, b,
 2656|       |                                                                 ix);
 2657|       |                     }
 2658|     43|                  }
 2659|     43|               });
_ZN3glz2toILj10ENSt3__13mapINS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEiNS1_4lessIS8_EENS6_INS1_4pairIKS8_iEEEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS8_RSF_TkNS_10is_contextERNS_7contextEmQoo14writable_map_tIT_EaaL_ZNS0_ILj10ESN_E14map_like_arrayEEeqcl17check_concatenateTL0__ELb1EEEvOT1_OT2_OT0_RT3_:
 1614|     75|      {
 1615|     75|         if constexpr (not check_opening_handled(Opts)) {
 1616|     75|            dump('{', b, ix);
 1617|     75|         }
 1618|       |
 1619|     75|         if (!empty_range(value)) {
  ------------------
  |  Branch (1619:14): [True: 0, False: 75]
  ------------------
 1620|      0|            if constexpr (!check_opening_handled(Opts)) {
 1621|       |               if constexpr (Opts.prettify) {
 1622|       |                  ctx.depth += check_indentation_width(Opts);
 1623|       |                  if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] {
 1624|       |                     return;
 1625|       |                  }
 1626|       |                  std::memcpy(&b[ix], "\n", 1);
 1627|       |                  ++ix;
 1628|       |                  std::memset(&b[ix], check_indentation_char(Opts), ctx.depth);
 1629|       |                  ix += ctx.depth;
 1630|       |               }
 1631|      0|            }
 1632|       |
 1633|      0|            using val_t = detail::iterator_second_type<T>; // the type of value in each [key, value] pair
 1634|      0|            constexpr bool write_function_pointers = check_write_function_pointers(Opts);
 1635|      0|            if constexpr (!always_skipped<val_t> && (write_function_pointers || !is_any_function_ptr<val_t>)) {
 1636|       |               if constexpr (null_t<val_t> && Opts.skip_null_members) {
 1637|       |                  auto write_first_entry = [&](auto&& it) {
 1638|       |                     auto&& [key, entry_val] = *it;
 1639|       |                     if (skip_member<Opts>(entry_val)) {
 1640|       |                        return true;
 1641|       |                     }
 1642|       |                     write_pair_content<Opts>(key, entry_val, ctx, b, ix);
 1643|       |                     return bool(ctx.error);
 1644|       |                  };
 1645|       |
 1646|       |                  auto it = std::begin(value);
 1647|       |                  bool first = write_first_entry(it);
 1648|       |                  if (bool(ctx.error)) [[unlikely]] {
 1649|       |                     return;
 1650|       |                  }
 1651|       |                  ++it;
 1652|       |                  for (const auto end = std::end(value); it != end; ++it) {
 1653|       |                     auto&& [key, entry_val] = *it;
 1654|       |                     if (skip_member<Opts>(entry_val)) {
 1655|       |                        continue;
 1656|       |                     }
 1657|       |
 1658|       |                     // When Opts.skip_null_members, *any* entry may be skipped, meaning separator dumping must be
 1659|       |                     // conditional for every entry.
 1660|       |                     // Alternatively, write separator after each entry except last but then branch is permanent
 1661|       |                     if (not first) {
 1662|       |                        write_object_entry_separator<Opts>(ctx, b, ix);
 1663|       |                     }
 1664|       |
 1665|       |                     write_pair_content<Opts>(key, entry_val, ctx, b, ix);
 1666|       |                     if (bool(ctx.error)) [[unlikely]] {
 1667|       |                        return;
 1668|       |                     }
 1669|       |
 1670|       |                     first = false;
 1671|       |                  }
 1672|       |               }
 1673|      0|               else {
 1674|      0|                  auto write_first_entry = [&](auto&& it) {
 1675|      0|                     auto&& [key, entry_val] = *it;
 1676|      0|                     write_pair_content<Opts>(key, entry_val, ctx, b, ix);
 1677|      0|                  };
 1678|       |
 1679|      0|                  auto it = std::begin(value);
 1680|      0|                  write_first_entry(it);
 1681|      0|                  if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (1681:23): [True: 0, False: 0]
  ------------------
 1682|      0|                     return;
 1683|      0|                  }
 1684|      0|                  ++it;
 1685|      0|                  for (const auto end = std::end(value); it != end; ++it) {
  ------------------
  |  Branch (1685:58): [True: 0, False: 0]
  ------------------
 1686|      0|                     auto&& [key, entry_val] = *it;
 1687|      0|                     write_object_entry_separator<Opts>(ctx, b, ix);
 1688|      0|                     write_pair_content<Opts>(key, entry_val, ctx, b, ix);
 1689|      0|                     if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (1689:26): [True: 0, False: 0]
  ------------------
 1690|      0|                        return;
 1691|      0|                     }
 1692|      0|                  }
 1693|      0|               }
 1694|      0|            }
 1695|       |
 1696|      0|            if constexpr (!check_closing_handled(Opts)) {
 1697|       |               if constexpr (Opts.prettify) {
 1698|       |                  ctx.depth -= check_indentation_width(Opts);
 1699|       |                  if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] {
 1700|       |                     return;
 1701|       |                  }
 1702|       |                  std::memcpy(&b[ix], "\n", 1);
 1703|       |                  ++ix;
 1704|       |                  std::memset(&b[ix], check_indentation_char(Opts), ctx.depth);
 1705|       |                  ix += ctx.depth;
 1706|       |               }
 1707|      0|            }
 1708|      0|         }
 1709|       |
 1710|     75|         if constexpr (!check_closing_handled(Opts)) {
 1711|     75|            dump('}', b, ix);
 1712|     75|         }
 1713|     75|      }
_ZZN3glz2toILj10EN12jsonrpc_fuzz8fuzz_apiEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlTnmvE_clILm6EEEDav:
 2539|     43|               for_each<N>([&]<size_t I>() {
 2540|     43|                  using val_t = field_t<T, I>;
 2541|       |
 2542|       |                  // `meta<T>::skip` joins the other compile-time exclusions here rather than returning
 2543|       |                  // early, so that a skipped field's writer is never instantiated -- see
 2544|       |                  // `skipped_by_meta`.
 2545|     43|                  constexpr bool write_function_pointers = check_write_function_pointers(Opts);
 2546|       |                  if constexpr (skipped_by_meta<T, I, operation::serialize> || always_skipped<val_t> ||
 2547|       |                                (!write_function_pointers && is_any_function_ptr<val_t>)) {
 2548|       |                     return;
 2549|       |                  }
 2550|     43|                  else {
 2551|       |                     if constexpr (meta_has_skip_if<T>) {
 2552|       |                        static constexpr auto skip_if_key = glz::get<I>(reflect<T>::keys);
 2553|       |                        static constexpr meta_context mctx{.op = operation::serialize};
 2554|       |                        decltype(auto) field_value = [&]() -> decltype(auto) {
 2555|       |                           if constexpr (reflectable<T>) {
 2556|       |                              return get<I>(t);
 2557|       |                           }
 2558|       |                           else {
 2559|       |                              return get_member(value, glz::get<I>(reflect<T>::values));
 2560|       |                           }
 2561|       |                        }();
 2562|       |                        if (meta<T>::skip_if(field_value, skip_if_key, mctx)) return;
 2563|       |                     }
 2564|       |
 2565|     43|                     if constexpr (null_t<val_t> && Opts.skip_null_members) {
 2566|       |                        if constexpr (always_null_t<val_t>)
 2567|       |                           return;
 2568|     43|                        else {
 2569|     43|                           const auto is_null = [&]() {
 2570|     43|                              decltype(auto) element = [&]() -> decltype(auto) {
 2571|     43|                                 if constexpr (reflectable<T>) {
 2572|     43|                                    return get<I>(t);
 2573|     43|                                 }
 2574|     43|                                 else {
 2575|     43|                                    return get<I>(reflect<T>::values);
 2576|     43|                                 }
 2577|     43|                              };
 2578|       |
 2579|     43|                              if constexpr (nullable_wrapper<val_t>) {
 2580|     43|                                 return !bool(element()(value).val);
 2581|     43|                              }
 2582|     43|                              else if constexpr (nullable_value_t<val_t>) {
 2583|     43|                                 return !get_member(value, element()).has_value();
 2584|     43|                              }
 2585|     43|                              else {
 2586|     43|                                 return !bool(get_member(value, element()));
 2587|     43|                              }
 2588|     43|                           }();
 2589|     43|                           if (is_null) return;
  ------------------
  |  Branch (2589:32): [True: 43, False: 0]
  ------------------
 2590|     43|                        }
 2591|       |                     }
 2592|       |                     else if constexpr (is_specialization_v<val_t, custom_t> && Opts.skip_null_members &&
 2593|       |                                        custom_getter_returns_nullable<val_t>()) {
 2594|       |                        if (is_custom_field_null<T, I>(value, t, ctx)) return;
 2595|       |                     }
 2596|       |                     else if constexpr (Opts.skip_null_members && glaze_value_is_nullable<val_t>()) {
 2597|       |                        if (is_glaze_value_field_null<T, I>(value, t)) return;
 2598|       |                     }
 2599|       |
 2600|       |                     if constexpr (check_skip_default_members(Opts) && has_skippable_default<val_t>) {
 2601|       |                        decltype(auto) member = [&]() -> decltype(auto) {
 2602|       |                           if constexpr (reflectable<T>) {
 2603|       |                              return get_member(value, get<I>(t));
 2604|       |                           }
 2605|       |                           else {
 2606|       |                              return get_member(value, get<I>(reflect<T>::values));
 2607|       |                           }
 2608|       |                        }();
 2609|       |                        if (is_default_value(member)) return;
 2610|       |                     }
 2611|       |
 2612|       |                     if constexpr (Opts.prettify) {
 2613|       |                        if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] {
 2614|       |                           return;
 2615|       |                        }
 2616|       |                     }
 2617|     43|                     else {
 2618|     43|                        if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] {
  ------------------
  |  Branch (2618:29): [True: 0, False: 43]
  ------------------
 2619|      0|                           return;
 2620|      0|                        }
 2621|     43|                     }
 2622|       |
 2623|     43|                     if (first) {
  ------------------
  |  Branch (2623:26): [True: 0, False: 43]
  ------------------
 2624|      0|                        first = false;
 2625|      0|                     }
 2626|     43|                     else {
 2627|       |                        // Null members may be skipped so we can't just write it out for all but the last member
 2628|       |                        if constexpr (Opts.prettify) {
 2629|       |                           std::memcpy(&b[ix], ",\n", 2);
 2630|       |                           ix += 2;
 2631|       |                           std::memset(&b[ix], check_indentation_char(Opts), ctx.depth);
 2632|       |                           ix += ctx.depth;
 2633|       |                        }
 2634|     43|                        else {
 2635|     43|                           std::memcpy(&b[ix], ",", 1);
 2636|     43|                           ++ix;
 2637|     43|                        }
 2638|       |                        if constexpr (is_output_streaming<B>) {
 2639|       |                           flush_buffer(b, ix);
 2640|       |                        }
 2641|     43|                     }
 2642|       |
 2643|       |                     // MSVC requires get<I> rather than keys[I]
 2644|     43|                     static constexpr auto key = glz::get<I>(reflect<T>::keys); // GCC 14 requires auto here
 2645|     43|                     static constexpr auto quoted_key = quoted_key_v<key, Opts.prettify>;
 2646|     43|                     static constexpr auto n = quoted_key.size();
 2647|     43|                     std::memcpy(&b[ix], quoted_key.data(), n);
 2648|     43|                     ix += n;
 2649|       |
 2650|     43|                     static constexpr auto check_opts = required_padding<val_t>() ? write_unchecked_on<Opts>() : Opts;
  ------------------
  |  Branch (2650:57): [True: 0, Folded]
  ------------------
 2651|     43|                     if constexpr (reflectable<T>) {
 2652|     43|                        to<JSON, val_t>::template op<check_opts>(get_member(value, get<I>(t)), ctx, b, ix);
 2653|       |                     }
 2654|       |                     else {
 2655|       |                        to<JSON, val_t>::template op<check_opts>(get_member(value, get<I>(reflect<T>::values)), ctx, b,
 2656|       |                                                                 ix);
 2657|       |                     }
 2658|     43|                  }
 2659|     43|               });
_ZZZN3glz2toILj10EN12jsonrpc_fuzz8fuzz_apiEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlTnmvE_clILm6EEEDavENKUlvE_clEv:
 2569|     43|                           const auto is_null = [&]() {
 2570|     43|                              decltype(auto) element = [&]() -> decltype(auto) {
 2571|     43|                                 if constexpr (reflectable<T>) {
 2572|     43|                                    return get<I>(t);
 2573|     43|                                 }
 2574|     43|                                 else {
 2575|     43|                                    return get<I>(reflect<T>::values);
 2576|     43|                                 }
 2577|     43|                              };
 2578|       |
 2579|       |                              if constexpr (nullable_wrapper<val_t>) {
 2580|       |                                 return !bool(element()(value).val);
 2581|       |                              }
 2582|     43|                              else if constexpr (nullable_value_t<val_t>) {
 2583|     43|                                 return !get_member(value, element()).has_value();
 2584|       |                              }
 2585|       |                              else {
 2586|       |                                 return !bool(get_member(value, element()));
 2587|       |                              }
 2588|     43|                           }();
_ZZZZN3glz2toILj10EN12jsonrpc_fuzz8fuzz_apiEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlTnmvE_clILm6EEEDavENKUlvE_clEvENKUlvE_clEv:
 2570|     43|                              decltype(auto) element = [&]() -> decltype(auto) {
 2571|     43|                                 if constexpr (reflectable<T>) {
 2572|     43|                                    return get<I>(t);
 2573|       |                                 }
 2574|       |                                 else {
 2575|       |                                    return get<I>(reflect<T>::values);
 2576|       |                                 }
 2577|     43|                              };
_ZZN3glz2toILj10EN12jsonrpc_fuzz8fuzz_apiEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlTnmvE_clILm7EEEDav:
 2539|     43|               for_each<N>([&]<size_t I>() {
 2540|     43|                  using val_t = field_t<T, I>;
 2541|       |
 2542|       |                  // `meta<T>::skip` joins the other compile-time exclusions here rather than returning
 2543|       |                  // early, so that a skipped field's writer is never instantiated -- see
 2544|       |                  // `skipped_by_meta`.
 2545|     43|                  constexpr bool write_function_pointers = check_write_function_pointers(Opts);
 2546|       |                  if constexpr (skipped_by_meta<T, I, operation::serialize> || always_skipped<val_t> ||
 2547|       |                                (!write_function_pointers && is_any_function_ptr<val_t>)) {
 2548|       |                     return;
 2549|       |                  }
 2550|     43|                  else {
 2551|       |                     if constexpr (meta_has_skip_if<T>) {
 2552|       |                        static constexpr auto skip_if_key = glz::get<I>(reflect<T>::keys);
 2553|       |                        static constexpr meta_context mctx{.op = operation::serialize};
 2554|       |                        decltype(auto) field_value = [&]() -> decltype(auto) {
 2555|       |                           if constexpr (reflectable<T>) {
 2556|       |                              return get<I>(t);
 2557|       |                           }
 2558|       |                           else {
 2559|       |                              return get_member(value, glz::get<I>(reflect<T>::values));
 2560|       |                           }
 2561|       |                        }();
 2562|       |                        if (meta<T>::skip_if(field_value, skip_if_key, mctx)) return;
 2563|       |                     }
 2564|       |
 2565|       |                     if constexpr (null_t<val_t> && Opts.skip_null_members) {
 2566|       |                        if constexpr (always_null_t<val_t>)
 2567|       |                           return;
 2568|       |                        else {
 2569|       |                           const auto is_null = [&]() {
 2570|       |                              decltype(auto) element = [&]() -> decltype(auto) {
 2571|       |                                 if constexpr (reflectable<T>) {
 2572|       |                                    return get<I>(t);
 2573|       |                                 }
 2574|       |                                 else {
 2575|       |                                    return get<I>(reflect<T>::values);
 2576|       |                                 }
 2577|       |                              };
 2578|       |
 2579|       |                              if constexpr (nullable_wrapper<val_t>) {
 2580|       |                                 return !bool(element()(value).val);
 2581|       |                              }
 2582|       |                              else if constexpr (nullable_value_t<val_t>) {
 2583|       |                                 return !get_member(value, element()).has_value();
 2584|       |                              }
 2585|       |                              else {
 2586|       |                                 return !bool(get_member(value, element()));
 2587|       |                              }
 2588|       |                           }();
 2589|       |                           if (is_null) return;
 2590|       |                        }
 2591|       |                     }
 2592|       |                     else if constexpr (is_specialization_v<val_t, custom_t> && Opts.skip_null_members &&
 2593|       |                                        custom_getter_returns_nullable<val_t>()) {
 2594|       |                        if (is_custom_field_null<T, I>(value, t, ctx)) return;
 2595|       |                     }
 2596|     43|                     else if constexpr (Opts.skip_null_members && glaze_value_is_nullable<val_t>()) {
 2597|     43|                        if (is_glaze_value_field_null<T, I>(value, t)) return;
 2598|     43|                     }
 2599|       |
 2600|       |                     if constexpr (check_skip_default_members(Opts) && has_skippable_default<val_t>) {
 2601|       |                        decltype(auto) member = [&]() -> decltype(auto) {
 2602|       |                           if constexpr (reflectable<T>) {
 2603|       |                              return get_member(value, get<I>(t));
 2604|       |                           }
 2605|       |                           else {
 2606|       |                              return get_member(value, get<I>(reflect<T>::values));
 2607|       |                           }
 2608|       |                        }();
 2609|       |                        if (is_default_value(member)) return;
 2610|       |                     }
 2611|       |
 2612|       |                     if constexpr (Opts.prettify) {
 2613|       |                        if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] {
 2614|       |                           return;
 2615|       |                        }
 2616|       |                     }
 2617|     43|                     else {
 2618|     43|                        if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] {
  ------------------
  |  Branch (2618:29): [True: 0, False: 43]
  ------------------
 2619|      0|                           return;
 2620|      0|                        }
 2621|     43|                     }
 2622|       |
 2623|     43|                     if (first) {
  ------------------
  |  Branch (2623:26): [True: 0, False: 43]
  ------------------
 2624|      0|                        first = false;
 2625|      0|                     }
 2626|     43|                     else {
 2627|       |                        // Null members may be skipped so we can't just write it out for all but the last member
 2628|       |                        if constexpr (Opts.prettify) {
 2629|       |                           std::memcpy(&b[ix], ",\n", 2);
 2630|       |                           ix += 2;
 2631|       |                           std::memset(&b[ix], check_indentation_char(Opts), ctx.depth);
 2632|       |                           ix += ctx.depth;
 2633|       |                        }
 2634|     43|                        else {
 2635|     43|                           std::memcpy(&b[ix], ",", 1);
 2636|     43|                           ++ix;
 2637|     43|                        }
 2638|       |                        if constexpr (is_output_streaming<B>) {
 2639|       |                           flush_buffer(b, ix);
 2640|       |                        }
 2641|     43|                     }
 2642|       |
 2643|       |                     // MSVC requires get<I> rather than keys[I]
 2644|     43|                     static constexpr auto key = glz::get<I>(reflect<T>::keys); // GCC 14 requires auto here
 2645|     43|                     static constexpr auto quoted_key = quoted_key_v<key, Opts.prettify>;
 2646|     43|                     static constexpr auto n = quoted_key.size();
 2647|     43|                     std::memcpy(&b[ix], quoted_key.data(), n);
 2648|     43|                     ix += n;
 2649|       |
 2650|     43|                     static constexpr auto check_opts = required_padding<val_t>() ? write_unchecked_on<Opts>() : Opts;
  ------------------
  |  Branch (2650:57): [Folded, False: 43]
  ------------------
 2651|     43|                     if constexpr (reflectable<T>) {
 2652|     43|                        to<JSON, val_t>::template op<check_opts>(get_member(value, get<I>(t)), ctx, b, ix);
 2653|       |                     }
 2654|       |                     else {
 2655|       |                        to<JSON, val_t>::template op<check_opts>(get_member(value, get<I>(reflect<T>::values)), ctx, b,
 2656|       |                                                                 ix);
 2657|       |                     }
 2658|     43|                  }
 2659|     43|               });
_ZN3glz2toILj10ENSt3__17variantIJNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEN12jsonrpc_fuzz6amountEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS8_RSB_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_:
 1947|    106|      {
 1948|       |         // Adjacent tagging needs no per-alternative dispatch: the discriminator and the value are
 1949|       |         // written side by side whatever the alternative is. The visit below still instantiates in
 1950|       |         // that mode (`if constexpr` does not discard the statements after it), but both of its
 1951|       |         // tagged branches are compile-time dead there and the runtime `return` keeps it unreached.
 1952|       |         if constexpr (check_write_type_info(Opts) && tagging == variant_tagging_kind::adjacent) {
 1953|       |            write_adjacent<Opts>(value, ctx, b, ix);
 1954|       |            return;
 1955|       |         }
 1956|    106|         std::visit(
 1957|    106|            [&](auto&& val) {
 1958|    106|               using V = std::decay_t<decltype(val)>;
 1959|       |
 1960|    106|               if constexpr (check_write_type_info(Opts) && tagging == variant_tagging_kind::internal &&
 1961|    106|                             custom_write<V>) {
 1962|       |                  // Custom alternative: the user's serializer emits the object body, into which we
 1963|       |                  // merge the variant tag. For this to produce valid JSON the custom to<> must (1)
 1964|       |                  // write an object body and (2) honor opening_and_closing_handled (suppress its own
 1965|       |                  // braces) so the tag shares the alternative's object. A custom writer that emits a
 1966|       |                  // scalar/array, or that ignores those flags, would yield malformed output.
 1967|       |                  //
 1968|       |                  // The tag-emission below mirrors the reflected-object branch that follows; keep the
 1969|       |                  // two in sync. The body size is not known at compile time, so we always write the
 1970|       |                  // tag separator and then drop it at runtime if the body turned out empty.
 1971|    106|                  if (missing_id(value, ctx)) {
 1972|    106|                     return;
 1973|    106|                  }
 1974|    106|                  using id_type = std::decay_t<decltype(ids_v<T>[value.index()])>;
 1975|    106|                  if constexpr (Opts.prettify) {
 1976|    106|                     dump("{\n", b, ix);
 1977|    106|                     ctx.depth += check_indentation_width(Opts);
 1978|    106|                     dumpn(check_indentation_char(Opts), ctx.depth, b, ix);
 1979|    106|                     dump('"', b, ix);
 1980|    106|                     dump_maybe_empty(tag_v<T>, b, ix);
 1981|    106|                     if constexpr (std::integral<id_type>) {
 1982|    106|                        dump("\": ", b, ix);
 1983|    106|                        serialize<JSON>::op<Opts>(ids_v<T>[value.index()], ctx, b, ix);
 1984|    106|                     }
 1985|    106|                     else {
 1986|    106|                        dump("\": \"", b, ix);
 1987|    106|                        dump_maybe_empty(ids_v<T>[value.index()], b, ix);
 1988|    106|                        dump('"', b, ix);
 1989|    106|                     }
 1990|    106|                     const auto pos_after_tag = ix;
 1991|    106|                     dump(",\n", b, ix);
 1992|    106|                     dumpn(check_indentation_char(Opts), ctx.depth, b, ix);
 1993|    106|                     const auto pos_body_start = ix;
 1994|    106|                     to<JSON, V>::template op<opening_and_closing_handled<Opts>()>(val, ctx, b, ix);
 1995|    106|                     if (ix == pos_body_start) {
 1996|    106|                        ix = pos_after_tag; // custom body was empty: undo the tag separator
 1997|    106|                     }
 1998|    106|                     ctx.depth -= check_indentation_width(Opts);
 1999|    106|                     if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] {
 2000|    106|                        return;
 2001|    106|                     }
 2002|    106|                     std::memcpy(&b[ix], "\n", 1);
 2003|    106|                     ++ix;
 2004|    106|                     std::memset(&b[ix], check_indentation_char(Opts), ctx.depth);
 2005|    106|                     ix += ctx.depth;
 2006|    106|                     std::memcpy(&b[ix], "}", 1);
 2007|    106|                     ++ix;
 2008|    106|                  }
 2009|    106|                  else {
 2010|    106|                     dump("{\"", b, ix);
 2011|    106|                     dump_maybe_empty(tag_v<T>, b, ix);
 2012|    106|                     if constexpr (std::integral<id_type>) {
 2013|    106|                        dump("\":", b, ix);
 2014|    106|                        serialize<JSON>::op<Opts>(ids_v<T>[value.index()], ctx, b, ix);
 2015|    106|                     }
 2016|    106|                     else {
 2017|    106|                        dump("\":\"", b, ix);
 2018|    106|                        dump_maybe_empty(ids_v<T>[value.index()], b, ix);
 2019|    106|                        dump('"', b, ix);
 2020|    106|                     }
 2021|    106|                     const auto pos_after_tag = ix;
 2022|    106|                     dump(',', b, ix);
 2023|    106|                     const auto pos_body_start = ix;
 2024|    106|                     to<JSON, V>::template op<opening_and_closing_handled<Opts>()>(val, ctx, b, ix);
 2025|    106|                     if (ix == pos_body_start) {
 2026|    106|                        ix = pos_after_tag; // custom body was empty: undo the tag separator
 2027|    106|                     }
 2028|    106|                     dump('}', b, ix);
 2029|    106|                  }
 2030|    106|               }
 2031|    106|               else if constexpr (check_write_type_info(Opts) && tagging == variant_tagging_kind::internal &&
 2032|    106|                                  variant_unit_alternative<V>) {
 2033|       |                  // A unit alternative carries no data, so internal tagging renders it as the
 2034|       |                  // discriminator alone -- the same object an empty struct alternative produces.
 2035|    106|                  if (missing_id(value, ctx)) {
 2036|    106|                     return;
 2037|    106|                  }
 2038|    106|                  if constexpr (Opts.prettify) {
 2039|    106|                     dump("{\n", b, ix);
 2040|    106|                     ctx.depth += check_indentation_width(Opts);
 2041|    106|                     dumpn(check_indentation_char(Opts), ctx.depth, b, ix);
 2042|    106|                     dump('"', b, ix);
 2043|    106|                     dump_maybe_empty(tag_v<T>, b, ix);
 2044|    106|                     dump("\": ", b, ix);
 2045|    106|                     write_id<Opts>(value, ctx, b, ix);
 2046|    106|                     ctx.depth -= check_indentation_width(Opts);
 2047|    106|                     if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] {
 2048|    106|                        return;
 2049|    106|                     }
 2050|    106|                     std::memcpy(&b[ix], "\n", 1);
 2051|    106|                     ++ix;
 2052|    106|                     std::memset(&b[ix], check_indentation_char(Opts), ctx.depth);
 2053|    106|                     ix += ctx.depth;
 2054|    106|                     std::memcpy(&b[ix], "}", 1);
 2055|    106|                     ++ix;
 2056|    106|                  }
 2057|    106|                  else {
 2058|    106|                     dump("{\"", b, ix);
 2059|    106|                     dump_maybe_empty(tag_v<T>, b, ix);
 2060|    106|                     dump("\":", b, ix);
 2061|    106|                     write_id<Opts>(value, ctx, b, ix);
 2062|    106|                     dump('}', b, ix);
 2063|    106|                  }
 2064|    106|               }
 2065|    106|               else if constexpr (check_write_type_info(Opts) && tagging == variant_tagging_kind::internal &&
 2066|    106|                                  (glaze_object_t<V> || reflectable<V> || is_memory_object<V>) &&
 2067|    106|                                  (not alternative_declares_key<V>(tag_v<T>))) {
 2068|       |                  // An alternative that declares a member named like the discriminator carries the
 2069|       |                  // discriminator itself, so no tag is merged here and the bare-write branch below
 2070|       |                  // handles it. Previously only `reflectable` alternatives were excluded; a
 2071|       |                  // `glaze_object_t` one fell through to this branch and emitted the key twice.
 2072|    106|                  if (missing_id(value, ctx)) {
 2073|    106|                     return;
 2074|    106|                  }
 2075|    106|                  constexpr auto N = []() {
 2076|    106|                     if constexpr (is_memory_object<V>) {
 2077|    106|                        return reflect<memory_type<V>>::size;
 2078|    106|                     }
 2079|    106|                     else {
 2080|    106|                        return reflect<V>::size;
 2081|    106|                     }
 2082|    106|                  }();
 2083|       |
 2084|       |                  // must first write out type
 2085|    106|                  if constexpr (Opts.prettify) {
 2086|    106|                     dump("{\n", b, ix);
 2087|    106|                     ctx.depth += check_indentation_width(Opts);
 2088|    106|                     dumpn(check_indentation_char(Opts), ctx.depth, b, ix);
 2089|    106|                     dump('"', b, ix);
 2090|    106|                     dump_maybe_empty(tag_v<T>, b, ix);
 2091|       |
 2092|    106|                     using id_type = std::decay_t<decltype(ids_v<T>[value.index()])>;
 2093|       |
 2094|    106|                     if constexpr (std::integral<id_type>) {
 2095|    106|                        dump("\": ", b, ix);
 2096|    106|                        serialize<JSON>::op<Opts>(ids_v<T>[value.index()], ctx, b, ix);
 2097|    106|                        if constexpr (N > 0) {
 2098|    106|                           dump(",\n", b, ix);
 2099|    106|                           dumpn(check_indentation_char(Opts), ctx.depth, b, ix);
 2100|    106|                        }
 2101|    106|                     }
 2102|    106|                     else {
 2103|    106|                        dump("\": \"", b, ix);
 2104|    106|                        dump_maybe_empty(ids_v<T>[value.index()], b, ix);
 2105|    106|                        if constexpr (N == 0) {
 2106|    106|                           dump('"', b, ix);
 2107|    106|                        }
 2108|    106|                        else {
 2109|    106|                           dump("\",\n", b, ix);
 2110|    106|                           dumpn(check_indentation_char(Opts), ctx.depth, b, ix);
 2111|    106|                        }
 2112|    106|                     }
 2113|    106|                  }
 2114|    106|                  else {
 2115|    106|                     using id_type = std::decay_t<decltype(ids_v<T>[value.index()])>;
 2116|       |
 2117|    106|                     dump("{\"", b, ix);
 2118|    106|                     dump_maybe_empty(tag_v<T>, b, ix);
 2119|       |
 2120|    106|                     if constexpr (std::integral<id_type>) {
 2121|    106|                        dump("\":", b, ix);
 2122|    106|                        serialize<JSON>::op<Opts>(ids_v<T>[value.index()], ctx, b, ix);
 2123|    106|                        if constexpr (N > 0) {
 2124|    106|                           dump(',', b, ix);
 2125|    106|                        }
 2126|    106|                     }
 2127|    106|                     else {
 2128|    106|                        dump("\":\"", b, ix);
 2129|    106|                        dump_maybe_empty(ids_v<T>[value.index()], b, ix);
 2130|    106|                        if constexpr (N == 0) {
 2131|    106|                           dump('"', b, ix);
 2132|    106|                        }
 2133|    106|                        else {
 2134|    106|                           dump("\",", b, ix);
 2135|    106|                        }
 2136|    106|                     }
 2137|    106|                  }
 2138|    106|                  if constexpr (is_memory_object<V>) {
 2139|    106|                     if (!val) [[unlikely]] {
 2140|    106|                        ctx.error = error_code::invalid_variant_object;
 2141|    106|                        return;
 2142|    106|                     }
 2143|    106|                     to<JSON, memory_type<V>>::template op<opening_and_closing_handled<Opts>()>(*val, ctx, b, ix);
 2144|    106|                  }
 2145|    106|                  else {
 2146|    106|                     to<JSON, V>::template op<opening_and_closing_handled<Opts>()>(val, ctx, b, ix);
 2147|    106|                  }
 2148|       |                  // If we skip everything then we may have an extra comma, which we want to revert
 2149|    106|                  if constexpr (Opts.skip_null_members) {
 2150|    106|                     if (b[ix - 1] == ',') {
 2151|    106|                        --ix;
 2152|    106|                     }
 2153|    106|                  }
 2154|       |
 2155|    106|                  if constexpr (Opts.prettify) {
 2156|    106|                     ctx.depth -= check_indentation_width(Opts);
 2157|    106|                     if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] {
 2158|    106|                        return;
 2159|    106|                     }
 2160|    106|                     std::memcpy(&b[ix], "\n", 1);
 2161|    106|                     ++ix;
 2162|    106|                     std::memset(&b[ix], check_indentation_char(Opts), ctx.depth);
 2163|    106|                     ix += ctx.depth;
 2164|    106|                     std::memcpy(&b[ix], "}", 1);
 2165|    106|                     ++ix;
 2166|    106|                  }
 2167|    106|                  else {
 2168|    106|                     dump('}', b, ix);
 2169|    106|                  }
 2170|    106|               }
 2171|    106|               else {
 2172|    106|                  to<JSON, V>::template op<Opts>(val, ctx, b, ix);
 2173|    106|               }
 2174|    106|            },
 2175|    106|            value);
 2176|    106|      }
_ZZN3glz2toILj10ENSt3__17variantIJNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEN12jsonrpc_fuzz6amountEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS8_RSB_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_ENKUlOT_E_clISF_EEDaSS_:
 1957|    106|            [&](auto&& val) {
 1958|    106|               using V = std::decay_t<decltype(val)>;
 1959|       |
 1960|       |               if constexpr (check_write_type_info(Opts) && tagging == variant_tagging_kind::internal &&
 1961|       |                             custom_write<V>) {
 1962|       |                  // Custom alternative: the user's serializer emits the object body, into which we
 1963|       |                  // merge the variant tag. For this to produce valid JSON the custom to<> must (1)
 1964|       |                  // write an object body and (2) honor opening_and_closing_handled (suppress its own
 1965|       |                  // braces) so the tag shares the alternative's object. A custom writer that emits a
 1966|       |                  // scalar/array, or that ignores those flags, would yield malformed output.
 1967|       |                  //
 1968|       |                  // The tag-emission below mirrors the reflected-object branch that follows; keep the
 1969|       |                  // two in sync. The body size is not known at compile time, so we always write the
 1970|       |                  // tag separator and then drop it at runtime if the body turned out empty.
 1971|       |                  if (missing_id(value, ctx)) {
 1972|       |                     return;
 1973|       |                  }
 1974|       |                  using id_type = std::decay_t<decltype(ids_v<T>[value.index()])>;
 1975|       |                  if constexpr (Opts.prettify) {
 1976|       |                     dump("{\n", b, ix);
 1977|       |                     ctx.depth += check_indentation_width(Opts);
 1978|       |                     dumpn(check_indentation_char(Opts), ctx.depth, b, ix);
 1979|       |                     dump('"', b, ix);
 1980|       |                     dump_maybe_empty(tag_v<T>, b, ix);
 1981|       |                     if constexpr (std::integral<id_type>) {
 1982|       |                        dump("\": ", b, ix);
 1983|       |                        serialize<JSON>::op<Opts>(ids_v<T>[value.index()], ctx, b, ix);
 1984|       |                     }
 1985|       |                     else {
 1986|       |                        dump("\": \"", b, ix);
 1987|       |                        dump_maybe_empty(ids_v<T>[value.index()], b, ix);
 1988|       |                        dump('"', b, ix);
 1989|       |                     }
 1990|       |                     const auto pos_after_tag = ix;
 1991|       |                     dump(",\n", b, ix);
 1992|       |                     dumpn(check_indentation_char(Opts), ctx.depth, b, ix);
 1993|       |                     const auto pos_body_start = ix;
 1994|       |                     to<JSON, V>::template op<opening_and_closing_handled<Opts>()>(val, ctx, b, ix);
 1995|       |                     if (ix == pos_body_start) {
 1996|       |                        ix = pos_after_tag; // custom body was empty: undo the tag separator
 1997|       |                     }
 1998|       |                     ctx.depth -= check_indentation_width(Opts);
 1999|       |                     if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] {
 2000|       |                        return;
 2001|       |                     }
 2002|       |                     std::memcpy(&b[ix], "\n", 1);
 2003|       |                     ++ix;
 2004|       |                     std::memset(&b[ix], check_indentation_char(Opts), ctx.depth);
 2005|       |                     ix += ctx.depth;
 2006|       |                     std::memcpy(&b[ix], "}", 1);
 2007|       |                     ++ix;
 2008|       |                  }
 2009|       |                  else {
 2010|       |                     dump("{\"", b, ix);
 2011|       |                     dump_maybe_empty(tag_v<T>, b, ix);
 2012|       |                     if constexpr (std::integral<id_type>) {
 2013|       |                        dump("\":", b, ix);
 2014|       |                        serialize<JSON>::op<Opts>(ids_v<T>[value.index()], ctx, b, ix);
 2015|       |                     }
 2016|       |                     else {
 2017|       |                        dump("\":\"", b, ix);
 2018|       |                        dump_maybe_empty(ids_v<T>[value.index()], b, ix);
 2019|       |                        dump('"', b, ix);
 2020|       |                     }
 2021|       |                     const auto pos_after_tag = ix;
 2022|       |                     dump(',', b, ix);
 2023|       |                     const auto pos_body_start = ix;
 2024|       |                     to<JSON, V>::template op<opening_and_closing_handled<Opts>()>(val, ctx, b, ix);
 2025|       |                     if (ix == pos_body_start) {
 2026|       |                        ix = pos_after_tag; // custom body was empty: undo the tag separator
 2027|       |                     }
 2028|       |                     dump('}', b, ix);
 2029|       |                  }
 2030|       |               }
 2031|       |               else if constexpr (check_write_type_info(Opts) && tagging == variant_tagging_kind::internal &&
 2032|       |                                  variant_unit_alternative<V>) {
 2033|       |                  // A unit alternative carries no data, so internal tagging renders it as the
 2034|       |                  // discriminator alone -- the same object an empty struct alternative produces.
 2035|       |                  if (missing_id(value, ctx)) {
 2036|       |                     return;
 2037|       |                  }
 2038|       |                  if constexpr (Opts.prettify) {
 2039|       |                     dump("{\n", b, ix);
 2040|       |                     ctx.depth += check_indentation_width(Opts);
 2041|       |                     dumpn(check_indentation_char(Opts), ctx.depth, b, ix);
 2042|       |                     dump('"', b, ix);
 2043|       |                     dump_maybe_empty(tag_v<T>, b, ix);
 2044|       |                     dump("\": ", b, ix);
 2045|       |                     write_id<Opts>(value, ctx, b, ix);
 2046|       |                     ctx.depth -= check_indentation_width(Opts);
 2047|       |                     if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] {
 2048|       |                        return;
 2049|       |                     }
 2050|       |                     std::memcpy(&b[ix], "\n", 1);
 2051|       |                     ++ix;
 2052|       |                     std::memset(&b[ix], check_indentation_char(Opts), ctx.depth);
 2053|       |                     ix += ctx.depth;
 2054|       |                     std::memcpy(&b[ix], "}", 1);
 2055|       |                     ++ix;
 2056|       |                  }
 2057|       |                  else {
 2058|       |                     dump("{\"", b, ix);
 2059|       |                     dump_maybe_empty(tag_v<T>, b, ix);
 2060|       |                     dump("\":", b, ix);
 2061|       |                     write_id<Opts>(value, ctx, b, ix);
 2062|       |                     dump('}', b, ix);
 2063|       |                  }
 2064|       |               }
 2065|       |               else if constexpr (check_write_type_info(Opts) && tagging == variant_tagging_kind::internal &&
 2066|       |                                  (glaze_object_t<V> || reflectable<V> || is_memory_object<V>) &&
 2067|       |                                  (not alternative_declares_key<V>(tag_v<T>))) {
 2068|       |                  // An alternative that declares a member named like the discriminator carries the
 2069|       |                  // discriminator itself, so no tag is merged here and the bare-write branch below
 2070|       |                  // handles it. Previously only `reflectable` alternatives were excluded; a
 2071|       |                  // `glaze_object_t` one fell through to this branch and emitted the key twice.
 2072|       |                  if (missing_id(value, ctx)) {
 2073|       |                     return;
 2074|       |                  }
 2075|       |                  constexpr auto N = []() {
 2076|       |                     if constexpr (is_memory_object<V>) {
 2077|       |                        return reflect<memory_type<V>>::size;
 2078|       |                     }
 2079|       |                     else {
 2080|       |                        return reflect<V>::size;
 2081|       |                     }
 2082|       |                  }();
 2083|       |
 2084|       |                  // must first write out type
 2085|       |                  if constexpr (Opts.prettify) {
 2086|       |                     dump("{\n", b, ix);
 2087|       |                     ctx.depth += check_indentation_width(Opts);
 2088|       |                     dumpn(check_indentation_char(Opts), ctx.depth, b, ix);
 2089|       |                     dump('"', b, ix);
 2090|       |                     dump_maybe_empty(tag_v<T>, b, ix);
 2091|       |
 2092|       |                     using id_type = std::decay_t<decltype(ids_v<T>[value.index()])>;
 2093|       |
 2094|       |                     if constexpr (std::integral<id_type>) {
 2095|       |                        dump("\": ", b, ix);
 2096|       |                        serialize<JSON>::op<Opts>(ids_v<T>[value.index()], ctx, b, ix);
 2097|       |                        if constexpr (N > 0) {
 2098|       |                           dump(",\n", b, ix);
 2099|       |                           dumpn(check_indentation_char(Opts), ctx.depth, b, ix);
 2100|       |                        }
 2101|       |                     }
 2102|       |                     else {
 2103|       |                        dump("\": \"", b, ix);
 2104|       |                        dump_maybe_empty(ids_v<T>[value.index()], b, ix);
 2105|       |                        if constexpr (N == 0) {
 2106|       |                           dump('"', b, ix);
 2107|       |                        }
 2108|       |                        else {
 2109|       |                           dump("\",\n", b, ix);
 2110|       |                           dumpn(check_indentation_char(Opts), ctx.depth, b, ix);
 2111|       |                        }
 2112|       |                     }
 2113|       |                  }
 2114|       |                  else {
 2115|       |                     using id_type = std::decay_t<decltype(ids_v<T>[value.index()])>;
 2116|       |
 2117|       |                     dump("{\"", b, ix);
 2118|       |                     dump_maybe_empty(tag_v<T>, b, ix);
 2119|       |
 2120|       |                     if constexpr (std::integral<id_type>) {
 2121|       |                        dump("\":", b, ix);
 2122|       |                        serialize<JSON>::op<Opts>(ids_v<T>[value.index()], ctx, b, ix);
 2123|       |                        if constexpr (N > 0) {
 2124|       |                           dump(',', b, ix);
 2125|       |                        }
 2126|       |                     }
 2127|       |                     else {
 2128|       |                        dump("\":\"", b, ix);
 2129|       |                        dump_maybe_empty(ids_v<T>[value.index()], b, ix);
 2130|       |                        if constexpr (N == 0) {
 2131|       |                           dump('"', b, ix);
 2132|       |                        }
 2133|       |                        else {
 2134|       |                           dump("\",", b, ix);
 2135|       |                        }
 2136|       |                     }
 2137|       |                  }
 2138|       |                  if constexpr (is_memory_object<V>) {
 2139|       |                     if (!val) [[unlikely]] {
 2140|       |                        ctx.error = error_code::invalid_variant_object;
 2141|       |                        return;
 2142|       |                     }
 2143|       |                     to<JSON, memory_type<V>>::template op<opening_and_closing_handled<Opts>()>(*val, ctx, b, ix);
 2144|       |                  }
 2145|       |                  else {
 2146|       |                     to<JSON, V>::template op<opening_and_closing_handled<Opts>()>(val, ctx, b, ix);
 2147|       |                  }
 2148|       |                  // If we skip everything then we may have an extra comma, which we want to revert
 2149|       |                  if constexpr (Opts.skip_null_members) {
 2150|       |                     if (b[ix - 1] == ',') {
 2151|       |                        --ix;
 2152|       |                     }
 2153|       |                  }
 2154|       |
 2155|       |                  if constexpr (Opts.prettify) {
 2156|       |                     ctx.depth -= check_indentation_width(Opts);
 2157|       |                     if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] {
 2158|       |                        return;
 2159|       |                     }
 2160|       |                     std::memcpy(&b[ix], "\n", 1);
 2161|       |                     ++ix;
 2162|       |                     std::memset(&b[ix], check_indentation_char(Opts), ctx.depth);
 2163|       |                     ix += ctx.depth;
 2164|       |                     std::memcpy(&b[ix], "}", 1);
 2165|       |                     ++ix;
 2166|       |                  }
 2167|       |                  else {
 2168|       |                     dump('}', b, ix);
 2169|       |                  }
 2170|       |               }
 2171|    106|               else {
 2172|    106|                  to<JSON, V>::template op<Opts>(val, ctx, b, ix);
 2173|    106|               }
 2174|    106|            },
_ZZN3glz2toILj10EN12jsonrpc_fuzz8fuzz_apiEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlTnmvE_clILm8EEEDav:
 2539|     43|               for_each<N>([&]<size_t I>() {
 2540|     43|                  using val_t = field_t<T, I>;
 2541|       |
 2542|       |                  // `meta<T>::skip` joins the other compile-time exclusions here rather than returning
 2543|       |                  // early, so that a skipped field's writer is never instantiated -- see
 2544|       |                  // `skipped_by_meta`.
 2545|     43|                  constexpr bool write_function_pointers = check_write_function_pointers(Opts);
 2546|       |                  if constexpr (skipped_by_meta<T, I, operation::serialize> || always_skipped<val_t> ||
 2547|       |                                (!write_function_pointers && is_any_function_ptr<val_t>)) {
 2548|       |                     return;
 2549|       |                  }
 2550|     43|                  else {
 2551|       |                     if constexpr (meta_has_skip_if<T>) {
 2552|       |                        static constexpr auto skip_if_key = glz::get<I>(reflect<T>::keys);
 2553|       |                        static constexpr meta_context mctx{.op = operation::serialize};
 2554|       |                        decltype(auto) field_value = [&]() -> decltype(auto) {
 2555|       |                           if constexpr (reflectable<T>) {
 2556|       |                              return get<I>(t);
 2557|       |                           }
 2558|       |                           else {
 2559|       |                              return get_member(value, glz::get<I>(reflect<T>::values));
 2560|       |                           }
 2561|       |                        }();
 2562|       |                        if (meta<T>::skip_if(field_value, skip_if_key, mctx)) return;
 2563|       |                     }
 2564|       |
 2565|       |                     if constexpr (null_t<val_t> && Opts.skip_null_members) {
 2566|       |                        if constexpr (always_null_t<val_t>)
 2567|       |                           return;
 2568|       |                        else {
 2569|       |                           const auto is_null = [&]() {
 2570|       |                              decltype(auto) element = [&]() -> decltype(auto) {
 2571|       |                                 if constexpr (reflectable<T>) {
 2572|       |                                    return get<I>(t);
 2573|       |                                 }
 2574|       |                                 else {
 2575|       |                                    return get<I>(reflect<T>::values);
 2576|       |                                 }
 2577|       |                              };
 2578|       |
 2579|       |                              if constexpr (nullable_wrapper<val_t>) {
 2580|       |                                 return !bool(element()(value).val);
 2581|       |                              }
 2582|       |                              else if constexpr (nullable_value_t<val_t>) {
 2583|       |                                 return !get_member(value, element()).has_value();
 2584|       |                              }
 2585|       |                              else {
 2586|       |                                 return !bool(get_member(value, element()));
 2587|       |                              }
 2588|       |                           }();
 2589|       |                           if (is_null) return;
 2590|       |                        }
 2591|       |                     }
 2592|       |                     else if constexpr (is_specialization_v<val_t, custom_t> && Opts.skip_null_members &&
 2593|       |                                        custom_getter_returns_nullable<val_t>()) {
 2594|       |                        if (is_custom_field_null<T, I>(value, t, ctx)) return;
 2595|       |                     }
 2596|     43|                     else if constexpr (Opts.skip_null_members && glaze_value_is_nullable<val_t>()) {
 2597|     43|                        if (is_glaze_value_field_null<T, I>(value, t)) return;
 2598|     43|                     }
 2599|       |
 2600|       |                     if constexpr (check_skip_default_members(Opts) && has_skippable_default<val_t>) {
 2601|       |                        decltype(auto) member = [&]() -> decltype(auto) {
 2602|       |                           if constexpr (reflectable<T>) {
 2603|       |                              return get_member(value, get<I>(t));
 2604|       |                           }
 2605|       |                           else {
 2606|       |                              return get_member(value, get<I>(reflect<T>::values));
 2607|       |                           }
 2608|       |                        }();
 2609|       |                        if (is_default_value(member)) return;
 2610|       |                     }
 2611|       |
 2612|       |                     if constexpr (Opts.prettify) {
 2613|       |                        if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] {
 2614|       |                           return;
 2615|       |                        }
 2616|       |                     }
 2617|     43|                     else {
 2618|     43|                        if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] {
  ------------------
  |  Branch (2618:29): [True: 0, False: 43]
  ------------------
 2619|      0|                           return;
 2620|      0|                        }
 2621|     43|                     }
 2622|       |
 2623|     43|                     if (first) {
  ------------------
  |  Branch (2623:26): [True: 0, False: 43]
  ------------------
 2624|      0|                        first = false;
 2625|      0|                     }
 2626|     43|                     else {
 2627|       |                        // Null members may be skipped so we can't just write it out for all but the last member
 2628|       |                        if constexpr (Opts.prettify) {
 2629|       |                           std::memcpy(&b[ix], ",\n", 2);
 2630|       |                           ix += 2;
 2631|       |                           std::memset(&b[ix], check_indentation_char(Opts), ctx.depth);
 2632|       |                           ix += ctx.depth;
 2633|       |                        }
 2634|     43|                        else {
 2635|     43|                           std::memcpy(&b[ix], ",", 1);
 2636|     43|                           ++ix;
 2637|     43|                        }
 2638|       |                        if constexpr (is_output_streaming<B>) {
 2639|       |                           flush_buffer(b, ix);
 2640|       |                        }
 2641|     43|                     }
 2642|       |
 2643|       |                     // MSVC requires get<I> rather than keys[I]
 2644|     43|                     static constexpr auto key = glz::get<I>(reflect<T>::keys); // GCC 14 requires auto here
 2645|     43|                     static constexpr auto quoted_key = quoted_key_v<key, Opts.prettify>;
 2646|     43|                     static constexpr auto n = quoted_key.size();
 2647|     43|                     std::memcpy(&b[ix], quoted_key.data(), n);
 2648|     43|                     ix += n;
 2649|       |
 2650|     43|                     static constexpr auto check_opts = required_padding<val_t>() ? write_unchecked_on<Opts>() : Opts;
  ------------------
  |  Branch (2650:57): [Folded, False: 43]
  ------------------
 2651|     43|                     if constexpr (reflectable<T>) {
 2652|     43|                        to<JSON, val_t>::template op<check_opts>(get_member(value, get<I>(t)), ctx, b, ix);
 2653|       |                     }
 2654|       |                     else {
 2655|       |                        to<JSON, val_t>::template op<check_opts>(get_member(value, get<I>(reflect<T>::values)), ctx, b,
 2656|       |                                                                 ix);
 2657|       |                     }
 2658|     43|                  }
 2659|     43|               });
_ZN3glz2toILj10ENSt3__18functionIFiiEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERS4_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_:
 1279|     43|      {
 1280|     43|         static constexpr auto name = name_v<std::decay_t<decltype(value)>>;
 1281|     43|         constexpr auto n = name.size();
 1282|       |
 1283|     43|         if (!ensure_space(ctx, b, ix + 8 + n)) [[unlikely]] {
  ------------------
  |  Branch (1283:14): [True: 0, False: 43]
  ------------------
 1284|      0|            return;
 1285|      0|         }
 1286|       |
 1287|     43|         std::memcpy(&b[ix], "\"", 1);
 1288|     43|         ++ix;
 1289|     43|         if constexpr (not name.empty()) {
 1290|     43|            std::memcpy(&b[ix], name.data(), n);
 1291|     43|            ix += n;
 1292|     43|         }
 1293|     43|         std::memcpy(&b[ix], "\"", 1);
 1294|     43|         ++ix;
 1295|     43|      }
_ZZN3glz2toILj10EN12jsonrpc_fuzz8fuzz_apiEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlTnmvE_clILm9EEEDav:
 2539|     43|               for_each<N>([&]<size_t I>() {
 2540|     43|                  using val_t = field_t<T, I>;
 2541|       |
 2542|       |                  // `meta<T>::skip` joins the other compile-time exclusions here rather than returning
 2543|       |                  // early, so that a skipped field's writer is never instantiated -- see
 2544|       |                  // `skipped_by_meta`.
 2545|     43|                  constexpr bool write_function_pointers = check_write_function_pointers(Opts);
 2546|       |                  if constexpr (skipped_by_meta<T, I, operation::serialize> || always_skipped<val_t> ||
 2547|       |                                (!write_function_pointers && is_any_function_ptr<val_t>)) {
 2548|       |                     return;
 2549|       |                  }
 2550|     43|                  else {
 2551|       |                     if constexpr (meta_has_skip_if<T>) {
 2552|       |                        static constexpr auto skip_if_key = glz::get<I>(reflect<T>::keys);
 2553|       |                        static constexpr meta_context mctx{.op = operation::serialize};
 2554|       |                        decltype(auto) field_value = [&]() -> decltype(auto) {
 2555|       |                           if constexpr (reflectable<T>) {
 2556|       |                              return get<I>(t);
 2557|       |                           }
 2558|       |                           else {
 2559|       |                              return get_member(value, glz::get<I>(reflect<T>::values));
 2560|       |                           }
 2561|       |                        }();
 2562|       |                        if (meta<T>::skip_if(field_value, skip_if_key, mctx)) return;
 2563|       |                     }
 2564|       |
 2565|       |                     if constexpr (null_t<val_t> && Opts.skip_null_members) {
 2566|       |                        if constexpr (always_null_t<val_t>)
 2567|       |                           return;
 2568|       |                        else {
 2569|       |                           const auto is_null = [&]() {
 2570|       |                              decltype(auto) element = [&]() -> decltype(auto) {
 2571|       |                                 if constexpr (reflectable<T>) {
 2572|       |                                    return get<I>(t);
 2573|       |                                 }
 2574|       |                                 else {
 2575|       |                                    return get<I>(reflect<T>::values);
 2576|       |                                 }
 2577|       |                              };
 2578|       |
 2579|       |                              if constexpr (nullable_wrapper<val_t>) {
 2580|       |                                 return !bool(element()(value).val);
 2581|       |                              }
 2582|       |                              else if constexpr (nullable_value_t<val_t>) {
 2583|       |                                 return !get_member(value, element()).has_value();
 2584|       |                              }
 2585|       |                              else {
 2586|       |                                 return !bool(get_member(value, element()));
 2587|       |                              }
 2588|       |                           }();
 2589|       |                           if (is_null) return;
 2590|       |                        }
 2591|       |                     }
 2592|       |                     else if constexpr (is_specialization_v<val_t, custom_t> && Opts.skip_null_members &&
 2593|       |                                        custom_getter_returns_nullable<val_t>()) {
 2594|       |                        if (is_custom_field_null<T, I>(value, t, ctx)) return;
 2595|       |                     }
 2596|     43|                     else if constexpr (Opts.skip_null_members && glaze_value_is_nullable<val_t>()) {
 2597|     43|                        if (is_glaze_value_field_null<T, I>(value, t)) return;
 2598|     43|                     }
 2599|       |
 2600|       |                     if constexpr (check_skip_default_members(Opts) && has_skippable_default<val_t>) {
 2601|       |                        decltype(auto) member = [&]() -> decltype(auto) {
 2602|       |                           if constexpr (reflectable<T>) {
 2603|       |                              return get_member(value, get<I>(t));
 2604|       |                           }
 2605|       |                           else {
 2606|       |                              return get_member(value, get<I>(reflect<T>::values));
 2607|       |                           }
 2608|       |                        }();
 2609|       |                        if (is_default_value(member)) return;
 2610|       |                     }
 2611|       |
 2612|       |                     if constexpr (Opts.prettify) {
 2613|       |                        if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] {
 2614|       |                           return;
 2615|       |                        }
 2616|       |                     }
 2617|     43|                     else {
 2618|     43|                        if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] {
  ------------------
  |  Branch (2618:29): [True: 0, False: 43]
  ------------------
 2619|      0|                           return;
 2620|      0|                        }
 2621|     43|                     }
 2622|       |
 2623|     43|                     if (first) {
  ------------------
  |  Branch (2623:26): [True: 0, False: 43]
  ------------------
 2624|      0|                        first = false;
 2625|      0|                     }
 2626|     43|                     else {
 2627|       |                        // Null members may be skipped so we can't just write it out for all but the last member
 2628|       |                        if constexpr (Opts.prettify) {
 2629|       |                           std::memcpy(&b[ix], ",\n", 2);
 2630|       |                           ix += 2;
 2631|       |                           std::memset(&b[ix], check_indentation_char(Opts), ctx.depth);
 2632|       |                           ix += ctx.depth;
 2633|       |                        }
 2634|     43|                        else {
 2635|     43|                           std::memcpy(&b[ix], ",", 1);
 2636|     43|                           ++ix;
 2637|     43|                        }
 2638|       |                        if constexpr (is_output_streaming<B>) {
 2639|       |                           flush_buffer(b, ix);
 2640|       |                        }
 2641|     43|                     }
 2642|       |
 2643|       |                     // MSVC requires get<I> rather than keys[I]
 2644|     43|                     static constexpr auto key = glz::get<I>(reflect<T>::keys); // GCC 14 requires auto here
 2645|     43|                     static constexpr auto quoted_key = quoted_key_v<key, Opts.prettify>;
 2646|     43|                     static constexpr auto n = quoted_key.size();
 2647|     43|                     std::memcpy(&b[ix], quoted_key.data(), n);
 2648|     43|                     ix += n;
 2649|       |
 2650|     43|                     static constexpr auto check_opts = required_padding<val_t>() ? write_unchecked_on<Opts>() : Opts;
  ------------------
  |  Branch (2650:57): [Folded, False: 43]
  ------------------
 2651|     43|                     if constexpr (reflectable<T>) {
 2652|     43|                        to<JSON, val_t>::template op<check_opts>(get_member(value, get<I>(t)), ctx, b, ix);
 2653|       |                     }
 2654|       |                     else {
 2655|       |                        to<JSON, val_t>::template op<check_opts>(get_member(value, get<I>(reflect<T>::values)), ctx, b,
 2656|       |                                                                 ix);
 2657|       |                     }
 2658|     43|                  }
 2659|     43|               });
_ZN3glz2toILj10ENSt3__18functionIFNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERKS8_EEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS8_RSC_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_:
 1279|     43|      {
 1280|     43|         static constexpr auto name = name_v<std::decay_t<decltype(value)>>;
 1281|     43|         constexpr auto n = name.size();
 1282|       |
 1283|     43|         if (!ensure_space(ctx, b, ix + 8 + n)) [[unlikely]] {
  ------------------
  |  Branch (1283:14): [True: 0, False: 43]
  ------------------
 1284|      0|            return;
 1285|      0|         }
 1286|       |
 1287|     43|         std::memcpy(&b[ix], "\"", 1);
 1288|     43|         ++ix;
 1289|     43|         if constexpr (not name.empty()) {
 1290|     43|            std::memcpy(&b[ix], name.data(), n);
 1291|     43|            ix += n;
 1292|     43|         }
 1293|     43|         std::memcpy(&b[ix], "\"", 1);
 1294|     43|         ++ix;
 1295|     43|      }
_ZZN3glz2toILj10EN12jsonrpc_fuzz8fuzz_apiEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlTnmvE_clILm10EEEDav:
 2539|     43|               for_each<N>([&]<size_t I>() {
 2540|     43|                  using val_t = field_t<T, I>;
 2541|       |
 2542|       |                  // `meta<T>::skip` joins the other compile-time exclusions here rather than returning
 2543|       |                  // early, so that a skipped field's writer is never instantiated -- see
 2544|       |                  // `skipped_by_meta`.
 2545|     43|                  constexpr bool write_function_pointers = check_write_function_pointers(Opts);
 2546|       |                  if constexpr (skipped_by_meta<T, I, operation::serialize> || always_skipped<val_t> ||
 2547|       |                                (!write_function_pointers && is_any_function_ptr<val_t>)) {
 2548|       |                     return;
 2549|       |                  }
 2550|     43|                  else {
 2551|       |                     if constexpr (meta_has_skip_if<T>) {
 2552|       |                        static constexpr auto skip_if_key = glz::get<I>(reflect<T>::keys);
 2553|       |                        static constexpr meta_context mctx{.op = operation::serialize};
 2554|       |                        decltype(auto) field_value = [&]() -> decltype(auto) {
 2555|       |                           if constexpr (reflectable<T>) {
 2556|       |                              return get<I>(t);
 2557|       |                           }
 2558|       |                           else {
 2559|       |                              return get_member(value, glz::get<I>(reflect<T>::values));
 2560|       |                           }
 2561|       |                        }();
 2562|       |                        if (meta<T>::skip_if(field_value, skip_if_key, mctx)) return;
 2563|       |                     }
 2564|       |
 2565|       |                     if constexpr (null_t<val_t> && Opts.skip_null_members) {
 2566|       |                        if constexpr (always_null_t<val_t>)
 2567|       |                           return;
 2568|       |                        else {
 2569|       |                           const auto is_null = [&]() {
 2570|       |                              decltype(auto) element = [&]() -> decltype(auto) {
 2571|       |                                 if constexpr (reflectable<T>) {
 2572|       |                                    return get<I>(t);
 2573|       |                                 }
 2574|       |                                 else {
 2575|       |                                    return get<I>(reflect<T>::values);
 2576|       |                                 }
 2577|       |                              };
 2578|       |
 2579|       |                              if constexpr (nullable_wrapper<val_t>) {
 2580|       |                                 return !bool(element()(value).val);
 2581|       |                              }
 2582|       |                              else if constexpr (nullable_value_t<val_t>) {
 2583|       |                                 return !get_member(value, element()).has_value();
 2584|       |                              }
 2585|       |                              else {
 2586|       |                                 return !bool(get_member(value, element()));
 2587|       |                              }
 2588|       |                           }();
 2589|       |                           if (is_null) return;
 2590|       |                        }
 2591|       |                     }
 2592|       |                     else if constexpr (is_specialization_v<val_t, custom_t> && Opts.skip_null_members &&
 2593|       |                                        custom_getter_returns_nullable<val_t>()) {
 2594|       |                        if (is_custom_field_null<T, I>(value, t, ctx)) return;
 2595|       |                     }
 2596|     43|                     else if constexpr (Opts.skip_null_members && glaze_value_is_nullable<val_t>()) {
 2597|     43|                        if (is_glaze_value_field_null<T, I>(value, t)) return;
 2598|     43|                     }
 2599|       |
 2600|       |                     if constexpr (check_skip_default_members(Opts) && has_skippable_default<val_t>) {
 2601|       |                        decltype(auto) member = [&]() -> decltype(auto) {
 2602|       |                           if constexpr (reflectable<T>) {
 2603|       |                              return get_member(value, get<I>(t));
 2604|       |                           }
 2605|       |                           else {
 2606|       |                              return get_member(value, get<I>(reflect<T>::values));
 2607|       |                           }
 2608|       |                        }();
 2609|       |                        if (is_default_value(member)) return;
 2610|       |                     }
 2611|       |
 2612|       |                     if constexpr (Opts.prettify) {
 2613|       |                        if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] {
 2614|       |                           return;
 2615|       |                        }
 2616|       |                     }
 2617|     43|                     else {
 2618|     43|                        if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] {
  ------------------
  |  Branch (2618:29): [True: 0, False: 43]
  ------------------
 2619|      0|                           return;
 2620|      0|                        }
 2621|     43|                     }
 2622|       |
 2623|     43|                     if (first) {
  ------------------
  |  Branch (2623:26): [True: 0, False: 43]
  ------------------
 2624|      0|                        first = false;
 2625|      0|                     }
 2626|     43|                     else {
 2627|       |                        // Null members may be skipped so we can't just write it out for all but the last member
 2628|       |                        if constexpr (Opts.prettify) {
 2629|       |                           std::memcpy(&b[ix], ",\n", 2);
 2630|       |                           ix += 2;
 2631|       |                           std::memset(&b[ix], check_indentation_char(Opts), ctx.depth);
 2632|       |                           ix += ctx.depth;
 2633|       |                        }
 2634|     43|                        else {
 2635|     43|                           std::memcpy(&b[ix], ",", 1);
 2636|     43|                           ++ix;
 2637|     43|                        }
 2638|       |                        if constexpr (is_output_streaming<B>) {
 2639|       |                           flush_buffer(b, ix);
 2640|       |                        }
 2641|     43|                     }
 2642|       |
 2643|       |                     // MSVC requires get<I> rather than keys[I]
 2644|     43|                     static constexpr auto key = glz::get<I>(reflect<T>::keys); // GCC 14 requires auto here
 2645|     43|                     static constexpr auto quoted_key = quoted_key_v<key, Opts.prettify>;
 2646|     43|                     static constexpr auto n = quoted_key.size();
 2647|     43|                     std::memcpy(&b[ix], quoted_key.data(), n);
 2648|     43|                     ix += n;
 2649|       |
 2650|     43|                     static constexpr auto check_opts = required_padding<val_t>() ? write_unchecked_on<Opts>() : Opts;
  ------------------
  |  Branch (2650:57): [Folded, False: 43]
  ------------------
 2651|     43|                     if constexpr (reflectable<T>) {
 2652|     43|                        to<JSON, val_t>::template op<check_opts>(get_member(value, get<I>(t)), ctx, b, ix);
 2653|       |                     }
 2654|       |                     else {
 2655|       |                        to<JSON, val_t>::template op<check_opts>(get_member(value, get<I>(reflect<T>::values)), ctx, b,
 2656|       |                                                                 ix);
 2657|       |                     }
 2658|     43|                  }
 2659|     43|               });
_ZN3glz2toILj10ENSt3__18functionIFN12jsonrpc_fuzz5pointERKS4_EEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERS8_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_:
 1279|     43|      {
 1280|     43|         static constexpr auto name = name_v<std::decay_t<decltype(value)>>;
 1281|     43|         constexpr auto n = name.size();
 1282|       |
 1283|     43|         if (!ensure_space(ctx, b, ix + 8 + n)) [[unlikely]] {
  ------------------
  |  Branch (1283:14): [True: 0, False: 43]
  ------------------
 1284|      0|            return;
 1285|      0|         }
 1286|       |
 1287|     43|         std::memcpy(&b[ix], "\"", 1);
 1288|     43|         ++ix;
 1289|     43|         if constexpr (not name.empty()) {
 1290|     43|            std::memcpy(&b[ix], name.data(), n);
 1291|     43|            ix += n;
 1292|     43|         }
 1293|     43|         std::memcpy(&b[ix], "\"", 1);
 1294|     43|         ++ix;
 1295|     43|      }
_ZZN3glz2toILj10EN12jsonrpc_fuzz8fuzz_apiEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlTnmvE_clILm11EEEDav:
 2539|     43|               for_each<N>([&]<size_t I>() {
 2540|     43|                  using val_t = field_t<T, I>;
 2541|       |
 2542|       |                  // `meta<T>::skip` joins the other compile-time exclusions here rather than returning
 2543|       |                  // early, so that a skipped field's writer is never instantiated -- see
 2544|       |                  // `skipped_by_meta`.
 2545|     43|                  constexpr bool write_function_pointers = check_write_function_pointers(Opts);
 2546|       |                  if constexpr (skipped_by_meta<T, I, operation::serialize> || always_skipped<val_t> ||
 2547|       |                                (!write_function_pointers && is_any_function_ptr<val_t>)) {
 2548|       |                     return;
 2549|       |                  }
 2550|     43|                  else {
 2551|       |                     if constexpr (meta_has_skip_if<T>) {
 2552|       |                        static constexpr auto skip_if_key = glz::get<I>(reflect<T>::keys);
 2553|       |                        static constexpr meta_context mctx{.op = operation::serialize};
 2554|       |                        decltype(auto) field_value = [&]() -> decltype(auto) {
 2555|       |                           if constexpr (reflectable<T>) {
 2556|       |                              return get<I>(t);
 2557|       |                           }
 2558|       |                           else {
 2559|       |                              return get_member(value, glz::get<I>(reflect<T>::values));
 2560|       |                           }
 2561|       |                        }();
 2562|       |                        if (meta<T>::skip_if(field_value, skip_if_key, mctx)) return;
 2563|       |                     }
 2564|       |
 2565|       |                     if constexpr (null_t<val_t> && Opts.skip_null_members) {
 2566|       |                        if constexpr (always_null_t<val_t>)
 2567|       |                           return;
 2568|       |                        else {
 2569|       |                           const auto is_null = [&]() {
 2570|       |                              decltype(auto) element = [&]() -> decltype(auto) {
 2571|       |                                 if constexpr (reflectable<T>) {
 2572|       |                                    return get<I>(t);
 2573|       |                                 }
 2574|       |                                 else {
 2575|       |                                    return get<I>(reflect<T>::values);
 2576|       |                                 }
 2577|       |                              };
 2578|       |
 2579|       |                              if constexpr (nullable_wrapper<val_t>) {
 2580|       |                                 return !bool(element()(value).val);
 2581|       |                              }
 2582|       |                              else if constexpr (nullable_value_t<val_t>) {
 2583|       |                                 return !get_member(value, element()).has_value();
 2584|       |                              }
 2585|       |                              else {
 2586|       |                                 return !bool(get_member(value, element()));
 2587|       |                              }
 2588|       |                           }();
 2589|       |                           if (is_null) return;
 2590|       |                        }
 2591|       |                     }
 2592|       |                     else if constexpr (is_specialization_v<val_t, custom_t> && Opts.skip_null_members &&
 2593|       |                                        custom_getter_returns_nullable<val_t>()) {
 2594|       |                        if (is_custom_field_null<T, I>(value, t, ctx)) return;
 2595|       |                     }
 2596|     43|                     else if constexpr (Opts.skip_null_members && glaze_value_is_nullable<val_t>()) {
 2597|     43|                        if (is_glaze_value_field_null<T, I>(value, t)) return;
 2598|     43|                     }
 2599|       |
 2600|       |                     if constexpr (check_skip_default_members(Opts) && has_skippable_default<val_t>) {
 2601|       |                        decltype(auto) member = [&]() -> decltype(auto) {
 2602|       |                           if constexpr (reflectable<T>) {
 2603|       |                              return get_member(value, get<I>(t));
 2604|       |                           }
 2605|       |                           else {
 2606|       |                              return get_member(value, get<I>(reflect<T>::values));
 2607|       |                           }
 2608|       |                        }();
 2609|       |                        if (is_default_value(member)) return;
 2610|       |                     }
 2611|       |
 2612|       |                     if constexpr (Opts.prettify) {
 2613|       |                        if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] {
 2614|       |                           return;
 2615|       |                        }
 2616|       |                     }
 2617|     43|                     else {
 2618|     43|                        if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] {
  ------------------
  |  Branch (2618:29): [True: 0, False: 43]
  ------------------
 2619|      0|                           return;
 2620|      0|                        }
 2621|     43|                     }
 2622|       |
 2623|     43|                     if (first) {
  ------------------
  |  Branch (2623:26): [True: 0, False: 43]
  ------------------
 2624|      0|                        first = false;
 2625|      0|                     }
 2626|     43|                     else {
 2627|       |                        // Null members may be skipped so we can't just write it out for all but the last member
 2628|       |                        if constexpr (Opts.prettify) {
 2629|       |                           std::memcpy(&b[ix], ",\n", 2);
 2630|       |                           ix += 2;
 2631|       |                           std::memset(&b[ix], check_indentation_char(Opts), ctx.depth);
 2632|       |                           ix += ctx.depth;
 2633|       |                        }
 2634|     43|                        else {
 2635|     43|                           std::memcpy(&b[ix], ",", 1);
 2636|     43|                           ++ix;
 2637|     43|                        }
 2638|       |                        if constexpr (is_output_streaming<B>) {
 2639|       |                           flush_buffer(b, ix);
 2640|       |                        }
 2641|     43|                     }
 2642|       |
 2643|       |                     // MSVC requires get<I> rather than keys[I]
 2644|     43|                     static constexpr auto key = glz::get<I>(reflect<T>::keys); // GCC 14 requires auto here
 2645|     43|                     static constexpr auto quoted_key = quoted_key_v<key, Opts.prettify>;
 2646|     43|                     static constexpr auto n = quoted_key.size();
 2647|     43|                     std::memcpy(&b[ix], quoted_key.data(), n);
 2648|     43|                     ix += n;
 2649|       |
 2650|     43|                     static constexpr auto check_opts = required_padding<val_t>() ? write_unchecked_on<Opts>() : Opts;
  ------------------
  |  Branch (2650:57): [Folded, False: 43]
  ------------------
 2651|     43|                     if constexpr (reflectable<T>) {
 2652|     43|                        to<JSON, val_t>::template op<check_opts>(get_member(value, get<I>(t)), ctx, b, ix);
 2653|       |                     }
 2654|       |                     else {
 2655|       |                        to<JSON, val_t>::template op<check_opts>(get_member(value, get<I>(reflect<T>::values)), ctx, b,
 2656|       |                                                                 ix);
 2657|       |                     }
 2658|     43|                  }
 2659|     43|               });
_ZN3glz2toILj10ENSt3__18functionIFdRNS1_6vectorIdNS1_9allocatorIdEEEEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNS1_12basic_stringIcNS1_11char_traitsIcEENS4_IcEEEERS9_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_:
 1279|     43|      {
 1280|     43|         static constexpr auto name = name_v<std::decay_t<decltype(value)>>;
 1281|     43|         constexpr auto n = name.size();
 1282|       |
 1283|     43|         if (!ensure_space(ctx, b, ix + 8 + n)) [[unlikely]] {
  ------------------
  |  Branch (1283:14): [True: 0, False: 43]
  ------------------
 1284|      0|            return;
 1285|      0|         }
 1286|       |
 1287|     43|         std::memcpy(&b[ix], "\"", 1);
 1288|     43|         ++ix;
 1289|     43|         if constexpr (not name.empty()) {
 1290|     43|            std::memcpy(&b[ix], name.data(), n);
 1291|     43|            ix += n;
 1292|     43|         }
 1293|     43|         std::memcpy(&b[ix], "\"", 1);
 1294|     43|         ++ix;
 1295|     43|      }
_ZZN3glz2toILj10EN12jsonrpc_fuzz8fuzz_apiEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlTnmvE_clILm12EEEDav:
 2539|     43|               for_each<N>([&]<size_t I>() {
 2540|     43|                  using val_t = field_t<T, I>;
 2541|       |
 2542|       |                  // `meta<T>::skip` joins the other compile-time exclusions here rather than returning
 2543|       |                  // early, so that a skipped field's writer is never instantiated -- see
 2544|       |                  // `skipped_by_meta`.
 2545|     43|                  constexpr bool write_function_pointers = check_write_function_pointers(Opts);
 2546|       |                  if constexpr (skipped_by_meta<T, I, operation::serialize> || always_skipped<val_t> ||
 2547|       |                                (!write_function_pointers && is_any_function_ptr<val_t>)) {
 2548|       |                     return;
 2549|       |                  }
 2550|     43|                  else {
 2551|       |                     if constexpr (meta_has_skip_if<T>) {
 2552|       |                        static constexpr auto skip_if_key = glz::get<I>(reflect<T>::keys);
 2553|       |                        static constexpr meta_context mctx{.op = operation::serialize};
 2554|       |                        decltype(auto) field_value = [&]() -> decltype(auto) {
 2555|       |                           if constexpr (reflectable<T>) {
 2556|       |                              return get<I>(t);
 2557|       |                           }
 2558|       |                           else {
 2559|       |                              return get_member(value, glz::get<I>(reflect<T>::values));
 2560|       |                           }
 2561|       |                        }();
 2562|       |                        if (meta<T>::skip_if(field_value, skip_if_key, mctx)) return;
 2563|       |                     }
 2564|       |
 2565|       |                     if constexpr (null_t<val_t> && Opts.skip_null_members) {
 2566|       |                        if constexpr (always_null_t<val_t>)
 2567|       |                           return;
 2568|       |                        else {
 2569|       |                           const auto is_null = [&]() {
 2570|       |                              decltype(auto) element = [&]() -> decltype(auto) {
 2571|       |                                 if constexpr (reflectable<T>) {
 2572|       |                                    return get<I>(t);
 2573|       |                                 }
 2574|       |                                 else {
 2575|       |                                    return get<I>(reflect<T>::values);
 2576|       |                                 }
 2577|       |                              };
 2578|       |
 2579|       |                              if constexpr (nullable_wrapper<val_t>) {
 2580|       |                                 return !bool(element()(value).val);
 2581|       |                              }
 2582|       |                              else if constexpr (nullable_value_t<val_t>) {
 2583|       |                                 return !get_member(value, element()).has_value();
 2584|       |                              }
 2585|       |                              else {
 2586|       |                                 return !bool(get_member(value, element()));
 2587|       |                              }
 2588|       |                           }();
 2589|       |                           if (is_null) return;
 2590|       |                        }
 2591|       |                     }
 2592|       |                     else if constexpr (is_specialization_v<val_t, custom_t> && Opts.skip_null_members &&
 2593|       |                                        custom_getter_returns_nullable<val_t>()) {
 2594|       |                        if (is_custom_field_null<T, I>(value, t, ctx)) return;
 2595|       |                     }
 2596|     43|                     else if constexpr (Opts.skip_null_members && glaze_value_is_nullable<val_t>()) {
 2597|     43|                        if (is_glaze_value_field_null<T, I>(value, t)) return;
 2598|     43|                     }
 2599|       |
 2600|       |                     if constexpr (check_skip_default_members(Opts) && has_skippable_default<val_t>) {
 2601|       |                        decltype(auto) member = [&]() -> decltype(auto) {
 2602|       |                           if constexpr (reflectable<T>) {
 2603|       |                              return get_member(value, get<I>(t));
 2604|       |                           }
 2605|       |                           else {
 2606|       |                              return get_member(value, get<I>(reflect<T>::values));
 2607|       |                           }
 2608|       |                        }();
 2609|       |                        if (is_default_value(member)) return;
 2610|       |                     }
 2611|       |
 2612|       |                     if constexpr (Opts.prettify) {
 2613|       |                        if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] {
 2614|       |                           return;
 2615|       |                        }
 2616|       |                     }
 2617|     43|                     else {
 2618|     43|                        if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] {
  ------------------
  |  Branch (2618:29): [True: 0, False: 43]
  ------------------
 2619|      0|                           return;
 2620|      0|                        }
 2621|     43|                     }
 2622|       |
 2623|     43|                     if (first) {
  ------------------
  |  Branch (2623:26): [True: 0, False: 43]
  ------------------
 2624|      0|                        first = false;
 2625|      0|                     }
 2626|     43|                     else {
 2627|       |                        // Null members may be skipped so we can't just write it out for all but the last member
 2628|       |                        if constexpr (Opts.prettify) {
 2629|       |                           std::memcpy(&b[ix], ",\n", 2);
 2630|       |                           ix += 2;
 2631|       |                           std::memset(&b[ix], check_indentation_char(Opts), ctx.depth);
 2632|       |                           ix += ctx.depth;
 2633|       |                        }
 2634|     43|                        else {
 2635|     43|                           std::memcpy(&b[ix], ",", 1);
 2636|     43|                           ++ix;
 2637|     43|                        }
 2638|       |                        if constexpr (is_output_streaming<B>) {
 2639|       |                           flush_buffer(b, ix);
 2640|       |                        }
 2641|     43|                     }
 2642|       |
 2643|       |                     // MSVC requires get<I> rather than keys[I]
 2644|     43|                     static constexpr auto key = glz::get<I>(reflect<T>::keys); // GCC 14 requires auto here
 2645|     43|                     static constexpr auto quoted_key = quoted_key_v<key, Opts.prettify>;
 2646|     43|                     static constexpr auto n = quoted_key.size();
 2647|     43|                     std::memcpy(&b[ix], quoted_key.data(), n);
 2648|     43|                     ix += n;
 2649|       |
 2650|     43|                     static constexpr auto check_opts = required_padding<val_t>() ? write_unchecked_on<Opts>() : Opts;
  ------------------
  |  Branch (2650:57): [Folded, False: 43]
  ------------------
 2651|     43|                     if constexpr (reflectable<T>) {
 2652|     43|                        to<JSON, val_t>::template op<check_opts>(get_member(value, get<I>(t)), ctx, b, ix);
 2653|       |                     }
 2654|       |                     else {
 2655|       |                        to<JSON, val_t>::template op<check_opts>(get_member(value, get<I>(reflect<T>::values)), ctx, b,
 2656|       |                                                                 ix);
 2657|       |                     }
 2658|     43|                  }
 2659|     43|               });
_ZN3glz2toILj10ENSt3__18functionIFvvEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERS4_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_:
 1279|     43|      {
 1280|     43|         static constexpr auto name = name_v<std::decay_t<decltype(value)>>;
 1281|     43|         constexpr auto n = name.size();
 1282|       |
 1283|     43|         if (!ensure_space(ctx, b, ix + 8 + n)) [[unlikely]] {
  ------------------
  |  Branch (1283:14): [True: 0, False: 43]
  ------------------
 1284|      0|            return;
 1285|      0|         }
 1286|       |
 1287|     43|         std::memcpy(&b[ix], "\"", 1);
 1288|     43|         ++ix;
 1289|     43|         if constexpr (not name.empty()) {
 1290|     43|            std::memcpy(&b[ix], name.data(), n);
 1291|     43|            ix += n;
 1292|     43|         }
 1293|     43|         std::memcpy(&b[ix], "\"", 1);
 1294|     43|         ++ix;
 1295|     43|      }
_ZN3glz2toILj10EdE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERdTkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_:
  814|  1.78k|      {
  815|  1.78k|         if constexpr (not check_write_unchecked(Opts)) {
  816|  1.78k|            static_assert(required_padding<T>());
  817|  1.78k|            if (!ensure_space(ctx, b, ix + required_padding<T>())) [[unlikely]] {
  ------------------
  |  Branch (817:17): [True: 0, False: 1.78k]
  ------------------
  818|      0|               return;
  819|      0|            }
  820|  1.78k|         }
  821|       |
  822|  1.78k|         static constexpr auto O = write_unchecked_on<Opts>();
  823|       |
  824|       |         if constexpr (check_quoted_num(Opts)) {
  825|       |            std::memcpy(&b[ix], "\"", 1);
  826|       |            ++ix;
  827|       |            write_chars::op<O>(value, ctx, b, ix);
  828|       |            std::memcpy(&b[ix], "\"", 1);
  829|       |            ++ix;
  830|       |         }
  831|  1.78k|         else {
  832|  1.78k|            write_chars::op<O>(value, ctx, b, ix);
  833|  1.78k|         }
  834|  1.78k|      }
_ZN3glz16required_paddingIdEEmv:
  538|  1.78k|   {
  539|  1.78k|      constexpr auto value = []() -> size_t {
  540|  1.78k|         if constexpr (boolean_like<T>) {
  541|  1.78k|            return 8;
  542|  1.78k|         }
  543|  1.78k|         else if constexpr (num_t<T>) {
  544|  1.78k|            if constexpr (std::floating_point<T>) {
  545|  1.78k|               if constexpr (sizeof(T) > 8) {
  546|  1.78k|                  return 64;
  547|  1.78k|               }
  548|  1.78k|               else if constexpr (sizeof(T) > 4) {
  549|       |                  // zmij scratch + 4 for optional quotes and trailing comma.
  550|  1.78k|                  return zmij::double_buffer_size + 4;
  551|  1.78k|               }
  552|  1.78k|               else {
  553|  1.78k|                  return zmij::float_buffer_size + 4;
  554|  1.78k|               }
  555|  1.78k|            }
  556|  1.78k|            else if constexpr (sizeof(T) > 4) {
  557|  1.78k|               return 24;
  558|  1.78k|            }
  559|  1.78k|            else if constexpr (sizeof(T) > 2) {
  560|  1.78k|               return 16;
  561|  1.78k|            }
  562|  1.78k|            else {
  563|  1.78k|               return 8;
  564|  1.78k|            }
  565|  1.78k|         }
  566|  1.78k|         else if constexpr (nullable_like<T>) {
  567|  1.78k|            if constexpr (has_value_type<T>) {
  568|  1.78k|               return required_padding<typename T::value_type>();
  569|  1.78k|            }
  570|  1.78k|            else if constexpr (has_element_type<T>) {
  571|  1.78k|               return required_padding<typename T::element_type>();
  572|  1.78k|            }
  573|  1.78k|            else {
  574|  1.78k|               return 0;
  575|  1.78k|            }
  576|  1.78k|         }
  577|  1.78k|         else if constexpr (always_null_t<T>) {
  578|  1.78k|            return 8;
  579|  1.78k|         }
  580|  1.78k|         else {
  581|  1.78k|            return 0;
  582|  1.78k|         }
  583|  1.78k|      }();
  584|       |
  585|       |      if constexpr (value >= (write_padding_bytes - 16)) {
  586|       |         // we always require 16 bytes available from write_padding_bytes
  587|       |         // for opening and closing characters
  588|       |         return 0;
  589|       |      }
  590|  1.78k|      return value;
  591|  1.78k|   }
_ZN3glz2toILj10ENSt3__18optionalIdEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS3_TkNS_10is_contextERNS_7contextERNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEmEEvOT0_OT1_OT2_RT3_:
 1805|     56|      {
 1806|     56|         if (value) {
  ------------------
  |  Branch (1806:14): [True: 0, False: 56]
  ------------------
 1807|      0|            if constexpr (required_padding<T>()) {
 1808|      0|               serialize<JSON>::op<Opts>(*value, ctx, b, ix);
 1809|       |            }
 1810|       |            else {
 1811|       |               serialize<JSON>::op<write_unchecked_off<Opts>()>(*value, ctx, b, ix);
 1812|       |            }
 1813|      0|         }
 1814|     56|         else {
 1815|     56|            dump<not check_write_unchecked(Opts)>("null", b, ix);
 1816|     56|         }
 1817|     56|      }
_ZN3glz10write_jsonITkNS_15write_supportedIL_ZNS_4JSONEEEENSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEENS2_8expectedIS8_NS_9error_ctxEEEOT_:
 2840|  4.09M|   {
 2841|  4.09M|      return write<opts{}>(std::forward<T>(value));
 2842|  4.09M|   }
_ZN3glz2toILj10ENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE2opITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERS7_S7_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_:
  845|  4.09M|      {
  846|       |         if constexpr (check_string_as_number(Opts)) {
  847|       |            const sv str = [&]() -> const sv {
  848|       |               if constexpr (array_char_t<T>) {
  849|       |                  const auto* start = value.data();
  850|       |                  const auto* end = static_cast<const char*>(std::memchr(start, '\0', value.size()));
  851|       |                  return sv{start, end ? size_t(end - start) : value.size()};
  852|       |               }
  853|       |               else if constexpr (u8str_t<T>) {
  854|       |                  return sv{reinterpret_cast<const char*>(value.data()), value.size()};
  855|       |               }
  856|       |               else {
  857|       |                  return str_view<T>(value);
  858|       |               }
  859|       |            }();
  860|       |            if (!ensure_space(ctx, b, ix + str.size() + write_padding_bytes)) [[unlikely]] {
  861|       |               return;
  862|       |            }
  863|       |            dump_maybe_empty<false>(str, b, ix);
  864|       |         }
  865|       |         else if constexpr (char_t<T>) {
  866|       |            if constexpr (check_unquoted(Opts)) {
  867|       |               dump(value, b, ix);
  868|       |            }
  869|       |            else {
  870|       |               // 8 bytes is enough for quotes and escaped character (worst case: \uXXXX = 6 + 2 quotes)
  871|       |               if (!ensure_space(ctx, b, ix + 8)) [[unlikely]] {
  872|       |                  return;
  873|       |               }
  874|       |
  875|       |               std::memcpy(&b[ix], "\"", 1);
  876|       |               ++ix;
  877|       |               if (const auto escaped = char_escape_table[uint8_t(value)]; escaped) {
  878|       |                  std::memcpy(&b[ix], &escaped, 2);
  879|       |                  ix += 2;
  880|       |               }
  881|       |               else if (value == '\0') {
  882|       |                  // null character treated as empty string
  883|       |               }
  884|       |               else if constexpr (check_escape_control_characters(Opts)) {
  885|       |                  if (uint8_t(value) < 0x20) {
  886|       |                     // Write as \uXXXX format
  887|       |                     char unicode_escape[6] = {'\\', 'u', '0', '0', '0', '0'};
  888|       |                     constexpr char hex_digits[] = "0123456789ABCDEF";
  889|       |                     unicode_escape[4] = hex_digits[(value >> 4) & 0xF];
  890|       |                     unicode_escape[5] = hex_digits[value & 0xF];
  891|       |                     std::memcpy(&b[ix], unicode_escape, 6);
  892|       |                     ix += 6;
  893|       |                  }
  894|       |                  else {
  895|       |                     std::memcpy(&b[ix], &value, 1);
  896|       |                     ++ix;
  897|       |                  }
  898|       |               }
  899|       |               else {
  900|       |                  if constexpr (check_reject_control_characters(Opts)) {
  901|       |                     if (uint8_t(value) < 0x20) [[unlikely]] {
  902|       |                        ctx.error = error_code::invalid_control_character;
  903|       |                     }
  904|       |                  }
  905|       |                  std::memcpy(&b[ix], &value, 1);
  906|       |                  ++ix;
  907|       |               }
  908|       |               std::memcpy(&b[ix], "\"", 1);
  909|       |               ++ix;
  910|       |            }
  911|       |         }
  912|  4.09M|         else {
  913|       |            if constexpr (check_raw_string(Opts)) {
  914|       |               const sv str = [&]() -> const sv {
  915|       |                  if constexpr (u8str_t<T>) {
  916|       |                     return sv{reinterpret_cast<const char*>(value.data()), value.size()};
  917|       |                  }
  918|       |                  else {
  919|       |                     return str_view<T>(value);
  920|       |                  }
  921|       |               }();
  922|       |
  923|       |               // We need space for quotes and the string length: 2 + n.
  924|       |               // Use +8 for extra buffer
  925|       |               if (!ensure_space(ctx, b, ix + 8 + str.size())) [[unlikely]] {
  926|       |                  return;
  927|       |               }
  928|       |               // now we don't have to check writing
  929|       |
  930|       |               if constexpr (not check_unquoted(Opts)) {
  931|       |                  std::memcpy(&b[ix], "\"", 1);
  932|       |                  ++ix;
  933|       |               }
  934|       |               if (str.size()) [[likely]] {
  935|       |                  const auto n = str.size();
  936|       |                  std::memcpy(&b[ix], str.data(), n);
  937|       |                  ix += n;
  938|       |               }
  939|       |               if constexpr (not check_unquoted(Opts)) {
  940|       |                  std::memcpy(&b[ix], "\"", 1);
  941|       |                  ++ix;
  942|       |               }
  943|       |            }
  944|  4.09M|            else {
  945|  4.09M|               const sv str = [&]() -> const sv {
  946|  4.09M|                  if constexpr (array_char_t<T>) {
  947|  4.09M|                     return sv{value.data(), value.size()};
  948|  4.09M|                  }
  949|  4.09M|                  else if constexpr (u8str_t<T>) {
  950|  4.09M|                     return sv{reinterpret_cast<const char*>(value.data()), value.size()};
  951|  4.09M|                  }
  952|  4.09M|                  else {
  953|  4.09M|                     return str_view<T>(value);
  954|  4.09M|                  }
  955|  4.09M|               }();
  956|  4.09M|               const auto n = str.size();
  957|       |
  958|       |               // In the case n == 0 we need two characters for quotes.
  959|       |               // For each individual character we need room for two characters to handle escapes.
  960|       |               // When using Unicode escapes, we might need up to 6 characters (\uXXXX) per character
  961|       |               if constexpr (check_escape_control_characters(Opts)) {
  962|       |                  if constexpr (has_bounded_capacity<B>) {
  963|       |                     // 6 bytes per character is a ceiling only a string of nothing but control
  964|       |                     // characters reaches. A resizable buffer merely over-allocates against it,
  965|       |                     // but a fixed buffer has nowhere to grow, so the ceiling would reject output
  966|       |                     // that fits. Measuring the string answers exactly, at the cost of a pass over
  967|       |                     // it, so bracket the measurement between two O(1) bounds and only pay it when
  968|       |                     // the answer is still in doubt: the ceiling fitting means yes, and the floor
  969|       |                     // of one byte per character not fitting means no.
  970|       |                     const size_t capacity = buffer_traits<std::remove_cvref_t<B>>::capacity(b);
  971|       |                     size_t required = ix + 10 + 6 * n;
  972|       |                     if (required > capacity) [[unlikely]] {
  973|       |                        required = ix + 10 + n;
  974|       |                        if (required <= capacity) {
  975|       |                           required = ix + 10 + detail::escaped_string_size(str);
  976|       |                        }
  977|       |                     }
  978|       |                     if (!ensure_space(ctx, b, required)) [[unlikely]] {
  979|       |                        return;
  980|       |                     }
  981|       |                  }
  982|       |                  // We need 2 + 6 * n characters in the worst case (all control chars)
  983|       |                  else if (!ensure_space(ctx, b, ix + 10 + 6 * n)) [[unlikely]] {
  984|       |                     return;
  985|       |                  }
  986|       |               }
  987|  4.09M|               else {
  988|       |                  // Using the original sizing
  989|  4.09M|                  if (!ensure_space(ctx, b, ix + 10 + 2 * n)) [[unlikely]] {
  ------------------
  |  Branch (989:23): [True: 0, False: 4.09M]
  ------------------
  990|      0|                     return;
  991|      0|                  }
  992|  4.09M|               }
  993|       |               // now we don't have to check writing
  994|       |
  995|       |               if constexpr (check_unquoted(Opts)) {
  996|       |                  if (n) {
  997|       |                     std::memcpy(&b[ix], str.data(), n);
  998|       |                     ix += n;
  999|       |                  }
 1000|       |               }
 1001|  4.09M|               else {
 1002|  4.09M|                  std::memcpy(&b[ix], "\"", 1);
 1003|  4.09M|                  ++ix;
 1004|       |
 1005|  4.09M|                  const auto* c = str.data();
 1006|  4.09M|                  const auto* const e = c + n;
 1007|  4.09M|                  const auto start = &b[ix];
 1008|  4.09M|                  auto data = start;
 1009|       |
 1010|       |                  // By default we don't escape control characters for performance. Invalid JSON characters
 1011|       |                  // result in null characters in the output, making the JSON invalid — these would then be
 1012|       |                  // detected upon reading. Enable the `escape_control_characters` option to properly escape
 1013|       |                  // control characters (0x00–0x1F) as \uXXXX sequences.
 1014|       |
 1015|       |                  // Escape handler: writes the escaped form of *c into data, advances both pointers
 1016|  4.09M|                  auto write_escape = [&]() {
 1017|  4.09M|                     if constexpr (check_escape_control_characters(Opts)) {
 1018|  4.09M|                        if (const auto escaped = char_escape_table[uint8_t(*c)]; escaped) {
 1019|  4.09M|                           std::memcpy(data, &escaped, 2);
 1020|  4.09M|                           data += 2;
 1021|  4.09M|                        }
 1022|  4.09M|                        else {
 1023|  4.09M|                           char unicode_escape[6] = {'\\', 'u', '0', '0', '0', '0'};
 1024|  4.09M|                           constexpr char hex_digits[] = "0123456789ABCDEF";
 1025|  4.09M|                           unicode_escape[4] = hex_digits[(uint8_t(*c) >> 4) & 0xF];
 1026|  4.09M|                           unicode_escape[5] = hex_digits[uint8_t(*c) & 0xF];
 1027|  4.09M|                           std::memcpy(data, unicode_escape, 6);
 1028|  4.09M|                           data += 6;
 1029|  4.09M|                        }
 1030|  4.09M|                     }
 1031|  4.09M|                     else {
 1032|  4.09M|                        if constexpr (check_reject_control_characters(Opts)) {
 1033|       |                           // A control character with no two-character escape cannot be written
 1034|       |                           // without \uXXXX. The table entry is zero, so the memcpy below would
 1035|       |                           // put two NULs where one byte was. Flag it and let the loop finish:
 1036|       |                           // returning early here would leave c un-advanced and the SIMD scan
 1037|       |                           // would find the same byte forever. The output is abandoned anyway.
 1038|  4.09M|                           if (char_escape_table[uint8_t(*c)] == 0) [[unlikely]] {
 1039|  4.09M|                              ctx.error = error_code::invalid_control_character;
 1040|  4.09M|                           }
 1041|  4.09M|                        }
 1042|  4.09M|                        std::memcpy(data, &char_escape_table[uint8_t(*c)], 2);
 1043|  4.09M|                        data += 2;
 1044|  4.09M|                     }
 1045|  4.09M|                     ++c;
 1046|  4.09M|                  };
 1047|       |
 1048|       |                  // Adding a helper here means adding a branch to string_escape_simd() in
 1049|       |                  // simd/backends.hpp, which names the widest one this cascade invokes, and a row
 1050|       |                  // to known_builds in tests/json_test/utf8_validation_test.cpp, which checks it.
 1051|       |#if defined(GLZ_USE_AVX2)
 1052|       |                  detail::avx2_string_escape(c, e, data, n, write_escape);
 1053|       |#endif
 1054|  4.09M|#if defined(GLZ_USE_SSE2)
 1055|  4.09M|                  detail::sse2_string_escape(c, e, data, n, write_escape);
 1056|       |#elif defined(GLZ_USE_NEON)
 1057|       |                  detail::neon_string_escape(c, e, data, n, write_escape);
 1058|       |#endif
 1059|       |
 1060|       |                  // SWAR: 8 bytes at a time
 1061|  4.09M|                  if (n > 7) {
  ------------------
  |  Branch (1061:23): [True: 4.09M, False: 0]
  ------------------
 1062|  4.68M|                     for (const auto end_m7 = e - 7; c < end_m7;) {
  ------------------
  |  Branch (1062:54): [True: 588k, False: 4.09M]
  ------------------
 1063|   588k|                        std::memcpy(data, c, 8);
 1064|   588k|                        uint64_t swar;
 1065|   588k|                        std::memcpy(&swar, c, 8);
 1066|       |                        if constexpr (std::endian::native == std::endian::big) {
 1067|       |                           swar = std::byteswap(swar);
 1068|       |                        }
 1069|       |
 1070|   588k|                        constexpr uint64_t lo7_mask = repeat_byte8(0b01111111);
 1071|   588k|                        const uint64_t lo7 = swar & lo7_mask;
 1072|   588k|                        const uint64_t quote = (lo7 ^ repeat_byte8('"')) + lo7_mask;
 1073|   588k|                        const uint64_t backslash = (lo7 ^ repeat_byte8('\\')) + lo7_mask;
 1074|   588k|                        const uint64_t less_32 = (swar & repeat_byte8(0b01100000)) + lo7_mask;
 1075|   588k|                        uint64_t next = ~((quote & backslash & less_32) | swar);
 1076|       |
 1077|   588k|                        next &= repeat_byte8(0b10000000);
 1078|   588k|                        if (next == 0) {
  ------------------
  |  Branch (1078:29): [True: 51.1k, False: 537k]
  ------------------
 1079|  51.1k|                           data += 8;
 1080|  51.1k|                           c += 8;
 1081|  51.1k|                           continue;
 1082|  51.1k|                        }
 1083|       |
 1084|   537k|                        const auto length = (countr_zero(next) >> 3);
 1085|   537k|                        c += length;
 1086|   537k|                        data += length;
 1087|   537k|                        write_escape();
 1088|   537k|                     }
 1089|  4.09M|                  }
 1090|       |
 1091|       |                  // Scalar tail
 1092|  28.0M|                  for (; c < e; ++c) {
  ------------------
  |  Branch (1092:26): [True: 23.9M, False: 4.09M]
  ------------------
 1093|  23.9M|                     if (const auto escaped = char_escape_table[uint8_t(*c)]; escaped) {
  ------------------
  |  Branch (1093:79): [True: 61.5k, False: 23.8M]
  ------------------
 1094|  61.5k|                        std::memcpy(data, &escaped, 2);
 1095|  61.5k|                        data += 2;
 1096|  61.5k|                     }
 1097|       |                     else if constexpr (check_escape_control_characters(Opts)) {
 1098|       |                        if (uint8_t(*c) < 0x20) {
 1099|       |                           char unicode_escape[6] = {'\\', 'u', '0', '0', '0', '0'};
 1100|       |                           constexpr char hex_digits[] = "0123456789ABCDEF";
 1101|       |                           unicode_escape[4] = hex_digits[(uint8_t(*c) >> 4) & 0xF];
 1102|       |                           unicode_escape[5] = hex_digits[uint8_t(*c) & 0xF];
 1103|       |                           std::memcpy(data, unicode_escape, 6);
 1104|       |                           data += 6;
 1105|       |                        }
 1106|       |                        else {
 1107|       |                           std::memcpy(data, c, 1);
 1108|       |                           ++data;
 1109|       |                        }
 1110|       |                     }
 1111|  23.8M|                     else {
 1112|       |                        if constexpr (check_reject_control_characters(Opts)) {
 1113|       |                           if (uint8_t(*c) < 0x20) [[unlikely]] {
 1114|       |                              ctx.error = error_code::invalid_control_character;
 1115|       |                           }
 1116|       |                        }
 1117|  23.8M|                        std::memcpy(data, c, 1);
 1118|  23.8M|                        ++data;
 1119|  23.8M|                     }
 1120|  23.9M|                  }
 1121|       |
 1122|  4.09M|                  ix += size_t(data - start);
 1123|       |
 1124|  4.09M|                  std::memcpy(&b[ix], "\"", 1);
 1125|  4.09M|                  ++ix;
 1126|  4.09M|               }
 1127|  4.09M|            }
 1128|  4.09M|         }
 1129|  4.09M|      }
_ZZN3glz2toILj10ENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE2opITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERS7_S7_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_ENKUlvE_clEv:
  945|  4.09M|               const sv str = [&]() -> const sv {
  946|       |                  if constexpr (array_char_t<T>) {
  947|       |                     return sv{value.data(), value.size()};
  948|       |                  }
  949|       |                  else if constexpr (u8str_t<T>) {
  950|       |                     return sv{reinterpret_cast<const char*>(value.data()), value.size()};
  951|       |                  }
  952|  4.09M|                  else {
  953|  4.09M|                     return str_view<T>(value);
  954|  4.09M|                  }
  955|  4.09M|               }();
_ZZN3glz2toILj10ENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE2opITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERS7_S7_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_ENKUlvE0_clEv:
 1016|  1.43M|                  auto write_escape = [&]() {
 1017|       |                     if constexpr (check_escape_control_characters(Opts)) {
 1018|       |                        if (const auto escaped = char_escape_table[uint8_t(*c)]; escaped) {
 1019|       |                           std::memcpy(data, &escaped, 2);
 1020|       |                           data += 2;
 1021|       |                        }
 1022|       |                        else {
 1023|       |                           char unicode_escape[6] = {'\\', 'u', '0', '0', '0', '0'};
 1024|       |                           constexpr char hex_digits[] = "0123456789ABCDEF";
 1025|       |                           unicode_escape[4] = hex_digits[(uint8_t(*c) >> 4) & 0xF];
 1026|       |                           unicode_escape[5] = hex_digits[uint8_t(*c) & 0xF];
 1027|       |                           std::memcpy(data, unicode_escape, 6);
 1028|       |                           data += 6;
 1029|       |                        }
 1030|       |                     }
 1031|  1.43M|                     else {
 1032|       |                        if constexpr (check_reject_control_characters(Opts)) {
 1033|       |                           // A control character with no two-character escape cannot be written
 1034|       |                           // without \uXXXX. The table entry is zero, so the memcpy below would
 1035|       |                           // put two NULs where one byte was. Flag it and let the loop finish:
 1036|       |                           // returning early here would leave c un-advanced and the SIMD scan
 1037|       |                           // would find the same byte forever. The output is abandoned anyway.
 1038|       |                           if (char_escape_table[uint8_t(*c)] == 0) [[unlikely]] {
 1039|       |                              ctx.error = error_code::invalid_control_character;
 1040|       |                           }
 1041|       |                        }
 1042|  1.43M|                        std::memcpy(data, &char_escape_table[uint8_t(*c)], 2);
 1043|  1.43M|                        data += 2;
 1044|  1.43M|                     }
 1045|  1.43M|                     ++c;
 1046|  1.43M|                  };
_ZN3glz10write_jsonITkNS_15write_supportedIL_ZNS_4JSONEEEERKNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEEENS2_8expectedINS2_12basic_stringIcS5_NS2_9allocatorIcEEEENS_9error_ctxEEEOT_:
 2840|     40|   {
 2841|     40|      return write<opts{}>(std::forward<T>(value));
 2842|     40|   }
_ZN3glz2toILj10ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEE2opITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERNS1_12basic_stringIcS4_NS1_9allocatorIcEEEERKS5_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_:
  845|     40|      {
  846|       |         if constexpr (check_string_as_number(Opts)) {
  847|       |            const sv str = [&]() -> const sv {
  848|       |               if constexpr (array_char_t<T>) {
  849|       |                  const auto* start = value.data();
  850|       |                  const auto* end = static_cast<const char*>(std::memchr(start, '\0', value.size()));
  851|       |                  return sv{start, end ? size_t(end - start) : value.size()};
  852|       |               }
  853|       |               else if constexpr (u8str_t<T>) {
  854|       |                  return sv{reinterpret_cast<const char*>(value.data()), value.size()};
  855|       |               }
  856|       |               else {
  857|       |                  return str_view<T>(value);
  858|       |               }
  859|       |            }();
  860|       |            if (!ensure_space(ctx, b, ix + str.size() + write_padding_bytes)) [[unlikely]] {
  861|       |               return;
  862|       |            }
  863|       |            dump_maybe_empty<false>(str, b, ix);
  864|       |         }
  865|       |         else if constexpr (char_t<T>) {
  866|       |            if constexpr (check_unquoted(Opts)) {
  867|       |               dump(value, b, ix);
  868|       |            }
  869|       |            else {
  870|       |               // 8 bytes is enough for quotes and escaped character (worst case: \uXXXX = 6 + 2 quotes)
  871|       |               if (!ensure_space(ctx, b, ix + 8)) [[unlikely]] {
  872|       |                  return;
  873|       |               }
  874|       |
  875|       |               std::memcpy(&b[ix], "\"", 1);
  876|       |               ++ix;
  877|       |               if (const auto escaped = char_escape_table[uint8_t(value)]; escaped) {
  878|       |                  std::memcpy(&b[ix], &escaped, 2);
  879|       |                  ix += 2;
  880|       |               }
  881|       |               else if (value == '\0') {
  882|       |                  // null character treated as empty string
  883|       |               }
  884|       |               else if constexpr (check_escape_control_characters(Opts)) {
  885|       |                  if (uint8_t(value) < 0x20) {
  886|       |                     // Write as \uXXXX format
  887|       |                     char unicode_escape[6] = {'\\', 'u', '0', '0', '0', '0'};
  888|       |                     constexpr char hex_digits[] = "0123456789ABCDEF";
  889|       |                     unicode_escape[4] = hex_digits[(value >> 4) & 0xF];
  890|       |                     unicode_escape[5] = hex_digits[value & 0xF];
  891|       |                     std::memcpy(&b[ix], unicode_escape, 6);
  892|       |                     ix += 6;
  893|       |                  }
  894|       |                  else {
  895|       |                     std::memcpy(&b[ix], &value, 1);
  896|       |                     ++ix;
  897|       |                  }
  898|       |               }
  899|       |               else {
  900|       |                  if constexpr (check_reject_control_characters(Opts)) {
  901|       |                     if (uint8_t(value) < 0x20) [[unlikely]] {
  902|       |                        ctx.error = error_code::invalid_control_character;
  903|       |                     }
  904|       |                  }
  905|       |                  std::memcpy(&b[ix], &value, 1);
  906|       |                  ++ix;
  907|       |               }
  908|       |               std::memcpy(&b[ix], "\"", 1);
  909|       |               ++ix;
  910|       |            }
  911|       |         }
  912|     40|         else {
  913|       |            if constexpr (check_raw_string(Opts)) {
  914|       |               const sv str = [&]() -> const sv {
  915|       |                  if constexpr (u8str_t<T>) {
  916|       |                     return sv{reinterpret_cast<const char*>(value.data()), value.size()};
  917|       |                  }
  918|       |                  else {
  919|       |                     return str_view<T>(value);
  920|       |                  }
  921|       |               }();
  922|       |
  923|       |               // We need space for quotes and the string length: 2 + n.
  924|       |               // Use +8 for extra buffer
  925|       |               if (!ensure_space(ctx, b, ix + 8 + str.size())) [[unlikely]] {
  926|       |                  return;
  927|       |               }
  928|       |               // now we don't have to check writing
  929|       |
  930|       |               if constexpr (not check_unquoted(Opts)) {
  931|       |                  std::memcpy(&b[ix], "\"", 1);
  932|       |                  ++ix;
  933|       |               }
  934|       |               if (str.size()) [[likely]] {
  935|       |                  const auto n = str.size();
  936|       |                  std::memcpy(&b[ix], str.data(), n);
  937|       |                  ix += n;
  938|       |               }
  939|       |               if constexpr (not check_unquoted(Opts)) {
  940|       |                  std::memcpy(&b[ix], "\"", 1);
  941|       |                  ++ix;
  942|       |               }
  943|       |            }
  944|     40|            else {
  945|     40|               const sv str = [&]() -> const sv {
  946|     40|                  if constexpr (array_char_t<T>) {
  947|     40|                     return sv{value.data(), value.size()};
  948|     40|                  }
  949|     40|                  else if constexpr (u8str_t<T>) {
  950|     40|                     return sv{reinterpret_cast<const char*>(value.data()), value.size()};
  951|     40|                  }
  952|     40|                  else {
  953|     40|                     return str_view<T>(value);
  954|     40|                  }
  955|     40|               }();
  956|     40|               const auto n = str.size();
  957|       |
  958|       |               // In the case n == 0 we need two characters for quotes.
  959|       |               // For each individual character we need room for two characters to handle escapes.
  960|       |               // When using Unicode escapes, we might need up to 6 characters (\uXXXX) per character
  961|       |               if constexpr (check_escape_control_characters(Opts)) {
  962|       |                  if constexpr (has_bounded_capacity<B>) {
  963|       |                     // 6 bytes per character is a ceiling only a string of nothing but control
  964|       |                     // characters reaches. A resizable buffer merely over-allocates against it,
  965|       |                     // but a fixed buffer has nowhere to grow, so the ceiling would reject output
  966|       |                     // that fits. Measuring the string answers exactly, at the cost of a pass over
  967|       |                     // it, so bracket the measurement between two O(1) bounds and only pay it when
  968|       |                     // the answer is still in doubt: the ceiling fitting means yes, and the floor
  969|       |                     // of one byte per character not fitting means no.
  970|       |                     const size_t capacity = buffer_traits<std::remove_cvref_t<B>>::capacity(b);
  971|       |                     size_t required = ix + 10 + 6 * n;
  972|       |                     if (required > capacity) [[unlikely]] {
  973|       |                        required = ix + 10 + n;
  974|       |                        if (required <= capacity) {
  975|       |                           required = ix + 10 + detail::escaped_string_size(str);
  976|       |                        }
  977|       |                     }
  978|       |                     if (!ensure_space(ctx, b, required)) [[unlikely]] {
  979|       |                        return;
  980|       |                     }
  981|       |                  }
  982|       |                  // We need 2 + 6 * n characters in the worst case (all control chars)
  983|       |                  else if (!ensure_space(ctx, b, ix + 10 + 6 * n)) [[unlikely]] {
  984|       |                     return;
  985|       |                  }
  986|       |               }
  987|     40|               else {
  988|       |                  // Using the original sizing
  989|     40|                  if (!ensure_space(ctx, b, ix + 10 + 2 * n)) [[unlikely]] {
  ------------------
  |  Branch (989:23): [True: 0, False: 40]
  ------------------
  990|      0|                     return;
  991|      0|                  }
  992|     40|               }
  993|       |               // now we don't have to check writing
  994|       |
  995|       |               if constexpr (check_unquoted(Opts)) {
  996|       |                  if (n) {
  997|       |                     std::memcpy(&b[ix], str.data(), n);
  998|       |                     ix += n;
  999|       |                  }
 1000|       |               }
 1001|     40|               else {
 1002|     40|                  std::memcpy(&b[ix], "\"", 1);
 1003|     40|                  ++ix;
 1004|       |
 1005|     40|                  const auto* c = str.data();
 1006|     40|                  const auto* const e = c + n;
 1007|     40|                  const auto start = &b[ix];
 1008|     40|                  auto data = start;
 1009|       |
 1010|       |                  // By default we don't escape control characters for performance. Invalid JSON characters
 1011|       |                  // result in null characters in the output, making the JSON invalid — these would then be
 1012|       |                  // detected upon reading. Enable the `escape_control_characters` option to properly escape
 1013|       |                  // control characters (0x00–0x1F) as \uXXXX sequences.
 1014|       |
 1015|       |                  // Escape handler: writes the escaped form of *c into data, advances both pointers
 1016|     40|                  auto write_escape = [&]() {
 1017|     40|                     if constexpr (check_escape_control_characters(Opts)) {
 1018|     40|                        if (const auto escaped = char_escape_table[uint8_t(*c)]; escaped) {
 1019|     40|                           std::memcpy(data, &escaped, 2);
 1020|     40|                           data += 2;
 1021|     40|                        }
 1022|     40|                        else {
 1023|     40|                           char unicode_escape[6] = {'\\', 'u', '0', '0', '0', '0'};
 1024|     40|                           constexpr char hex_digits[] = "0123456789ABCDEF";
 1025|     40|                           unicode_escape[4] = hex_digits[(uint8_t(*c) >> 4) & 0xF];
 1026|     40|                           unicode_escape[5] = hex_digits[uint8_t(*c) & 0xF];
 1027|     40|                           std::memcpy(data, unicode_escape, 6);
 1028|     40|                           data += 6;
 1029|     40|                        }
 1030|     40|                     }
 1031|     40|                     else {
 1032|     40|                        if constexpr (check_reject_control_characters(Opts)) {
 1033|       |                           // A control character with no two-character escape cannot be written
 1034|       |                           // without \uXXXX. The table entry is zero, so the memcpy below would
 1035|       |                           // put two NULs where one byte was. Flag it and let the loop finish:
 1036|       |                           // returning early here would leave c un-advanced and the SIMD scan
 1037|       |                           // would find the same byte forever. The output is abandoned anyway.
 1038|     40|                           if (char_escape_table[uint8_t(*c)] == 0) [[unlikely]] {
 1039|     40|                              ctx.error = error_code::invalid_control_character;
 1040|     40|                           }
 1041|     40|                        }
 1042|     40|                        std::memcpy(data, &char_escape_table[uint8_t(*c)], 2);
 1043|     40|                        data += 2;
 1044|     40|                     }
 1045|     40|                     ++c;
 1046|     40|                  };
 1047|       |
 1048|       |                  // Adding a helper here means adding a branch to string_escape_simd() in
 1049|       |                  // simd/backends.hpp, which names the widest one this cascade invokes, and a row
 1050|       |                  // to known_builds in tests/json_test/utf8_validation_test.cpp, which checks it.
 1051|       |#if defined(GLZ_USE_AVX2)
 1052|       |                  detail::avx2_string_escape(c, e, data, n, write_escape);
 1053|       |#endif
 1054|     40|#if defined(GLZ_USE_SSE2)
 1055|     40|                  detail::sse2_string_escape(c, e, data, n, write_escape);
 1056|       |#elif defined(GLZ_USE_NEON)
 1057|       |                  detail::neon_string_escape(c, e, data, n, write_escape);
 1058|       |#endif
 1059|       |
 1060|       |                  // SWAR: 8 bytes at a time
 1061|     40|                  if (n > 7) {
  ------------------
  |  Branch (1061:23): [True: 0, False: 40]
  ------------------
 1062|      0|                     for (const auto end_m7 = e - 7; c < end_m7;) {
  ------------------
  |  Branch (1062:54): [True: 0, False: 0]
  ------------------
 1063|      0|                        std::memcpy(data, c, 8);
 1064|      0|                        uint64_t swar;
 1065|      0|                        std::memcpy(&swar, c, 8);
 1066|       |                        if constexpr (std::endian::native == std::endian::big) {
 1067|       |                           swar = std::byteswap(swar);
 1068|       |                        }
 1069|       |
 1070|      0|                        constexpr uint64_t lo7_mask = repeat_byte8(0b01111111);
 1071|      0|                        const uint64_t lo7 = swar & lo7_mask;
 1072|      0|                        const uint64_t quote = (lo7 ^ repeat_byte8('"')) + lo7_mask;
 1073|      0|                        const uint64_t backslash = (lo7 ^ repeat_byte8('\\')) + lo7_mask;
 1074|      0|                        const uint64_t less_32 = (swar & repeat_byte8(0b01100000)) + lo7_mask;
 1075|      0|                        uint64_t next = ~((quote & backslash & less_32) | swar);
 1076|       |
 1077|      0|                        next &= repeat_byte8(0b10000000);
 1078|      0|                        if (next == 0) {
  ------------------
  |  Branch (1078:29): [True: 0, False: 0]
  ------------------
 1079|      0|                           data += 8;
 1080|      0|                           c += 8;
 1081|      0|                           continue;
 1082|      0|                        }
 1083|       |
 1084|      0|                        const auto length = (countr_zero(next) >> 3);
 1085|      0|                        c += length;
 1086|      0|                        data += length;
 1087|      0|                        write_escape();
 1088|      0|                     }
 1089|      0|                  }
 1090|       |
 1091|       |                  // Scalar tail
 1092|    280|                  for (; c < e; ++c) {
  ------------------
  |  Branch (1092:26): [True: 240, False: 40]
  ------------------
 1093|    240|                     if (const auto escaped = char_escape_table[uint8_t(*c)]; escaped) {
  ------------------
  |  Branch (1093:79): [True: 0, False: 240]
  ------------------
 1094|      0|                        std::memcpy(data, &escaped, 2);
 1095|      0|                        data += 2;
 1096|      0|                     }
 1097|       |                     else if constexpr (check_escape_control_characters(Opts)) {
 1098|       |                        if (uint8_t(*c) < 0x20) {
 1099|       |                           char unicode_escape[6] = {'\\', 'u', '0', '0', '0', '0'};
 1100|       |                           constexpr char hex_digits[] = "0123456789ABCDEF";
 1101|       |                           unicode_escape[4] = hex_digits[(uint8_t(*c) >> 4) & 0xF];
 1102|       |                           unicode_escape[5] = hex_digits[uint8_t(*c) & 0xF];
 1103|       |                           std::memcpy(data, unicode_escape, 6);
 1104|       |                           data += 6;
 1105|       |                        }
 1106|       |                        else {
 1107|       |                           std::memcpy(data, c, 1);
 1108|       |                           ++data;
 1109|       |                        }
 1110|       |                     }
 1111|    240|                     else {
 1112|       |                        if constexpr (check_reject_control_characters(Opts)) {
 1113|       |                           if (uint8_t(*c) < 0x20) [[unlikely]] {
 1114|       |                              ctx.error = error_code::invalid_control_character;
 1115|       |                           }
 1116|       |                        }
 1117|    240|                        std::memcpy(data, c, 1);
 1118|    240|                        ++data;
 1119|    240|                     }
 1120|    240|                  }
 1121|       |
 1122|     40|                  ix += size_t(data - start);
 1123|       |
 1124|     40|                  std::memcpy(&b[ix], "\"", 1);
 1125|     40|                  ++ix;
 1126|     40|               }
 1127|     40|            }
 1128|     40|         }
 1129|     40|      }
_ZZN3glz2toILj10ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEE2opITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERNS1_12basic_stringIcS4_NS1_9allocatorIcEEEERKS5_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_ENKUlvE_clEv:
  945|     40|               const sv str = [&]() -> const sv {
  946|       |                  if constexpr (array_char_t<T>) {
  947|       |                     return sv{value.data(), value.size()};
  948|       |                  }
  949|       |                  else if constexpr (u8str_t<T>) {
  950|       |                     return sv{reinterpret_cast<const char*>(value.data()), value.size()};
  951|       |                  }
  952|     40|                  else {
  953|     40|                     return str_view<T>(value);
  954|     40|                  }
  955|     40|               }();

_ZN3glz6to_tieIRN12jsonrpc_fuzz5pointELm2EQleT0_L_ZNS_6detail25max_pure_reflection_countEEEEDcOT_:
  137|  68.6k|   {
  138|       |      if constexpr (N == 0) {
  139|       |         return tuple{};
  140|       |      }
  141|       |      else if constexpr (N == 1) {
  142|       |         auto& [p] = t;
  143|       |         return glz::tie(p);
  144|       |      }
  145|  68.6k|      else if constexpr (N == 2) {
  146|  68.6k|         auto& [p0, p1] = t;
  147|  68.6k|         return glz::tie(p0, p1);
  148|       |      }
  149|       |      else if constexpr (N == 3) {
  150|       |         auto& [p0, p1, p2] = t;
  151|       |         return glz::tie(p0, p1, p2);
  152|       |      }
  153|       |      else if constexpr (N == 4) {
  154|       |         auto& [p0, p1, p2, p3] = t;
  155|       |         return glz::tie(p0, p1, p2, p3);
  156|       |      }
  157|       |      else if constexpr (N == 5) {
  158|       |         auto& [p0, p1, p2, p3, p4] = t;
  159|       |         return glz::tie(p0, p1, p2, p3, p4);
  160|       |      }
  161|       |      else if constexpr (N == 6) {
  162|       |         auto& [p0, p1, p2, p3, p4, p5] = t;
  163|       |         return glz::tie(p0, p1, p2, p3, p4, p5);
  164|       |      }
  165|       |      else if constexpr (N == 7) {
  166|       |         auto& [p0, p1, p2, p3, p4, p5, p6] = t;
  167|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6);
  168|       |      }
  169|       |      else if constexpr (N == 8) {
  170|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7] = t;
  171|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7);
  172|       |      }
  173|       |      else if constexpr (N == 9) {
  174|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8] = t;
  175|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8);
  176|       |      }
  177|       |      else if constexpr (N == 10) {
  178|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9] = t;
  179|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9);
  180|       |      }
  181|       |      else if constexpr (N == 11) {
  182|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10] = t;
  183|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10);
  184|       |      }
  185|       |      else if constexpr (N == 12) {
  186|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11] = t;
  187|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11);
  188|       |      }
  189|       |      else if constexpr (N == 13) {
  190|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12] = t;
  191|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12);
  192|       |      }
  193|       |      else if constexpr (N == 14) {
  194|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13] = t;
  195|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13);
  196|       |      }
  197|       |      else if constexpr (N == 15) {
  198|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14] = t;
  199|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14);
  200|       |      }
  201|       |      else if constexpr (N == 16) {
  202|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15] = t;
  203|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15);
  204|       |      }
  205|       |      else if constexpr (N == 17) {
  206|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16] = t;
  207|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16);
  208|       |      }
  209|       |      else if constexpr (N == 18) {
  210|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17] = t;
  211|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17);
  212|       |      }
  213|       |      else if constexpr (N == 19) {
  214|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18] = t;
  215|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18);
  216|       |      }
  217|       |      else if constexpr (N == 20) {
  218|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19] = t;
  219|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19);
  220|       |      }
  221|       |      else if constexpr (N == 21) {
  222|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20] = t;
  223|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20);
  224|       |      }
  225|       |      else if constexpr (N == 22) {
  226|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21] = t;
  227|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  228|       |                         p21);
  229|       |      }
  230|       |      else if constexpr (N == 23) {
  231|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
  232|       |                p22] = t;
  233|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  234|       |                         p21, p22);
  235|       |      }
  236|       |      else if constexpr (N == 24) {
  237|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  238|       |                p23] = t;
  239|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  240|       |                         p21, p22, p23);
  241|       |      }
  242|       |      else if constexpr (N == 25) {
  243|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  244|       |                p23, p24] = t;
  245|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  246|       |                         p21, p22, p23, p24);
  247|       |      }
  248|       |      else if constexpr (N == 26) {
  249|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  250|       |                p23, p24, p25] = t;
  251|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  252|       |                         p21, p22, p23, p24, p25);
  253|       |      }
  254|       |      else if constexpr (N == 27) {
  255|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  256|       |                p23, p24, p25, p26] = t;
  257|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  258|       |                         p21, p22, p23, p24, p25, p26);
  259|       |      }
  260|       |      else if constexpr (N == 28) {
  261|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  262|       |                p23, p24, p25, p26, p27] = t;
  263|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  264|       |                         p21, p22, p23, p24, p25, p26, p27);
  265|       |      }
  266|       |      else if constexpr (N == 29) {
  267|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  268|       |                p23, p24, p25, p26, p27, p28] = t;
  269|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  270|       |                         p21, p22, p23, p24, p25, p26, p27, p28);
  271|       |      }
  272|       |      else if constexpr (N == 30) {
  273|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  274|       |                p23, p24, p25, p26, p27, p28, p29] = t;
  275|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  276|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29);
  277|       |      }
  278|       |      else if constexpr (N == 31) {
  279|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  280|       |                p23, p24, p25, p26, p27, p28, p29, p30] = t;
  281|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  282|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30);
  283|       |      }
  284|       |      else if constexpr (N == 32) {
  285|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  286|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31] = t;
  287|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  288|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31);
  289|       |      }
  290|       |      else if constexpr (N == 33) {
  291|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  292|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32] = t;
  293|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  294|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32);
  295|       |      }
  296|       |      else if constexpr (N == 34) {
  297|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  298|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33] = t;
  299|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  300|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33);
  301|       |      }
  302|       |      else if constexpr (N == 35) {
  303|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  304|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34] = t;
  305|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  306|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34);
  307|       |      }
  308|       |      else if constexpr (N == 36) {
  309|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  310|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35] = t;
  311|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  312|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35);
  313|       |      }
  314|       |      else if constexpr (N == 37) {
  315|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  316|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36] = t;
  317|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  318|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36);
  319|       |      }
  320|       |      else if constexpr (N == 38) {
  321|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  322|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37] = t;
  323|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  324|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37);
  325|       |      }
  326|       |      else if constexpr (N == 39) {
  327|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  328|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38] = t;
  329|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  330|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38);
  331|       |      }
  332|       |      else if constexpr (N == 40) {
  333|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  334|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39] = t;
  335|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  336|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39);
  337|       |      }
  338|       |      else if constexpr (N == 41) {
  339|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  340|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40] = t;
  341|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  342|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  343|       |                         p40);
  344|       |      }
  345|       |      else if constexpr (N == 42) {
  346|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  347|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41] = t;
  348|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  349|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  350|       |                         p40, p41);
  351|       |      }
  352|       |      else if constexpr (N == 43) {
  353|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  354|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42] = t;
  355|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  356|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  357|       |                         p40, p41, p42);
  358|       |      }
  359|       |      else if constexpr (N == 44) {
  360|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  361|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42,
  362|       |                p43] = t;
  363|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  364|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  365|       |                         p40, p41, p42, p43);
  366|       |      }
  367|       |      else if constexpr (N == 45) {
  368|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  369|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  370|       |                p44] = t;
  371|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  372|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  373|       |                         p40, p41, p42, p43, p44);
  374|       |      }
  375|       |      else if constexpr (N == 46) {
  376|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  377|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  378|       |                p44, p45] = t;
  379|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  380|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  381|       |                         p40, p41, p42, p43, p44, p45);
  382|       |      }
  383|       |      else if constexpr (N == 47) {
  384|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  385|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  386|       |                p44, p45, p46] = t;
  387|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  388|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  389|       |                         p40, p41, p42, p43, p44, p45, p46);
  390|       |      }
  391|       |      else if constexpr (N == 48) {
  392|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  393|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  394|       |                p44, p45, p46, p47] = t;
  395|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  396|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  397|       |                         p40, p41, p42, p43, p44, p45, p46, p47);
  398|       |      }
  399|       |      else if constexpr (N == 49) {
  400|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  401|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  402|       |                p44, p45, p46, p47, p48] = t;
  403|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  404|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  405|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48);
  406|       |      }
  407|       |      else if constexpr (N == 50) {
  408|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  409|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  410|       |                p44, p45, p46, p47, p48, p49] = t;
  411|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  412|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  413|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49);
  414|       |      }
  415|       |      else if constexpr (N == 51) {
  416|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  417|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  418|       |                p44, p45, p46, p47, p48, p49, p50] = t;
  419|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  420|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  421|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50);
  422|       |      }
  423|       |      else if constexpr (N == 52) {
  424|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  425|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  426|       |                p44, p45, p46, p47, p48, p49, p50, p51] = t;
  427|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  428|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  429|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51);
  430|       |      }
  431|       |      else if constexpr (N == 53) {
  432|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  433|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  434|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52] = t;
  435|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  436|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  437|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52);
  438|       |      }
  439|       |      else if constexpr (N == 54) {
  440|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  441|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  442|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53] = t;
  443|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  444|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  445|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53);
  446|       |      }
  447|       |      else if constexpr (N == 55) {
  448|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  449|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  450|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54] = t;
  451|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  452|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  453|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54);
  454|       |      }
  455|       |      else if constexpr (N == 56) {
  456|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  457|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  458|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55] = t;
  459|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  460|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  461|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55);
  462|       |      }
  463|       |      else if constexpr (N == 57) {
  464|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  465|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  466|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56] = t;
  467|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  468|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  469|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56);
  470|       |      }
  471|       |      else if constexpr (N == 58) {
  472|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  473|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  474|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57] = t;
  475|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  476|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  477|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57);
  478|       |      }
  479|       |      else if constexpr (N == 59) {
  480|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  481|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  482|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58] = t;
  483|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  484|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  485|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58);
  486|       |      }
  487|       |      else if constexpr (N == 60) {
  488|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  489|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  490|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59] = t;
  491|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  492|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  493|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  494|       |                         p59);
  495|       |      }
  496|       |      else if constexpr (N == 61) {
  497|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  498|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  499|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60] = t;
  500|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  501|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  502|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  503|       |                         p59, p60);
  504|       |      }
  505|       |      else if constexpr (N == 62) {
  506|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  507|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  508|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61] = t;
  509|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  510|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  511|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  512|       |                         p59, p60, p61);
  513|       |      }
  514|       |      else if constexpr (N == 63) {
  515|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  516|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  517|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62] = t;
  518|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  519|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  520|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  521|       |                         p59, p60, p61, p62);
  522|       |      }
  523|       |      else if constexpr (N == 64) {
  524|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  525|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  526|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63] = t;
  527|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  528|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  529|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  530|       |                         p59, p60, p61, p62, p63);
  531|       |      }
  532|       |      else if constexpr (N == 65) {
  533|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  534|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  535|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63,
  536|       |                p64] = t;
  537|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  538|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  539|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  540|       |                         p59, p60, p61, p62, p63, p64);
  541|       |      }
  542|       |      else if constexpr (N == 66) {
  543|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  544|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  545|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  546|       |                p65] = t;
  547|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  548|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  549|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  550|       |                         p59, p60, p61, p62, p63, p64, p65);
  551|       |      }
  552|       |      else if constexpr (N == 67) {
  553|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  554|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  555|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  556|       |                p65, p66] = t;
  557|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  558|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  559|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  560|       |                         p59, p60, p61, p62, p63, p64, p65, p66);
  561|       |      }
  562|       |      else if constexpr (N == 68) {
  563|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  564|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  565|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  566|       |                p65, p66, p67] = t;
  567|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  568|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  569|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  570|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67);
  571|       |      }
  572|       |      else if constexpr (N == 69) {
  573|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  574|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  575|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  576|       |                p65, p66, p67, p68] = t;
  577|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  578|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  579|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  580|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68);
  581|       |      }
  582|       |      else if constexpr (N == 70) {
  583|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  584|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  585|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  586|       |                p65, p66, p67, p68, p69] = t;
  587|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  588|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  589|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  590|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69);
  591|       |      }
  592|       |      else if constexpr (N == 71) {
  593|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  594|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  595|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  596|       |                p65, p66, p67, p68, p69, p70] = t;
  597|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  598|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  599|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  600|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70);
  601|       |      }
  602|       |      else if constexpr (N == 72) {
  603|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  604|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  605|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  606|       |                p65, p66, p67, p68, p69, p70, p71] = t;
  607|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  608|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  609|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  610|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71);
  611|       |      }
  612|       |      else if constexpr (N == 73) {
  613|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  614|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  615|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  616|       |                p65, p66, p67, p68, p69, p70, p71, p72] = t;
  617|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  618|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  619|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  620|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72);
  621|       |      }
  622|       |      else if constexpr (N == 74) {
  623|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  624|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  625|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  626|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73] = t;
  627|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  628|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  629|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  630|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73);
  631|       |      }
  632|       |      else if constexpr (N == 75) {
  633|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  634|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  635|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  636|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74] = t;
  637|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  638|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  639|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  640|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74);
  641|       |      }
  642|       |      else if constexpr (N == 76) {
  643|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  644|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  645|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  646|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75] = t;
  647|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  648|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  649|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  650|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75);
  651|       |      }
  652|       |      else if constexpr (N == 77) {
  653|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  654|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  655|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  656|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76] = t;
  657|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  658|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  659|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  660|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76);
  661|       |      }
  662|       |      else if constexpr (N == 78) {
  663|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  664|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  665|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  666|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77] = t;
  667|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  668|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  669|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  670|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77);
  671|       |      }
  672|       |      else if constexpr (N == 79) {
  673|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  674|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  675|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  676|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78] = t;
  677|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  678|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  679|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  680|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  681|       |                         p78);
  682|       |      }
  683|       |      else if constexpr (N == 80) {
  684|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  685|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  686|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  687|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79] = t;
  688|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  689|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  690|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  691|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  692|       |                         p78, p79);
  693|       |      }
  694|       |      else if constexpr (N == 81) {
  695|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  696|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  697|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  698|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80] = t;
  699|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  700|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  701|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  702|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  703|       |                         p78, p79, p80);
  704|       |      }
  705|       |      else if constexpr (N == 82) {
  706|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  707|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  708|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  709|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81] = t;
  710|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  711|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  712|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  713|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  714|       |                         p78, p79, p80, p81);
  715|       |      }
  716|       |      else if constexpr (N == 83) {
  717|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  718|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  719|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  720|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82] = t;
  721|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  722|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  723|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  724|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  725|       |                         p78, p79, p80, p81, p82);
  726|       |      }
  727|       |      else if constexpr (N == 84) {
  728|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  729|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  730|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  731|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83] = t;
  732|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  733|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  734|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  735|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  736|       |                         p78, p79, p80, p81, p82, p83);
  737|       |      }
  738|       |      else if constexpr (N == 85) {
  739|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  740|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  741|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  742|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84] = t;
  743|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  744|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  745|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  746|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  747|       |                         p78, p79, p80, p81, p82, p83, p84);
  748|       |      }
  749|       |      else if constexpr (N == 86) {
  750|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  751|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  752|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  753|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84,
  754|       |                p85] = t;
  755|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  756|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  757|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  758|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  759|       |                         p78, p79, p80, p81, p82, p83, p84, p85);
  760|       |      }
  761|       |      else if constexpr (N == 87) {
  762|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  763|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  764|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  765|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
  766|       |                p86] = t;
  767|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  768|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  769|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  770|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  771|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86);
  772|       |      }
  773|       |      else if constexpr (N == 88) {
  774|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  775|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  776|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  777|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
  778|       |                p86, p87] = t;
  779|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  780|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  781|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  782|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  783|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87);
  784|       |      }
  785|       |      else if constexpr (N == 89) {
  786|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  787|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  788|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  789|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
  790|       |                p86, p87, p88] = t;
  791|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  792|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  793|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  794|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  795|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88);
  796|       |      }
  797|       |      else if constexpr (N == 90) {
  798|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  799|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  800|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  801|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
  802|       |                p86, p87, p88, p89] = t;
  803|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  804|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  805|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  806|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  807|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89);
  808|       |      }
  809|       |      else if constexpr (N == 91) {
  810|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  811|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  812|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  813|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
  814|       |                p86, p87, p88, p89, p90] = t;
  815|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  816|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  817|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  818|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  819|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90);
  820|       |      }
  821|       |      else if constexpr (N == 92) {
  822|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  823|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  824|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  825|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
  826|       |                p86, p87, p88, p89, p90, p91] = t;
  827|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  828|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  829|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  830|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  831|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91);
  832|       |      }
  833|       |      else if constexpr (N == 93) {
  834|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  835|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  836|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  837|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
  838|       |                p86, p87, p88, p89, p90, p91, p92] = t;
  839|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  840|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  841|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  842|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  843|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92);
  844|       |      }
  845|       |      else if constexpr (N == 94) {
  846|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  847|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  848|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  849|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
  850|       |                p86, p87, p88, p89, p90, p91, p92, p93] = t;
  851|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  852|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  853|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  854|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  855|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93);
  856|       |      }
  857|       |      else if constexpr (N == 95) {
  858|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  859|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  860|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  861|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
  862|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94] = t;
  863|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  864|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  865|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  866|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  867|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94);
  868|       |      }
  869|       |      else if constexpr (N == 96) {
  870|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  871|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  872|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  873|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
  874|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95] = t;
  875|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  876|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  877|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  878|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  879|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95);
  880|       |      }
  881|       |      else if constexpr (N == 97) {
  882|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  883|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  884|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  885|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
  886|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96] = t;
  887|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  888|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  889|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  890|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  891|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96);
  892|       |      }
  893|       |      else if constexpr (N == 98) {
  894|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  895|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  896|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  897|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
  898|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97] = t;
  899|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  900|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  901|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  902|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  903|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
  904|       |                         p97);
  905|       |      }
  906|       |      else if constexpr (N == 99) {
  907|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  908|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  909|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  910|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
  911|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98] = t;
  912|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  913|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  914|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  915|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  916|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
  917|       |                         p97, p98);
  918|       |      }
  919|       |      else if constexpr (N == 100) {
  920|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  921|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  922|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  923|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
  924|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99] = t;
  925|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  926|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  927|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  928|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  929|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
  930|       |                         p97, p98, p99);
  931|       |      }
  932|       |      else if constexpr (N == 101) {
  933|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  934|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  935|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  936|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
  937|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100] = t;
  938|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  939|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  940|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  941|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  942|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
  943|       |                         p97, p98, p99, p100);
  944|       |      }
  945|       |      else if constexpr (N == 102) {
  946|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  947|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  948|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  949|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
  950|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101] = t;
  951|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  952|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  953|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  954|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  955|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
  956|       |                         p97, p98, p99, p100, p101);
  957|       |      }
  958|       |      else if constexpr (N == 103) {
  959|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  960|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  961|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  962|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
  963|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102] = t;
  964|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  965|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  966|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  967|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  968|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
  969|       |                         p97, p98, p99, p100, p101, p102);
  970|       |      }
  971|       |      else if constexpr (N == 104) {
  972|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  973|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  974|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  975|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
  976|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103] = t;
  977|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  978|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  979|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  980|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  981|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
  982|       |                         p97, p98, p99, p100, p101, p102, p103);
  983|       |      }
  984|       |      else if constexpr (N == 105) {
  985|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  986|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  987|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  988|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
  989|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104] = t;
  990|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  991|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  992|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  993|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  994|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
  995|       |                         p97, p98, p99, p100, p101, p102, p103, p104);
  996|       |      }
  997|       |      else if constexpr (N == 106) {
  998|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  999|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1000|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1001|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1002|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1003|       |                p105] = t;
 1004|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1005|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1006|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1007|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1008|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1009|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105);
 1010|       |      }
 1011|       |      else if constexpr (N == 107) {
 1012|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
 1013|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1014|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1015|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1016|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1017|       |                p105, p106] = t;
 1018|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1019|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1020|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1021|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1022|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1023|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106);
 1024|       |      }
 1025|       |      else if constexpr (N == 108) {
 1026|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
 1027|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1028|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1029|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1030|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1031|       |                p105, p106, p107] = t;
 1032|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1033|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1034|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1035|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1036|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1037|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107);
 1038|       |      }
 1039|       |      else if constexpr (N == 109) {
 1040|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
 1041|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1042|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1043|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1044|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1045|       |                p105, p106, p107, p108] = t;
 1046|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1047|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1048|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1049|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1050|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1051|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108);
 1052|       |      }
 1053|       |      else if constexpr (N == 110) {
 1054|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
 1055|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1056|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1057|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1058|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1059|       |                p105, p106, p107, p108, p109] = t;
 1060|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1061|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1062|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1063|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1064|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1065|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109);
 1066|       |      }
 1067|       |      else if constexpr (N == 111) {
 1068|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
 1069|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1070|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1071|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1072|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1073|       |                p105, p106, p107, p108, p109, p110] = t;
 1074|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1075|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1076|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1077|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1078|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1079|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110);
 1080|       |      }
 1081|       |      else if constexpr (N == 112) {
 1082|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
 1083|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1084|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1085|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1086|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1087|       |                p105, p106, p107, p108, p109, p110, p111] = t;
 1088|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1089|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1090|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1091|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1092|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1093|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111);
 1094|       |      }
 1095|       |      else if constexpr (N == 113) {
 1096|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
 1097|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1098|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1099|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1100|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1101|       |                p105, p106, p107, p108, p109, p110, p111, p112] = t;
 1102|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1103|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1104|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1105|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1106|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1107|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112);
 1108|       |      }
 1109|       |      else if constexpr (N == 114) {
 1110|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
 1111|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1112|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1113|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1114|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1115|       |                p105, p106, p107, p108, p109, p110, p111, p112, p113] = t;
 1116|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1117|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1118|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1119|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1120|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1121|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112,
 1122|       |                         p113);
 1123|       |      }
 1124|       |      else if constexpr (N == 115) {
 1125|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
 1126|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1127|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1128|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1129|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1130|       |                p105, p106, p107, p108, p109, p110, p111, p112, p113, p114] = t;
 1131|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1132|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1133|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1134|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1135|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1136|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112,
 1137|       |                         p113, p114);
 1138|       |      }
 1139|       |      else if constexpr (N == 116) {
 1140|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
 1141|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1142|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1143|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1144|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1145|       |                p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115] = t;
 1146|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1147|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1148|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1149|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1150|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1151|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112,
 1152|       |                         p113, p114, p115);
 1153|       |      }
 1154|       |      else if constexpr (N == 117) {
 1155|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
 1156|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1157|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1158|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1159|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1160|       |                p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116] = t;
 1161|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1162|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1163|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1164|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1165|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1166|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112,
 1167|       |                         p113, p114, p115, p116);
 1168|       |      }
 1169|       |      else if constexpr (N == 118) {
 1170|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
 1171|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1172|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1173|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1174|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1175|       |                p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117] = t;
 1176|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1177|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1178|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1179|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1180|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1181|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112,
 1182|       |                         p113, p114, p115, p116, p117);
 1183|       |      }
 1184|       |      else if constexpr (N == 119) {
 1185|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
 1186|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1187|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1188|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1189|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1190|       |                p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118] = t;
 1191|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1192|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1193|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1194|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1195|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1196|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112,
 1197|       |                         p113, p114, p115, p116, p117, p118);
 1198|       |      }
 1199|       |      else if constexpr (N == 120) {
 1200|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
 1201|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1202|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1203|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1204|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1205|       |                p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119] = t;
 1206|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1207|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1208|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1209|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1210|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1211|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112,
 1212|       |                         p113, p114, p115, p116, p117, p118, p119);
 1213|       |      }
 1214|       |      else if constexpr (N == 121) {
 1215|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
 1216|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1217|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1218|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1219|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1220|       |                p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119, p120] = t;
 1221|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1222|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1223|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1224|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1225|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1226|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112,
 1227|       |                         p113, p114, p115, p116, p117, p118, p119, p120);
 1228|       |      }
 1229|       |      else if constexpr (N == 122) {
 1230|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
 1231|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1232|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1233|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1234|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1235|       |                p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119, p120, p121] =
 1236|       |            t;
 1237|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1238|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1239|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1240|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1241|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1242|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112,
 1243|       |                         p113, p114, p115, p116, p117, p118, p119, p120, p121);
 1244|       |      }
 1245|       |      else if constexpr (N == 123) {
 1246|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
 1247|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1248|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1249|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1250|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1251|       |                p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119, p120, p121,
 1252|       |                p122] = t;
 1253|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1254|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1255|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1256|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1257|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1258|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112,
 1259|       |                         p113, p114, p115, p116, p117, p118, p119, p120, p121, p122);
 1260|       |      }
 1261|       |      else if constexpr (N == 124) {
 1262|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
 1263|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1264|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1265|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1266|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1267|       |                p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119, p120, p121,
 1268|       |                p122, p123] = t;
 1269|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1270|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1271|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1272|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1273|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1274|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112,
 1275|       |                         p113, p114, p115, p116, p117, p118, p119, p120, p121, p122, p123);
 1276|       |      }
 1277|       |      else if constexpr (N == 125) {
 1278|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
 1279|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1280|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1281|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1282|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1283|       |                p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119, p120, p121,
 1284|       |                p122, p123, p124] = t;
 1285|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1286|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1287|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1288|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1289|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1290|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112,
 1291|       |                         p113, p114, p115, p116, p117, p118, p119, p120, p121, p122, p123, p124);
 1292|       |      }
 1293|       |      else if constexpr (N == 126) {
 1294|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
 1295|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1296|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1297|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1298|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1299|       |                p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119, p120, p121,
 1300|       |                p122, p123, p124, p125] = t;
 1301|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1302|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1303|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1304|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1305|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1306|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112,
 1307|       |                         p113, p114, p115, p116, p117, p118, p119, p120, p121, p122, p123, p124, p125);
 1308|       |      }
 1309|       |      else if constexpr (N == 127) {
 1310|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
 1311|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1312|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1313|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1314|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1315|       |                p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119, p120, p121,
 1316|       |                p122, p123, p124, p125, p126] = t;
 1317|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1318|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1319|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1320|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1321|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1322|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112,
 1323|       |                         p113, p114, p115, p116, p117, p118, p119, p120, p121, p122, p123, p124, p125, p126);
 1324|       |      }
 1325|       |      else if constexpr (N == 128) {
 1326|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
 1327|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1328|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1329|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1330|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1331|       |                p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119, p120, p121,
 1332|       |                p122, p123, p124, p125, p126, p127] = t;
 1333|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1334|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1335|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1336|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1337|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1338|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112,
 1339|       |                         p113, p114, p115, p116, p117, p118, p119, p120, p121, p122, p123, p124, p125, p126, p127);
 1340|       |      }
 1341|  68.6k|   }
_ZN3glz6to_tieIRN12jsonrpc_fuzz8fuzz_apiELm13EQleT0_L_ZNS_6detail25max_pure_reflection_countEEEEDcOT_:
  137|  88.9k|   {
  138|       |      if constexpr (N == 0) {
  139|       |         return tuple{};
  140|       |      }
  141|       |      else if constexpr (N == 1) {
  142|       |         auto& [p] = t;
  143|       |         return glz::tie(p);
  144|       |      }
  145|       |      else if constexpr (N == 2) {
  146|       |         auto& [p0, p1] = t;
  147|       |         return glz::tie(p0, p1);
  148|       |      }
  149|       |      else if constexpr (N == 3) {
  150|       |         auto& [p0, p1, p2] = t;
  151|       |         return glz::tie(p0, p1, p2);
  152|       |      }
  153|       |      else if constexpr (N == 4) {
  154|       |         auto& [p0, p1, p2, p3] = t;
  155|       |         return glz::tie(p0, p1, p2, p3);
  156|       |      }
  157|       |      else if constexpr (N == 5) {
  158|       |         auto& [p0, p1, p2, p3, p4] = t;
  159|       |         return glz::tie(p0, p1, p2, p3, p4);
  160|       |      }
  161|       |      else if constexpr (N == 6) {
  162|       |         auto& [p0, p1, p2, p3, p4, p5] = t;
  163|       |         return glz::tie(p0, p1, p2, p3, p4, p5);
  164|       |      }
  165|       |      else if constexpr (N == 7) {
  166|       |         auto& [p0, p1, p2, p3, p4, p5, p6] = t;
  167|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6);
  168|       |      }
  169|       |      else if constexpr (N == 8) {
  170|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7] = t;
  171|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7);
  172|       |      }
  173|       |      else if constexpr (N == 9) {
  174|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8] = t;
  175|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8);
  176|       |      }
  177|       |      else if constexpr (N == 10) {
  178|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9] = t;
  179|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9);
  180|       |      }
  181|       |      else if constexpr (N == 11) {
  182|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10] = t;
  183|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10);
  184|       |      }
  185|       |      else if constexpr (N == 12) {
  186|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11] = t;
  187|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11);
  188|       |      }
  189|  88.9k|      else if constexpr (N == 13) {
  190|  88.9k|         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12] = t;
  191|  88.9k|         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12);
  192|       |      }
  193|       |      else if constexpr (N == 14) {
  194|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13] = t;
  195|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13);
  196|       |      }
  197|       |      else if constexpr (N == 15) {
  198|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14] = t;
  199|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14);
  200|       |      }
  201|       |      else if constexpr (N == 16) {
  202|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15] = t;
  203|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15);
  204|       |      }
  205|       |      else if constexpr (N == 17) {
  206|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16] = t;
  207|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16);
  208|       |      }
  209|       |      else if constexpr (N == 18) {
  210|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17] = t;
  211|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17);
  212|       |      }
  213|       |      else if constexpr (N == 19) {
  214|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18] = t;
  215|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18);
  216|       |      }
  217|       |      else if constexpr (N == 20) {
  218|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19] = t;
  219|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19);
  220|       |      }
  221|       |      else if constexpr (N == 21) {
  222|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20] = t;
  223|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20);
  224|       |      }
  225|       |      else if constexpr (N == 22) {
  226|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21] = t;
  227|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  228|       |                         p21);
  229|       |      }
  230|       |      else if constexpr (N == 23) {
  231|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
  232|       |                p22] = t;
  233|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  234|       |                         p21, p22);
  235|       |      }
  236|       |      else if constexpr (N == 24) {
  237|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  238|       |                p23] = t;
  239|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  240|       |                         p21, p22, p23);
  241|       |      }
  242|       |      else if constexpr (N == 25) {
  243|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  244|       |                p23, p24] = t;
  245|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  246|       |                         p21, p22, p23, p24);
  247|       |      }
  248|       |      else if constexpr (N == 26) {
  249|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  250|       |                p23, p24, p25] = t;
  251|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  252|       |                         p21, p22, p23, p24, p25);
  253|       |      }
  254|       |      else if constexpr (N == 27) {
  255|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  256|       |                p23, p24, p25, p26] = t;
  257|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  258|       |                         p21, p22, p23, p24, p25, p26);
  259|       |      }
  260|       |      else if constexpr (N == 28) {
  261|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  262|       |                p23, p24, p25, p26, p27] = t;
  263|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  264|       |                         p21, p22, p23, p24, p25, p26, p27);
  265|       |      }
  266|       |      else if constexpr (N == 29) {
  267|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  268|       |                p23, p24, p25, p26, p27, p28] = t;
  269|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  270|       |                         p21, p22, p23, p24, p25, p26, p27, p28);
  271|       |      }
  272|       |      else if constexpr (N == 30) {
  273|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  274|       |                p23, p24, p25, p26, p27, p28, p29] = t;
  275|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  276|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29);
  277|       |      }
  278|       |      else if constexpr (N == 31) {
  279|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  280|       |                p23, p24, p25, p26, p27, p28, p29, p30] = t;
  281|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  282|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30);
  283|       |      }
  284|       |      else if constexpr (N == 32) {
  285|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  286|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31] = t;
  287|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  288|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31);
  289|       |      }
  290|       |      else if constexpr (N == 33) {
  291|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  292|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32] = t;
  293|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  294|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32);
  295|       |      }
  296|       |      else if constexpr (N == 34) {
  297|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  298|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33] = t;
  299|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  300|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33);
  301|       |      }
  302|       |      else if constexpr (N == 35) {
  303|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  304|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34] = t;
  305|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  306|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34);
  307|       |      }
  308|       |      else if constexpr (N == 36) {
  309|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  310|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35] = t;
  311|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  312|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35);
  313|       |      }
  314|       |      else if constexpr (N == 37) {
  315|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  316|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36] = t;
  317|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  318|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36);
  319|       |      }
  320|       |      else if constexpr (N == 38) {
  321|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  322|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37] = t;
  323|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  324|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37);
  325|       |      }
  326|       |      else if constexpr (N == 39) {
  327|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  328|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38] = t;
  329|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  330|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38);
  331|       |      }
  332|       |      else if constexpr (N == 40) {
  333|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  334|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39] = t;
  335|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  336|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39);
  337|       |      }
  338|       |      else if constexpr (N == 41) {
  339|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  340|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40] = t;
  341|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  342|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  343|       |                         p40);
  344|       |      }
  345|       |      else if constexpr (N == 42) {
  346|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  347|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41] = t;
  348|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  349|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  350|       |                         p40, p41);
  351|       |      }
  352|       |      else if constexpr (N == 43) {
  353|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  354|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42] = t;
  355|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  356|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  357|       |                         p40, p41, p42);
  358|       |      }
  359|       |      else if constexpr (N == 44) {
  360|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  361|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42,
  362|       |                p43] = t;
  363|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  364|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  365|       |                         p40, p41, p42, p43);
  366|       |      }
  367|       |      else if constexpr (N == 45) {
  368|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  369|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  370|       |                p44] = t;
  371|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  372|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  373|       |                         p40, p41, p42, p43, p44);
  374|       |      }
  375|       |      else if constexpr (N == 46) {
  376|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  377|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  378|       |                p44, p45] = t;
  379|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  380|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  381|       |                         p40, p41, p42, p43, p44, p45);
  382|       |      }
  383|       |      else if constexpr (N == 47) {
  384|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  385|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  386|       |                p44, p45, p46] = t;
  387|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  388|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  389|       |                         p40, p41, p42, p43, p44, p45, p46);
  390|       |      }
  391|       |      else if constexpr (N == 48) {
  392|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  393|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  394|       |                p44, p45, p46, p47] = t;
  395|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  396|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  397|       |                         p40, p41, p42, p43, p44, p45, p46, p47);
  398|       |      }
  399|       |      else if constexpr (N == 49) {
  400|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  401|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  402|       |                p44, p45, p46, p47, p48] = t;
  403|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  404|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  405|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48);
  406|       |      }
  407|       |      else if constexpr (N == 50) {
  408|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  409|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  410|       |                p44, p45, p46, p47, p48, p49] = t;
  411|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  412|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  413|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49);
  414|       |      }
  415|       |      else if constexpr (N == 51) {
  416|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  417|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  418|       |                p44, p45, p46, p47, p48, p49, p50] = t;
  419|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  420|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  421|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50);
  422|       |      }
  423|       |      else if constexpr (N == 52) {
  424|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  425|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  426|       |                p44, p45, p46, p47, p48, p49, p50, p51] = t;
  427|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  428|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  429|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51);
  430|       |      }
  431|       |      else if constexpr (N == 53) {
  432|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  433|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  434|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52] = t;
  435|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  436|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  437|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52);
  438|       |      }
  439|       |      else if constexpr (N == 54) {
  440|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  441|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  442|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53] = t;
  443|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  444|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  445|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53);
  446|       |      }
  447|       |      else if constexpr (N == 55) {
  448|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  449|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  450|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54] = t;
  451|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  452|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  453|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54);
  454|       |      }
  455|       |      else if constexpr (N == 56) {
  456|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  457|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  458|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55] = t;
  459|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  460|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  461|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55);
  462|       |      }
  463|       |      else if constexpr (N == 57) {
  464|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  465|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  466|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56] = t;
  467|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  468|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  469|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56);
  470|       |      }
  471|       |      else if constexpr (N == 58) {
  472|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  473|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  474|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57] = t;
  475|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  476|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  477|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57);
  478|       |      }
  479|       |      else if constexpr (N == 59) {
  480|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  481|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  482|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58] = t;
  483|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  484|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  485|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58);
  486|       |      }
  487|       |      else if constexpr (N == 60) {
  488|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  489|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  490|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59] = t;
  491|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  492|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  493|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  494|       |                         p59);
  495|       |      }
  496|       |      else if constexpr (N == 61) {
  497|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  498|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  499|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60] = t;
  500|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  501|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  502|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  503|       |                         p59, p60);
  504|       |      }
  505|       |      else if constexpr (N == 62) {
  506|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  507|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  508|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61] = t;
  509|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  510|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  511|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  512|       |                         p59, p60, p61);
  513|       |      }
  514|       |      else if constexpr (N == 63) {
  515|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  516|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  517|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62] = t;
  518|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  519|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  520|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  521|       |                         p59, p60, p61, p62);
  522|       |      }
  523|       |      else if constexpr (N == 64) {
  524|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  525|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  526|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63] = t;
  527|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  528|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  529|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  530|       |                         p59, p60, p61, p62, p63);
  531|       |      }
  532|       |      else if constexpr (N == 65) {
  533|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  534|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  535|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63,
  536|       |                p64] = t;
  537|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  538|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  539|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  540|       |                         p59, p60, p61, p62, p63, p64);
  541|       |      }
  542|       |      else if constexpr (N == 66) {
  543|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  544|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  545|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  546|       |                p65] = t;
  547|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  548|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  549|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  550|       |                         p59, p60, p61, p62, p63, p64, p65);
  551|       |      }
  552|       |      else if constexpr (N == 67) {
  553|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  554|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  555|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  556|       |                p65, p66] = t;
  557|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  558|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  559|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  560|       |                         p59, p60, p61, p62, p63, p64, p65, p66);
  561|       |      }
  562|       |      else if constexpr (N == 68) {
  563|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  564|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  565|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  566|       |                p65, p66, p67] = t;
  567|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  568|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  569|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  570|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67);
  571|       |      }
  572|       |      else if constexpr (N == 69) {
  573|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  574|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  575|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  576|       |                p65, p66, p67, p68] = t;
  577|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  578|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  579|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  580|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68);
  581|       |      }
  582|       |      else if constexpr (N == 70) {
  583|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  584|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  585|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  586|       |                p65, p66, p67, p68, p69] = t;
  587|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  588|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  589|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  590|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69);
  591|       |      }
  592|       |      else if constexpr (N == 71) {
  593|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  594|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  595|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  596|       |                p65, p66, p67, p68, p69, p70] = t;
  597|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  598|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  599|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  600|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70);
  601|       |      }
  602|       |      else if constexpr (N == 72) {
  603|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  604|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  605|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  606|       |                p65, p66, p67, p68, p69, p70, p71] = t;
  607|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  608|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  609|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  610|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71);
  611|       |      }
  612|       |      else if constexpr (N == 73) {
  613|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  614|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  615|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  616|       |                p65, p66, p67, p68, p69, p70, p71, p72] = t;
  617|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  618|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  619|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  620|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72);
  621|       |      }
  622|       |      else if constexpr (N == 74) {
  623|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  624|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  625|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  626|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73] = t;
  627|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  628|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  629|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  630|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73);
  631|       |      }
  632|       |      else if constexpr (N == 75) {
  633|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  634|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  635|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  636|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74] = t;
  637|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  638|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  639|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  640|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74);
  641|       |      }
  642|       |      else if constexpr (N == 76) {
  643|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  644|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  645|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  646|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75] = t;
  647|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  648|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  649|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  650|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75);
  651|       |      }
  652|       |      else if constexpr (N == 77) {
  653|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  654|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  655|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  656|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76] = t;
  657|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  658|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  659|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  660|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76);
  661|       |      }
  662|       |      else if constexpr (N == 78) {
  663|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  664|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  665|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  666|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77] = t;
  667|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  668|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  669|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  670|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77);
  671|       |      }
  672|       |      else if constexpr (N == 79) {
  673|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  674|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  675|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  676|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78] = t;
  677|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  678|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  679|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  680|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  681|       |                         p78);
  682|       |      }
  683|       |      else if constexpr (N == 80) {
  684|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  685|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  686|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  687|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79] = t;
  688|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  689|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  690|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  691|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  692|       |                         p78, p79);
  693|       |      }
  694|       |      else if constexpr (N == 81) {
  695|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  696|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  697|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  698|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80] = t;
  699|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  700|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  701|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  702|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  703|       |                         p78, p79, p80);
  704|       |      }
  705|       |      else if constexpr (N == 82) {
  706|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  707|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  708|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  709|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81] = t;
  710|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  711|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  712|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  713|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  714|       |                         p78, p79, p80, p81);
  715|       |      }
  716|       |      else if constexpr (N == 83) {
  717|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  718|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  719|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  720|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82] = t;
  721|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  722|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  723|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  724|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  725|       |                         p78, p79, p80, p81, p82);
  726|       |      }
  727|       |      else if constexpr (N == 84) {
  728|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  729|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  730|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  731|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83] = t;
  732|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  733|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  734|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  735|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  736|       |                         p78, p79, p80, p81, p82, p83);
  737|       |      }
  738|       |      else if constexpr (N == 85) {
  739|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  740|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  741|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  742|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84] = t;
  743|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  744|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  745|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  746|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  747|       |                         p78, p79, p80, p81, p82, p83, p84);
  748|       |      }
  749|       |      else if constexpr (N == 86) {
  750|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  751|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  752|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  753|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84,
  754|       |                p85] = t;
  755|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  756|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  757|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  758|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  759|       |                         p78, p79, p80, p81, p82, p83, p84, p85);
  760|       |      }
  761|       |      else if constexpr (N == 87) {
  762|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  763|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  764|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  765|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
  766|       |                p86] = t;
  767|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  768|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  769|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  770|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  771|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86);
  772|       |      }
  773|       |      else if constexpr (N == 88) {
  774|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  775|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  776|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  777|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
  778|       |                p86, p87] = t;
  779|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  780|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  781|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  782|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  783|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87);
  784|       |      }
  785|       |      else if constexpr (N == 89) {
  786|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  787|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  788|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  789|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
  790|       |                p86, p87, p88] = t;
  791|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  792|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  793|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  794|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  795|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88);
  796|       |      }
  797|       |      else if constexpr (N == 90) {
  798|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  799|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  800|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  801|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
  802|       |                p86, p87, p88, p89] = t;
  803|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  804|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  805|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  806|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  807|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89);
  808|       |      }
  809|       |      else if constexpr (N == 91) {
  810|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  811|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  812|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  813|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
  814|       |                p86, p87, p88, p89, p90] = t;
  815|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  816|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  817|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  818|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  819|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90);
  820|       |      }
  821|       |      else if constexpr (N == 92) {
  822|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  823|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  824|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  825|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
  826|       |                p86, p87, p88, p89, p90, p91] = t;
  827|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  828|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  829|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  830|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  831|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91);
  832|       |      }
  833|       |      else if constexpr (N == 93) {
  834|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  835|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  836|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  837|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
  838|       |                p86, p87, p88, p89, p90, p91, p92] = t;
  839|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  840|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  841|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  842|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  843|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92);
  844|       |      }
  845|       |      else if constexpr (N == 94) {
  846|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  847|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  848|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  849|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
  850|       |                p86, p87, p88, p89, p90, p91, p92, p93] = t;
  851|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  852|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  853|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  854|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  855|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93);
  856|       |      }
  857|       |      else if constexpr (N == 95) {
  858|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  859|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  860|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  861|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
  862|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94] = t;
  863|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  864|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  865|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  866|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  867|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94);
  868|       |      }
  869|       |      else if constexpr (N == 96) {
  870|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  871|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  872|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  873|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
  874|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95] = t;
  875|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  876|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  877|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  878|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  879|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95);
  880|       |      }
  881|       |      else if constexpr (N == 97) {
  882|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  883|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  884|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  885|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
  886|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96] = t;
  887|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  888|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  889|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  890|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  891|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96);
  892|       |      }
  893|       |      else if constexpr (N == 98) {
  894|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  895|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  896|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  897|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
  898|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97] = t;
  899|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  900|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  901|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  902|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  903|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
  904|       |                         p97);
  905|       |      }
  906|       |      else if constexpr (N == 99) {
  907|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  908|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  909|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  910|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
  911|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98] = t;
  912|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  913|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  914|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  915|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  916|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
  917|       |                         p97, p98);
  918|       |      }
  919|       |      else if constexpr (N == 100) {
  920|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  921|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  922|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  923|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
  924|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99] = t;
  925|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  926|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  927|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  928|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  929|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
  930|       |                         p97, p98, p99);
  931|       |      }
  932|       |      else if constexpr (N == 101) {
  933|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  934|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  935|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  936|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
  937|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100] = t;
  938|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  939|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  940|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  941|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  942|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
  943|       |                         p97, p98, p99, p100);
  944|       |      }
  945|       |      else if constexpr (N == 102) {
  946|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  947|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  948|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  949|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
  950|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101] = t;
  951|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  952|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  953|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  954|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  955|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
  956|       |                         p97, p98, p99, p100, p101);
  957|       |      }
  958|       |      else if constexpr (N == 103) {
  959|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  960|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  961|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  962|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
  963|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102] = t;
  964|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  965|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  966|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  967|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  968|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
  969|       |                         p97, p98, p99, p100, p101, p102);
  970|       |      }
  971|       |      else if constexpr (N == 104) {
  972|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  973|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  974|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  975|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
  976|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103] = t;
  977|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  978|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  979|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  980|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  981|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
  982|       |                         p97, p98, p99, p100, p101, p102, p103);
  983|       |      }
  984|       |      else if constexpr (N == 105) {
  985|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  986|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  987|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  988|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
  989|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104] = t;
  990|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  991|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  992|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  993|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  994|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
  995|       |                         p97, p98, p99, p100, p101, p102, p103, p104);
  996|       |      }
  997|       |      else if constexpr (N == 106) {
  998|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  999|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1000|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1001|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1002|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1003|       |                p105] = t;
 1004|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1005|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1006|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1007|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1008|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1009|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105);
 1010|       |      }
 1011|       |      else if constexpr (N == 107) {
 1012|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
 1013|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1014|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1015|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1016|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1017|       |                p105, p106] = t;
 1018|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1019|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1020|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1021|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1022|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1023|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106);
 1024|       |      }
 1025|       |      else if constexpr (N == 108) {
 1026|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
 1027|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1028|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1029|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1030|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1031|       |                p105, p106, p107] = t;
 1032|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1033|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1034|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1035|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1036|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1037|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107);
 1038|       |      }
 1039|       |      else if constexpr (N == 109) {
 1040|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
 1041|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1042|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1043|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1044|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1045|       |                p105, p106, p107, p108] = t;
 1046|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1047|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1048|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1049|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1050|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1051|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108);
 1052|       |      }
 1053|       |      else if constexpr (N == 110) {
 1054|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
 1055|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1056|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1057|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1058|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1059|       |                p105, p106, p107, p108, p109] = t;
 1060|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1061|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1062|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1063|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1064|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1065|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109);
 1066|       |      }
 1067|       |      else if constexpr (N == 111) {
 1068|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
 1069|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1070|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1071|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1072|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1073|       |                p105, p106, p107, p108, p109, p110] = t;
 1074|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1075|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1076|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1077|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1078|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1079|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110);
 1080|       |      }
 1081|       |      else if constexpr (N == 112) {
 1082|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
 1083|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1084|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1085|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1086|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1087|       |                p105, p106, p107, p108, p109, p110, p111] = t;
 1088|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1089|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1090|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1091|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1092|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1093|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111);
 1094|       |      }
 1095|       |      else if constexpr (N == 113) {
 1096|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
 1097|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1098|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1099|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1100|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1101|       |                p105, p106, p107, p108, p109, p110, p111, p112] = t;
 1102|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1103|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1104|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1105|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1106|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1107|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112);
 1108|       |      }
 1109|       |      else if constexpr (N == 114) {
 1110|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
 1111|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1112|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1113|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1114|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1115|       |                p105, p106, p107, p108, p109, p110, p111, p112, p113] = t;
 1116|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1117|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1118|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1119|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1120|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1121|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112,
 1122|       |                         p113);
 1123|       |      }
 1124|       |      else if constexpr (N == 115) {
 1125|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
 1126|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1127|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1128|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1129|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1130|       |                p105, p106, p107, p108, p109, p110, p111, p112, p113, p114] = t;
 1131|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1132|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1133|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1134|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1135|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1136|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112,
 1137|       |                         p113, p114);
 1138|       |      }
 1139|       |      else if constexpr (N == 116) {
 1140|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
 1141|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1142|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1143|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1144|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1145|       |                p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115] = t;
 1146|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1147|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1148|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1149|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1150|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1151|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112,
 1152|       |                         p113, p114, p115);
 1153|       |      }
 1154|       |      else if constexpr (N == 117) {
 1155|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
 1156|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1157|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1158|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1159|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1160|       |                p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116] = t;
 1161|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1162|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1163|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1164|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1165|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1166|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112,
 1167|       |                         p113, p114, p115, p116);
 1168|       |      }
 1169|       |      else if constexpr (N == 118) {
 1170|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
 1171|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1172|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1173|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1174|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1175|       |                p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117] = t;
 1176|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1177|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1178|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1179|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1180|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1181|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112,
 1182|       |                         p113, p114, p115, p116, p117);
 1183|       |      }
 1184|       |      else if constexpr (N == 119) {
 1185|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
 1186|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1187|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1188|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1189|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1190|       |                p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118] = t;
 1191|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1192|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1193|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1194|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1195|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1196|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112,
 1197|       |                         p113, p114, p115, p116, p117, p118);
 1198|       |      }
 1199|       |      else if constexpr (N == 120) {
 1200|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
 1201|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1202|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1203|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1204|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1205|       |                p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119] = t;
 1206|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1207|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1208|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1209|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1210|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1211|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112,
 1212|       |                         p113, p114, p115, p116, p117, p118, p119);
 1213|       |      }
 1214|       |      else if constexpr (N == 121) {
 1215|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
 1216|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1217|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1218|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1219|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1220|       |                p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119, p120] = t;
 1221|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1222|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1223|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1224|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1225|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1226|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112,
 1227|       |                         p113, p114, p115, p116, p117, p118, p119, p120);
 1228|       |      }
 1229|       |      else if constexpr (N == 122) {
 1230|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
 1231|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1232|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1233|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1234|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1235|       |                p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119, p120, p121] =
 1236|       |            t;
 1237|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1238|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1239|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1240|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1241|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1242|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112,
 1243|       |                         p113, p114, p115, p116, p117, p118, p119, p120, p121);
 1244|       |      }
 1245|       |      else if constexpr (N == 123) {
 1246|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
 1247|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1248|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1249|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1250|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1251|       |                p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119, p120, p121,
 1252|       |                p122] = t;
 1253|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1254|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1255|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1256|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1257|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1258|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112,
 1259|       |                         p113, p114, p115, p116, p117, p118, p119, p120, p121, p122);
 1260|       |      }
 1261|       |      else if constexpr (N == 124) {
 1262|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
 1263|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1264|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1265|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1266|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1267|       |                p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119, p120, p121,
 1268|       |                p122, p123] = t;
 1269|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1270|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1271|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1272|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1273|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1274|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112,
 1275|       |                         p113, p114, p115, p116, p117, p118, p119, p120, p121, p122, p123);
 1276|       |      }
 1277|       |      else if constexpr (N == 125) {
 1278|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
 1279|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1280|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1281|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1282|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1283|       |                p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119, p120, p121,
 1284|       |                p122, p123, p124] = t;
 1285|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1286|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1287|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1288|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1289|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1290|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112,
 1291|       |                         p113, p114, p115, p116, p117, p118, p119, p120, p121, p122, p123, p124);
 1292|       |      }
 1293|       |      else if constexpr (N == 126) {
 1294|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
 1295|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1296|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1297|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1298|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1299|       |                p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119, p120, p121,
 1300|       |                p122, p123, p124, p125] = t;
 1301|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1302|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1303|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1304|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1305|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1306|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112,
 1307|       |                         p113, p114, p115, p116, p117, p118, p119, p120, p121, p122, p123, p124, p125);
 1308|       |      }
 1309|       |      else if constexpr (N == 127) {
 1310|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
 1311|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1312|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1313|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1314|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1315|       |                p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119, p120, p121,
 1316|       |                p122, p123, p124, p125, p126] = t;
 1317|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1318|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1319|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1320|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1321|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1322|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112,
 1323|       |                         p113, p114, p115, p116, p117, p118, p119, p120, p121, p122, p123, p124, p125, p126);
 1324|       |      }
 1325|       |      else if constexpr (N == 128) {
 1326|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
 1327|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1328|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1329|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1330|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1331|       |                p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119, p120, p121,
 1332|       |                p122, p123, p124, p125, p126, p127] = t;
 1333|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1334|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1335|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1336|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1337|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1338|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112,
 1339|       |                         p113, p114, p115, p116, p117, p118, p119, p120, p121, p122, p123, p124, p125, p126, p127);
 1340|       |      }
 1341|  88.9k|   }
_ZN3glz6to_tieIRN12jsonrpc_fuzz6nestedELm2EQleT0_L_ZNS_6detail25max_pure_reflection_countEEEEDcOT_:
  137|  74.1k|   {
  138|       |      if constexpr (N == 0) {
  139|       |         return tuple{};
  140|       |      }
  141|       |      else if constexpr (N == 1) {
  142|       |         auto& [p] = t;
  143|       |         return glz::tie(p);
  144|       |      }
  145|  74.1k|      else if constexpr (N == 2) {
  146|  74.1k|         auto& [p0, p1] = t;
  147|  74.1k|         return glz::tie(p0, p1);
  148|       |      }
  149|       |      else if constexpr (N == 3) {
  150|       |         auto& [p0, p1, p2] = t;
  151|       |         return glz::tie(p0, p1, p2);
  152|       |      }
  153|       |      else if constexpr (N == 4) {
  154|       |         auto& [p0, p1, p2, p3] = t;
  155|       |         return glz::tie(p0, p1, p2, p3);
  156|       |      }
  157|       |      else if constexpr (N == 5) {
  158|       |         auto& [p0, p1, p2, p3, p4] = t;
  159|       |         return glz::tie(p0, p1, p2, p3, p4);
  160|       |      }
  161|       |      else if constexpr (N == 6) {
  162|       |         auto& [p0, p1, p2, p3, p4, p5] = t;
  163|       |         return glz::tie(p0, p1, p2, p3, p4, p5);
  164|       |      }
  165|       |      else if constexpr (N == 7) {
  166|       |         auto& [p0, p1, p2, p3, p4, p5, p6] = t;
  167|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6);
  168|       |      }
  169|       |      else if constexpr (N == 8) {
  170|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7] = t;
  171|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7);
  172|       |      }
  173|       |      else if constexpr (N == 9) {
  174|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8] = t;
  175|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8);
  176|       |      }
  177|       |      else if constexpr (N == 10) {
  178|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9] = t;
  179|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9);
  180|       |      }
  181|       |      else if constexpr (N == 11) {
  182|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10] = t;
  183|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10);
  184|       |      }
  185|       |      else if constexpr (N == 12) {
  186|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11] = t;
  187|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11);
  188|       |      }
  189|       |      else if constexpr (N == 13) {
  190|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12] = t;
  191|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12);
  192|       |      }
  193|       |      else if constexpr (N == 14) {
  194|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13] = t;
  195|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13);
  196|       |      }
  197|       |      else if constexpr (N == 15) {
  198|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14] = t;
  199|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14);
  200|       |      }
  201|       |      else if constexpr (N == 16) {
  202|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15] = t;
  203|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15);
  204|       |      }
  205|       |      else if constexpr (N == 17) {
  206|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16] = t;
  207|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16);
  208|       |      }
  209|       |      else if constexpr (N == 18) {
  210|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17] = t;
  211|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17);
  212|       |      }
  213|       |      else if constexpr (N == 19) {
  214|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18] = t;
  215|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18);
  216|       |      }
  217|       |      else if constexpr (N == 20) {
  218|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19] = t;
  219|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19);
  220|       |      }
  221|       |      else if constexpr (N == 21) {
  222|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20] = t;
  223|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20);
  224|       |      }
  225|       |      else if constexpr (N == 22) {
  226|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21] = t;
  227|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  228|       |                         p21);
  229|       |      }
  230|       |      else if constexpr (N == 23) {
  231|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
  232|       |                p22] = t;
  233|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  234|       |                         p21, p22);
  235|       |      }
  236|       |      else if constexpr (N == 24) {
  237|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  238|       |                p23] = t;
  239|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  240|       |                         p21, p22, p23);
  241|       |      }
  242|       |      else if constexpr (N == 25) {
  243|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  244|       |                p23, p24] = t;
  245|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  246|       |                         p21, p22, p23, p24);
  247|       |      }
  248|       |      else if constexpr (N == 26) {
  249|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  250|       |                p23, p24, p25] = t;
  251|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  252|       |                         p21, p22, p23, p24, p25);
  253|       |      }
  254|       |      else if constexpr (N == 27) {
  255|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  256|       |                p23, p24, p25, p26] = t;
  257|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  258|       |                         p21, p22, p23, p24, p25, p26);
  259|       |      }
  260|       |      else if constexpr (N == 28) {
  261|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  262|       |                p23, p24, p25, p26, p27] = t;
  263|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  264|       |                         p21, p22, p23, p24, p25, p26, p27);
  265|       |      }
  266|       |      else if constexpr (N == 29) {
  267|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  268|       |                p23, p24, p25, p26, p27, p28] = t;
  269|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  270|       |                         p21, p22, p23, p24, p25, p26, p27, p28);
  271|       |      }
  272|       |      else if constexpr (N == 30) {
  273|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  274|       |                p23, p24, p25, p26, p27, p28, p29] = t;
  275|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  276|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29);
  277|       |      }
  278|       |      else if constexpr (N == 31) {
  279|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  280|       |                p23, p24, p25, p26, p27, p28, p29, p30] = t;
  281|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  282|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30);
  283|       |      }
  284|       |      else if constexpr (N == 32) {
  285|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  286|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31] = t;
  287|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  288|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31);
  289|       |      }
  290|       |      else if constexpr (N == 33) {
  291|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  292|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32] = t;
  293|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  294|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32);
  295|       |      }
  296|       |      else if constexpr (N == 34) {
  297|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  298|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33] = t;
  299|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  300|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33);
  301|       |      }
  302|       |      else if constexpr (N == 35) {
  303|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  304|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34] = t;
  305|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  306|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34);
  307|       |      }
  308|       |      else if constexpr (N == 36) {
  309|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  310|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35] = t;
  311|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  312|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35);
  313|       |      }
  314|       |      else if constexpr (N == 37) {
  315|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  316|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36] = t;
  317|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  318|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36);
  319|       |      }
  320|       |      else if constexpr (N == 38) {
  321|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  322|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37] = t;
  323|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  324|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37);
  325|       |      }
  326|       |      else if constexpr (N == 39) {
  327|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  328|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38] = t;
  329|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  330|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38);
  331|       |      }
  332|       |      else if constexpr (N == 40) {
  333|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  334|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39] = t;
  335|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  336|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39);
  337|       |      }
  338|       |      else if constexpr (N == 41) {
  339|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  340|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40] = t;
  341|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  342|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  343|       |                         p40);
  344|       |      }
  345|       |      else if constexpr (N == 42) {
  346|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  347|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41] = t;
  348|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  349|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  350|       |                         p40, p41);
  351|       |      }
  352|       |      else if constexpr (N == 43) {
  353|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  354|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42] = t;
  355|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  356|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  357|       |                         p40, p41, p42);
  358|       |      }
  359|       |      else if constexpr (N == 44) {
  360|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  361|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42,
  362|       |                p43] = t;
  363|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  364|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  365|       |                         p40, p41, p42, p43);
  366|       |      }
  367|       |      else if constexpr (N == 45) {
  368|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  369|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  370|       |                p44] = t;
  371|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  372|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  373|       |                         p40, p41, p42, p43, p44);
  374|       |      }
  375|       |      else if constexpr (N == 46) {
  376|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  377|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  378|       |                p44, p45] = t;
  379|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  380|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  381|       |                         p40, p41, p42, p43, p44, p45);
  382|       |      }
  383|       |      else if constexpr (N == 47) {
  384|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  385|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  386|       |                p44, p45, p46] = t;
  387|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  388|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  389|       |                         p40, p41, p42, p43, p44, p45, p46);
  390|       |      }
  391|       |      else if constexpr (N == 48) {
  392|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  393|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  394|       |                p44, p45, p46, p47] = t;
  395|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  396|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  397|       |                         p40, p41, p42, p43, p44, p45, p46, p47);
  398|       |      }
  399|       |      else if constexpr (N == 49) {
  400|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  401|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  402|       |                p44, p45, p46, p47, p48] = t;
  403|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  404|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  405|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48);
  406|       |      }
  407|       |      else if constexpr (N == 50) {
  408|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  409|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  410|       |                p44, p45, p46, p47, p48, p49] = t;
  411|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  412|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  413|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49);
  414|       |      }
  415|       |      else if constexpr (N == 51) {
  416|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  417|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  418|       |                p44, p45, p46, p47, p48, p49, p50] = t;
  419|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  420|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  421|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50);
  422|       |      }
  423|       |      else if constexpr (N == 52) {
  424|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  425|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  426|       |                p44, p45, p46, p47, p48, p49, p50, p51] = t;
  427|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  428|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  429|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51);
  430|       |      }
  431|       |      else if constexpr (N == 53) {
  432|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  433|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  434|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52] = t;
  435|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  436|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  437|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52);
  438|       |      }
  439|       |      else if constexpr (N == 54) {
  440|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  441|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  442|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53] = t;
  443|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  444|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  445|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53);
  446|       |      }
  447|       |      else if constexpr (N == 55) {
  448|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  449|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  450|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54] = t;
  451|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  452|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  453|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54);
  454|       |      }
  455|       |      else if constexpr (N == 56) {
  456|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  457|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  458|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55] = t;
  459|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  460|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  461|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55);
  462|       |      }
  463|       |      else if constexpr (N == 57) {
  464|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  465|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  466|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56] = t;
  467|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  468|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  469|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56);
  470|       |      }
  471|       |      else if constexpr (N == 58) {
  472|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  473|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  474|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57] = t;
  475|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  476|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  477|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57);
  478|       |      }
  479|       |      else if constexpr (N == 59) {
  480|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  481|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  482|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58] = t;
  483|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  484|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  485|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58);
  486|       |      }
  487|       |      else if constexpr (N == 60) {
  488|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  489|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  490|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59] = t;
  491|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  492|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  493|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  494|       |                         p59);
  495|       |      }
  496|       |      else if constexpr (N == 61) {
  497|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  498|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  499|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60] = t;
  500|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  501|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  502|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  503|       |                         p59, p60);
  504|       |      }
  505|       |      else if constexpr (N == 62) {
  506|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  507|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  508|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61] = t;
  509|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  510|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  511|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  512|       |                         p59, p60, p61);
  513|       |      }
  514|       |      else if constexpr (N == 63) {
  515|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  516|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  517|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62] = t;
  518|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  519|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  520|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  521|       |                         p59, p60, p61, p62);
  522|       |      }
  523|       |      else if constexpr (N == 64) {
  524|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  525|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  526|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63] = t;
  527|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  528|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  529|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  530|       |                         p59, p60, p61, p62, p63);
  531|       |      }
  532|       |      else if constexpr (N == 65) {
  533|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  534|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  535|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63,
  536|       |                p64] = t;
  537|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  538|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  539|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  540|       |                         p59, p60, p61, p62, p63, p64);
  541|       |      }
  542|       |      else if constexpr (N == 66) {
  543|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  544|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  545|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  546|       |                p65] = t;
  547|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  548|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  549|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  550|       |                         p59, p60, p61, p62, p63, p64, p65);
  551|       |      }
  552|       |      else if constexpr (N == 67) {
  553|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  554|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  555|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  556|       |                p65, p66] = t;
  557|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  558|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  559|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  560|       |                         p59, p60, p61, p62, p63, p64, p65, p66);
  561|       |      }
  562|       |      else if constexpr (N == 68) {
  563|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  564|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  565|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  566|       |                p65, p66, p67] = t;
  567|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  568|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  569|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  570|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67);
  571|       |      }
  572|       |      else if constexpr (N == 69) {
  573|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  574|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  575|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  576|       |                p65, p66, p67, p68] = t;
  577|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  578|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  579|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  580|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68);
  581|       |      }
  582|       |      else if constexpr (N == 70) {
  583|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  584|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  585|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  586|       |                p65, p66, p67, p68, p69] = t;
  587|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  588|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  589|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  590|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69);
  591|       |      }
  592|       |      else if constexpr (N == 71) {
  593|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  594|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  595|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  596|       |                p65, p66, p67, p68, p69, p70] = t;
  597|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  598|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  599|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  600|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70);
  601|       |      }
  602|       |      else if constexpr (N == 72) {
  603|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  604|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  605|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  606|       |                p65, p66, p67, p68, p69, p70, p71] = t;
  607|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  608|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  609|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  610|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71);
  611|       |      }
  612|       |      else if constexpr (N == 73) {
  613|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  614|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  615|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  616|       |                p65, p66, p67, p68, p69, p70, p71, p72] = t;
  617|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  618|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  619|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  620|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72);
  621|       |      }
  622|       |      else if constexpr (N == 74) {
  623|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  624|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  625|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  626|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73] = t;
  627|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  628|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  629|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  630|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73);
  631|       |      }
  632|       |      else if constexpr (N == 75) {
  633|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  634|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  635|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  636|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74] = t;
  637|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  638|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  639|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  640|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74);
  641|       |      }
  642|       |      else if constexpr (N == 76) {
  643|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  644|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  645|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  646|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75] = t;
  647|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  648|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  649|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  650|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75);
  651|       |      }
  652|       |      else if constexpr (N == 77) {
  653|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  654|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  655|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  656|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76] = t;
  657|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  658|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  659|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  660|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76);
  661|       |      }
  662|       |      else if constexpr (N == 78) {
  663|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  664|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  665|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  666|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77] = t;
  667|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  668|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  669|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  670|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77);
  671|       |      }
  672|       |      else if constexpr (N == 79) {
  673|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  674|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  675|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  676|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78] = t;
  677|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  678|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  679|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  680|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  681|       |                         p78);
  682|       |      }
  683|       |      else if constexpr (N == 80) {
  684|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  685|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  686|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  687|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79] = t;
  688|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  689|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  690|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  691|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  692|       |                         p78, p79);
  693|       |      }
  694|       |      else if constexpr (N == 81) {
  695|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  696|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  697|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  698|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80] = t;
  699|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  700|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  701|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  702|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  703|       |                         p78, p79, p80);
  704|       |      }
  705|       |      else if constexpr (N == 82) {
  706|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  707|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  708|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  709|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81] = t;
  710|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  711|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  712|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  713|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  714|       |                         p78, p79, p80, p81);
  715|       |      }
  716|       |      else if constexpr (N == 83) {
  717|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  718|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  719|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  720|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82] = t;
  721|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  722|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  723|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  724|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  725|       |                         p78, p79, p80, p81, p82);
  726|       |      }
  727|       |      else if constexpr (N == 84) {
  728|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  729|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  730|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  731|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83] = t;
  732|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  733|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  734|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  735|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  736|       |                         p78, p79, p80, p81, p82, p83);
  737|       |      }
  738|       |      else if constexpr (N == 85) {
  739|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  740|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  741|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  742|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84] = t;
  743|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  744|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  745|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  746|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  747|       |                         p78, p79, p80, p81, p82, p83, p84);
  748|       |      }
  749|       |      else if constexpr (N == 86) {
  750|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  751|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  752|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  753|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84,
  754|       |                p85] = t;
  755|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  756|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  757|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  758|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  759|       |                         p78, p79, p80, p81, p82, p83, p84, p85);
  760|       |      }
  761|       |      else if constexpr (N == 87) {
  762|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  763|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  764|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  765|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
  766|       |                p86] = t;
  767|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  768|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  769|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  770|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  771|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86);
  772|       |      }
  773|       |      else if constexpr (N == 88) {
  774|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  775|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  776|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  777|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
  778|       |                p86, p87] = t;
  779|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  780|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  781|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  782|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  783|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87);
  784|       |      }
  785|       |      else if constexpr (N == 89) {
  786|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  787|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  788|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  789|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
  790|       |                p86, p87, p88] = t;
  791|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  792|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  793|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  794|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  795|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88);
  796|       |      }
  797|       |      else if constexpr (N == 90) {
  798|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  799|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  800|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  801|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
  802|       |                p86, p87, p88, p89] = t;
  803|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  804|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  805|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  806|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  807|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89);
  808|       |      }
  809|       |      else if constexpr (N == 91) {
  810|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  811|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  812|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  813|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
  814|       |                p86, p87, p88, p89, p90] = t;
  815|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  816|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  817|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  818|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  819|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90);
  820|       |      }
  821|       |      else if constexpr (N == 92) {
  822|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  823|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  824|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  825|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
  826|       |                p86, p87, p88, p89, p90, p91] = t;
  827|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  828|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  829|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  830|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  831|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91);
  832|       |      }
  833|       |      else if constexpr (N == 93) {
  834|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  835|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  836|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  837|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
  838|       |                p86, p87, p88, p89, p90, p91, p92] = t;
  839|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  840|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  841|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  842|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  843|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92);
  844|       |      }
  845|       |      else if constexpr (N == 94) {
  846|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  847|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  848|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  849|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
  850|       |                p86, p87, p88, p89, p90, p91, p92, p93] = t;
  851|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  852|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  853|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  854|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  855|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93);
  856|       |      }
  857|       |      else if constexpr (N == 95) {
  858|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  859|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  860|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  861|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
  862|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94] = t;
  863|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  864|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  865|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  866|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  867|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94);
  868|       |      }
  869|       |      else if constexpr (N == 96) {
  870|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  871|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  872|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  873|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
  874|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95] = t;
  875|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  876|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  877|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  878|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  879|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95);
  880|       |      }
  881|       |      else if constexpr (N == 97) {
  882|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  883|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  884|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  885|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
  886|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96] = t;
  887|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  888|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  889|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  890|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  891|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96);
  892|       |      }
  893|       |      else if constexpr (N == 98) {
  894|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  895|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  896|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  897|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
  898|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97] = t;
  899|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  900|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  901|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  902|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  903|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
  904|       |                         p97);
  905|       |      }
  906|       |      else if constexpr (N == 99) {
  907|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  908|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  909|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  910|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
  911|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98] = t;
  912|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  913|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  914|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  915|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  916|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
  917|       |                         p97, p98);
  918|       |      }
  919|       |      else if constexpr (N == 100) {
  920|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  921|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  922|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  923|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
  924|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99] = t;
  925|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  926|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  927|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  928|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  929|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
  930|       |                         p97, p98, p99);
  931|       |      }
  932|       |      else if constexpr (N == 101) {
  933|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  934|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  935|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  936|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
  937|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100] = t;
  938|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  939|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  940|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  941|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  942|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
  943|       |                         p97, p98, p99, p100);
  944|       |      }
  945|       |      else if constexpr (N == 102) {
  946|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  947|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  948|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  949|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
  950|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101] = t;
  951|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  952|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  953|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  954|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  955|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
  956|       |                         p97, p98, p99, p100, p101);
  957|       |      }
  958|       |      else if constexpr (N == 103) {
  959|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  960|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  961|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  962|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
  963|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102] = t;
  964|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  965|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  966|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  967|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  968|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
  969|       |                         p97, p98, p99, p100, p101, p102);
  970|       |      }
  971|       |      else if constexpr (N == 104) {
  972|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  973|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  974|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  975|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
  976|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103] = t;
  977|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  978|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  979|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  980|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  981|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
  982|       |                         p97, p98, p99, p100, p101, p102, p103);
  983|       |      }
  984|       |      else if constexpr (N == 105) {
  985|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  986|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  987|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  988|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
  989|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104] = t;
  990|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  991|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  992|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  993|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  994|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
  995|       |                         p97, p98, p99, p100, p101, p102, p103, p104);
  996|       |      }
  997|       |      else if constexpr (N == 106) {
  998|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  999|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1000|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1001|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1002|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1003|       |                p105] = t;
 1004|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1005|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1006|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1007|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1008|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1009|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105);
 1010|       |      }
 1011|       |      else if constexpr (N == 107) {
 1012|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
 1013|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1014|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1015|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1016|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1017|       |                p105, p106] = t;
 1018|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1019|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1020|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1021|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1022|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1023|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106);
 1024|       |      }
 1025|       |      else if constexpr (N == 108) {
 1026|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
 1027|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1028|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1029|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1030|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1031|       |                p105, p106, p107] = t;
 1032|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1033|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1034|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1035|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1036|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1037|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107);
 1038|       |      }
 1039|       |      else if constexpr (N == 109) {
 1040|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
 1041|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1042|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1043|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1044|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1045|       |                p105, p106, p107, p108] = t;
 1046|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1047|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1048|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1049|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1050|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1051|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108);
 1052|       |      }
 1053|       |      else if constexpr (N == 110) {
 1054|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
 1055|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1056|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1057|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1058|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1059|       |                p105, p106, p107, p108, p109] = t;
 1060|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1061|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1062|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1063|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1064|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1065|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109);
 1066|       |      }
 1067|       |      else if constexpr (N == 111) {
 1068|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
 1069|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1070|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1071|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1072|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1073|       |                p105, p106, p107, p108, p109, p110] = t;
 1074|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1075|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1076|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1077|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1078|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1079|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110);
 1080|       |      }
 1081|       |      else if constexpr (N == 112) {
 1082|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
 1083|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1084|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1085|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1086|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1087|       |                p105, p106, p107, p108, p109, p110, p111] = t;
 1088|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1089|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1090|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1091|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1092|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1093|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111);
 1094|       |      }
 1095|       |      else if constexpr (N == 113) {
 1096|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
 1097|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1098|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1099|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1100|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1101|       |                p105, p106, p107, p108, p109, p110, p111, p112] = t;
 1102|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1103|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1104|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1105|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1106|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1107|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112);
 1108|       |      }
 1109|       |      else if constexpr (N == 114) {
 1110|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
 1111|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1112|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1113|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1114|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1115|       |                p105, p106, p107, p108, p109, p110, p111, p112, p113] = t;
 1116|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1117|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1118|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1119|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1120|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1121|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112,
 1122|       |                         p113);
 1123|       |      }
 1124|       |      else if constexpr (N == 115) {
 1125|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
 1126|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1127|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1128|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1129|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1130|       |                p105, p106, p107, p108, p109, p110, p111, p112, p113, p114] = t;
 1131|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1132|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1133|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1134|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1135|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1136|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112,
 1137|       |                         p113, p114);
 1138|       |      }
 1139|       |      else if constexpr (N == 116) {
 1140|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
 1141|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1142|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1143|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1144|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1145|       |                p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115] = t;
 1146|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1147|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1148|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1149|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1150|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1151|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112,
 1152|       |                         p113, p114, p115);
 1153|       |      }
 1154|       |      else if constexpr (N == 117) {
 1155|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
 1156|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1157|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1158|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1159|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1160|       |                p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116] = t;
 1161|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1162|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1163|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1164|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1165|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1166|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112,
 1167|       |                         p113, p114, p115, p116);
 1168|       |      }
 1169|       |      else if constexpr (N == 118) {
 1170|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
 1171|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1172|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1173|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1174|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1175|       |                p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117] = t;
 1176|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1177|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1178|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1179|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1180|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1181|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112,
 1182|       |                         p113, p114, p115, p116, p117);
 1183|       |      }
 1184|       |      else if constexpr (N == 119) {
 1185|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
 1186|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1187|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1188|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1189|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1190|       |                p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118] = t;
 1191|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1192|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1193|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1194|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1195|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1196|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112,
 1197|       |                         p113, p114, p115, p116, p117, p118);
 1198|       |      }
 1199|       |      else if constexpr (N == 120) {
 1200|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
 1201|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1202|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1203|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1204|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1205|       |                p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119] = t;
 1206|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1207|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1208|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1209|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1210|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1211|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112,
 1212|       |                         p113, p114, p115, p116, p117, p118, p119);
 1213|       |      }
 1214|       |      else if constexpr (N == 121) {
 1215|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
 1216|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1217|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1218|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1219|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1220|       |                p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119, p120] = t;
 1221|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1222|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1223|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1224|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1225|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1226|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112,
 1227|       |                         p113, p114, p115, p116, p117, p118, p119, p120);
 1228|       |      }
 1229|       |      else if constexpr (N == 122) {
 1230|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
 1231|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1232|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1233|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1234|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1235|       |                p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119, p120, p121] =
 1236|       |            t;
 1237|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1238|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1239|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1240|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1241|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1242|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112,
 1243|       |                         p113, p114, p115, p116, p117, p118, p119, p120, p121);
 1244|       |      }
 1245|       |      else if constexpr (N == 123) {
 1246|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
 1247|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1248|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1249|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1250|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1251|       |                p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119, p120, p121,
 1252|       |                p122] = t;
 1253|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1254|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1255|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1256|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1257|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1258|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112,
 1259|       |                         p113, p114, p115, p116, p117, p118, p119, p120, p121, p122);
 1260|       |      }
 1261|       |      else if constexpr (N == 124) {
 1262|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
 1263|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1264|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1265|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1266|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1267|       |                p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119, p120, p121,
 1268|       |                p122, p123] = t;
 1269|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1270|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1271|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1272|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1273|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1274|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112,
 1275|       |                         p113, p114, p115, p116, p117, p118, p119, p120, p121, p122, p123);
 1276|       |      }
 1277|       |      else if constexpr (N == 125) {
 1278|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
 1279|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1280|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1281|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1282|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1283|       |                p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119, p120, p121,
 1284|       |                p122, p123, p124] = t;
 1285|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1286|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1287|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1288|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1289|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1290|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112,
 1291|       |                         p113, p114, p115, p116, p117, p118, p119, p120, p121, p122, p123, p124);
 1292|       |      }
 1293|       |      else if constexpr (N == 126) {
 1294|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
 1295|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1296|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1297|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1298|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1299|       |                p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119, p120, p121,
 1300|       |                p122, p123, p124, p125] = t;
 1301|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1302|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1303|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1304|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1305|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1306|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112,
 1307|       |                         p113, p114, p115, p116, p117, p118, p119, p120, p121, p122, p123, p124, p125);
 1308|       |      }
 1309|       |      else if constexpr (N == 127) {
 1310|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
 1311|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1312|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1313|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1314|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1315|       |                p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119, p120, p121,
 1316|       |                p122, p123, p124, p125, p126] = t;
 1317|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1318|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1319|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1320|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1321|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1322|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112,
 1323|       |                         p113, p114, p115, p116, p117, p118, p119, p120, p121, p122, p123, p124, p125, p126);
 1324|       |      }
 1325|       |      else if constexpr (N == 128) {
 1326|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
 1327|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1328|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1329|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1330|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1331|       |                p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119, p120, p121,
 1332|       |                p122, p123, p124, p125, p126, p127] = t;
 1333|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1334|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1335|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1336|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1337|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1338|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112,
 1339|       |                         p113, p114, p115, p116, p117, p118, p119, p120, p121, p122, p123, p124, p125, p126, p127);
 1340|       |      }
 1341|  74.1k|   }
_ZN3glz6to_tieIRN12jsonrpc_fuzz6amountELm1EQleT0_L_ZNS_6detail25max_pure_reflection_countEEEEDcOT_:
  137|    303|   {
  138|       |      if constexpr (N == 0) {
  139|       |         return tuple{};
  140|       |      }
  141|    303|      else if constexpr (N == 1) {
  142|    303|         auto& [p] = t;
  143|    303|         return glz::tie(p);
  144|       |      }
  145|       |      else if constexpr (N == 2) {
  146|       |         auto& [p0, p1] = t;
  147|       |         return glz::tie(p0, p1);
  148|       |      }
  149|       |      else if constexpr (N == 3) {
  150|       |         auto& [p0, p1, p2] = t;
  151|       |         return glz::tie(p0, p1, p2);
  152|       |      }
  153|       |      else if constexpr (N == 4) {
  154|       |         auto& [p0, p1, p2, p3] = t;
  155|       |         return glz::tie(p0, p1, p2, p3);
  156|       |      }
  157|       |      else if constexpr (N == 5) {
  158|       |         auto& [p0, p1, p2, p3, p4] = t;
  159|       |         return glz::tie(p0, p1, p2, p3, p4);
  160|       |      }
  161|       |      else if constexpr (N == 6) {
  162|       |         auto& [p0, p1, p2, p3, p4, p5] = t;
  163|       |         return glz::tie(p0, p1, p2, p3, p4, p5);
  164|       |      }
  165|       |      else if constexpr (N == 7) {
  166|       |         auto& [p0, p1, p2, p3, p4, p5, p6] = t;
  167|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6);
  168|       |      }
  169|       |      else if constexpr (N == 8) {
  170|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7] = t;
  171|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7);
  172|       |      }
  173|       |      else if constexpr (N == 9) {
  174|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8] = t;
  175|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8);
  176|       |      }
  177|       |      else if constexpr (N == 10) {
  178|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9] = t;
  179|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9);
  180|       |      }
  181|       |      else if constexpr (N == 11) {
  182|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10] = t;
  183|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10);
  184|       |      }
  185|       |      else if constexpr (N == 12) {
  186|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11] = t;
  187|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11);
  188|       |      }
  189|       |      else if constexpr (N == 13) {
  190|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12] = t;
  191|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12);
  192|       |      }
  193|       |      else if constexpr (N == 14) {
  194|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13] = t;
  195|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13);
  196|       |      }
  197|       |      else if constexpr (N == 15) {
  198|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14] = t;
  199|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14);
  200|       |      }
  201|       |      else if constexpr (N == 16) {
  202|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15] = t;
  203|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15);
  204|       |      }
  205|       |      else if constexpr (N == 17) {
  206|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16] = t;
  207|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16);
  208|       |      }
  209|       |      else if constexpr (N == 18) {
  210|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17] = t;
  211|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17);
  212|       |      }
  213|       |      else if constexpr (N == 19) {
  214|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18] = t;
  215|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18);
  216|       |      }
  217|       |      else if constexpr (N == 20) {
  218|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19] = t;
  219|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19);
  220|       |      }
  221|       |      else if constexpr (N == 21) {
  222|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20] = t;
  223|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20);
  224|       |      }
  225|       |      else if constexpr (N == 22) {
  226|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21] = t;
  227|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  228|       |                         p21);
  229|       |      }
  230|       |      else if constexpr (N == 23) {
  231|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21,
  232|       |                p22] = t;
  233|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  234|       |                         p21, p22);
  235|       |      }
  236|       |      else if constexpr (N == 24) {
  237|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  238|       |                p23] = t;
  239|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  240|       |                         p21, p22, p23);
  241|       |      }
  242|       |      else if constexpr (N == 25) {
  243|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  244|       |                p23, p24] = t;
  245|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  246|       |                         p21, p22, p23, p24);
  247|       |      }
  248|       |      else if constexpr (N == 26) {
  249|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  250|       |                p23, p24, p25] = t;
  251|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  252|       |                         p21, p22, p23, p24, p25);
  253|       |      }
  254|       |      else if constexpr (N == 27) {
  255|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  256|       |                p23, p24, p25, p26] = t;
  257|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  258|       |                         p21, p22, p23, p24, p25, p26);
  259|       |      }
  260|       |      else if constexpr (N == 28) {
  261|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  262|       |                p23, p24, p25, p26, p27] = t;
  263|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  264|       |                         p21, p22, p23, p24, p25, p26, p27);
  265|       |      }
  266|       |      else if constexpr (N == 29) {
  267|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  268|       |                p23, p24, p25, p26, p27, p28] = t;
  269|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  270|       |                         p21, p22, p23, p24, p25, p26, p27, p28);
  271|       |      }
  272|       |      else if constexpr (N == 30) {
  273|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  274|       |                p23, p24, p25, p26, p27, p28, p29] = t;
  275|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  276|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29);
  277|       |      }
  278|       |      else if constexpr (N == 31) {
  279|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  280|       |                p23, p24, p25, p26, p27, p28, p29, p30] = t;
  281|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  282|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30);
  283|       |      }
  284|       |      else if constexpr (N == 32) {
  285|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  286|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31] = t;
  287|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  288|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31);
  289|       |      }
  290|       |      else if constexpr (N == 33) {
  291|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  292|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32] = t;
  293|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  294|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32);
  295|       |      }
  296|       |      else if constexpr (N == 34) {
  297|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  298|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33] = t;
  299|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  300|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33);
  301|       |      }
  302|       |      else if constexpr (N == 35) {
  303|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  304|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34] = t;
  305|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  306|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34);
  307|       |      }
  308|       |      else if constexpr (N == 36) {
  309|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  310|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35] = t;
  311|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  312|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35);
  313|       |      }
  314|       |      else if constexpr (N == 37) {
  315|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  316|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36] = t;
  317|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  318|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36);
  319|       |      }
  320|       |      else if constexpr (N == 38) {
  321|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  322|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37] = t;
  323|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  324|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37);
  325|       |      }
  326|       |      else if constexpr (N == 39) {
  327|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  328|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38] = t;
  329|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  330|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38);
  331|       |      }
  332|       |      else if constexpr (N == 40) {
  333|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  334|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39] = t;
  335|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  336|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39);
  337|       |      }
  338|       |      else if constexpr (N == 41) {
  339|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  340|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40] = t;
  341|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  342|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  343|       |                         p40);
  344|       |      }
  345|       |      else if constexpr (N == 42) {
  346|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  347|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41] = t;
  348|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  349|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  350|       |                         p40, p41);
  351|       |      }
  352|       |      else if constexpr (N == 43) {
  353|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  354|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42] = t;
  355|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  356|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  357|       |                         p40, p41, p42);
  358|       |      }
  359|       |      else if constexpr (N == 44) {
  360|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  361|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42,
  362|       |                p43] = t;
  363|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  364|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  365|       |                         p40, p41, p42, p43);
  366|       |      }
  367|       |      else if constexpr (N == 45) {
  368|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  369|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  370|       |                p44] = t;
  371|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  372|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  373|       |                         p40, p41, p42, p43, p44);
  374|       |      }
  375|       |      else if constexpr (N == 46) {
  376|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  377|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  378|       |                p44, p45] = t;
  379|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  380|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  381|       |                         p40, p41, p42, p43, p44, p45);
  382|       |      }
  383|       |      else if constexpr (N == 47) {
  384|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  385|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  386|       |                p44, p45, p46] = t;
  387|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  388|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  389|       |                         p40, p41, p42, p43, p44, p45, p46);
  390|       |      }
  391|       |      else if constexpr (N == 48) {
  392|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  393|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  394|       |                p44, p45, p46, p47] = t;
  395|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  396|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  397|       |                         p40, p41, p42, p43, p44, p45, p46, p47);
  398|       |      }
  399|       |      else if constexpr (N == 49) {
  400|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  401|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  402|       |                p44, p45, p46, p47, p48] = t;
  403|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  404|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  405|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48);
  406|       |      }
  407|       |      else if constexpr (N == 50) {
  408|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  409|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  410|       |                p44, p45, p46, p47, p48, p49] = t;
  411|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  412|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  413|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49);
  414|       |      }
  415|       |      else if constexpr (N == 51) {
  416|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  417|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  418|       |                p44, p45, p46, p47, p48, p49, p50] = t;
  419|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  420|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  421|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50);
  422|       |      }
  423|       |      else if constexpr (N == 52) {
  424|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  425|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  426|       |                p44, p45, p46, p47, p48, p49, p50, p51] = t;
  427|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  428|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  429|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51);
  430|       |      }
  431|       |      else if constexpr (N == 53) {
  432|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  433|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  434|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52] = t;
  435|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  436|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  437|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52);
  438|       |      }
  439|       |      else if constexpr (N == 54) {
  440|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  441|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  442|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53] = t;
  443|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  444|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  445|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53);
  446|       |      }
  447|       |      else if constexpr (N == 55) {
  448|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  449|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  450|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54] = t;
  451|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  452|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  453|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54);
  454|       |      }
  455|       |      else if constexpr (N == 56) {
  456|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  457|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  458|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55] = t;
  459|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  460|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  461|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55);
  462|       |      }
  463|       |      else if constexpr (N == 57) {
  464|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  465|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  466|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56] = t;
  467|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  468|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  469|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56);
  470|       |      }
  471|       |      else if constexpr (N == 58) {
  472|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  473|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  474|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57] = t;
  475|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  476|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  477|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57);
  478|       |      }
  479|       |      else if constexpr (N == 59) {
  480|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  481|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  482|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58] = t;
  483|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  484|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  485|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58);
  486|       |      }
  487|       |      else if constexpr (N == 60) {
  488|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  489|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  490|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59] = t;
  491|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  492|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  493|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  494|       |                         p59);
  495|       |      }
  496|       |      else if constexpr (N == 61) {
  497|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  498|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  499|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60] = t;
  500|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  501|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  502|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  503|       |                         p59, p60);
  504|       |      }
  505|       |      else if constexpr (N == 62) {
  506|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  507|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  508|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61] = t;
  509|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  510|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  511|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  512|       |                         p59, p60, p61);
  513|       |      }
  514|       |      else if constexpr (N == 63) {
  515|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  516|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  517|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62] = t;
  518|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  519|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  520|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  521|       |                         p59, p60, p61, p62);
  522|       |      }
  523|       |      else if constexpr (N == 64) {
  524|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  525|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  526|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63] = t;
  527|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  528|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  529|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  530|       |                         p59, p60, p61, p62, p63);
  531|       |      }
  532|       |      else if constexpr (N == 65) {
  533|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  534|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  535|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63,
  536|       |                p64] = t;
  537|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  538|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  539|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  540|       |                         p59, p60, p61, p62, p63, p64);
  541|       |      }
  542|       |      else if constexpr (N == 66) {
  543|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  544|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  545|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  546|       |                p65] = t;
  547|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  548|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  549|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  550|       |                         p59, p60, p61, p62, p63, p64, p65);
  551|       |      }
  552|       |      else if constexpr (N == 67) {
  553|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  554|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  555|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  556|       |                p65, p66] = t;
  557|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  558|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  559|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  560|       |                         p59, p60, p61, p62, p63, p64, p65, p66);
  561|       |      }
  562|       |      else if constexpr (N == 68) {
  563|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  564|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  565|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  566|       |                p65, p66, p67] = t;
  567|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  568|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  569|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  570|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67);
  571|       |      }
  572|       |      else if constexpr (N == 69) {
  573|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  574|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  575|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  576|       |                p65, p66, p67, p68] = t;
  577|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  578|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  579|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  580|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68);
  581|       |      }
  582|       |      else if constexpr (N == 70) {
  583|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  584|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  585|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  586|       |                p65, p66, p67, p68, p69] = t;
  587|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  588|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  589|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  590|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69);
  591|       |      }
  592|       |      else if constexpr (N == 71) {
  593|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  594|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  595|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  596|       |                p65, p66, p67, p68, p69, p70] = t;
  597|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  598|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  599|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  600|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70);
  601|       |      }
  602|       |      else if constexpr (N == 72) {
  603|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  604|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  605|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  606|       |                p65, p66, p67, p68, p69, p70, p71] = t;
  607|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  608|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  609|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  610|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71);
  611|       |      }
  612|       |      else if constexpr (N == 73) {
  613|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  614|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  615|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  616|       |                p65, p66, p67, p68, p69, p70, p71, p72] = t;
  617|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  618|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  619|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  620|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72);
  621|       |      }
  622|       |      else if constexpr (N == 74) {
  623|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  624|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  625|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  626|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73] = t;
  627|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  628|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  629|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  630|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73);
  631|       |      }
  632|       |      else if constexpr (N == 75) {
  633|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  634|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  635|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  636|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74] = t;
  637|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  638|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  639|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  640|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74);
  641|       |      }
  642|       |      else if constexpr (N == 76) {
  643|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  644|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  645|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  646|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75] = t;
  647|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  648|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  649|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  650|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75);
  651|       |      }
  652|       |      else if constexpr (N == 77) {
  653|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  654|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  655|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  656|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76] = t;
  657|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  658|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  659|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  660|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76);
  661|       |      }
  662|       |      else if constexpr (N == 78) {
  663|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  664|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  665|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  666|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77] = t;
  667|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  668|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  669|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  670|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77);
  671|       |      }
  672|       |      else if constexpr (N == 79) {
  673|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  674|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  675|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  676|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78] = t;
  677|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  678|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  679|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  680|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  681|       |                         p78);
  682|       |      }
  683|       |      else if constexpr (N == 80) {
  684|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  685|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  686|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  687|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79] = t;
  688|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  689|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  690|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  691|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  692|       |                         p78, p79);
  693|       |      }
  694|       |      else if constexpr (N == 81) {
  695|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  696|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  697|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  698|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80] = t;
  699|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  700|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  701|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  702|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  703|       |                         p78, p79, p80);
  704|       |      }
  705|       |      else if constexpr (N == 82) {
  706|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  707|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  708|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  709|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81] = t;
  710|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  711|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  712|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  713|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  714|       |                         p78, p79, p80, p81);
  715|       |      }
  716|       |      else if constexpr (N == 83) {
  717|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  718|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  719|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  720|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82] = t;
  721|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  722|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  723|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  724|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  725|       |                         p78, p79, p80, p81, p82);
  726|       |      }
  727|       |      else if constexpr (N == 84) {
  728|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  729|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  730|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  731|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83] = t;
  732|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  733|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  734|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  735|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  736|       |                         p78, p79, p80, p81, p82, p83);
  737|       |      }
  738|       |      else if constexpr (N == 85) {
  739|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  740|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  741|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  742|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84] = t;
  743|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  744|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  745|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  746|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  747|       |                         p78, p79, p80, p81, p82, p83, p84);
  748|       |      }
  749|       |      else if constexpr (N == 86) {
  750|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  751|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  752|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  753|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84,
  754|       |                p85] = t;
  755|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  756|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  757|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  758|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  759|       |                         p78, p79, p80, p81, p82, p83, p84, p85);
  760|       |      }
  761|       |      else if constexpr (N == 87) {
  762|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  763|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  764|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  765|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
  766|       |                p86] = t;
  767|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  768|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  769|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  770|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  771|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86);
  772|       |      }
  773|       |      else if constexpr (N == 88) {
  774|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  775|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  776|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  777|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
  778|       |                p86, p87] = t;
  779|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  780|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  781|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  782|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  783|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87);
  784|       |      }
  785|       |      else if constexpr (N == 89) {
  786|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  787|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  788|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  789|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
  790|       |                p86, p87, p88] = t;
  791|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  792|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  793|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  794|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  795|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88);
  796|       |      }
  797|       |      else if constexpr (N == 90) {
  798|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  799|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  800|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  801|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
  802|       |                p86, p87, p88, p89] = t;
  803|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  804|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  805|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  806|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  807|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89);
  808|       |      }
  809|       |      else if constexpr (N == 91) {
  810|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  811|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  812|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  813|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
  814|       |                p86, p87, p88, p89, p90] = t;
  815|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  816|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  817|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  818|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  819|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90);
  820|       |      }
  821|       |      else if constexpr (N == 92) {
  822|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  823|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  824|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  825|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
  826|       |                p86, p87, p88, p89, p90, p91] = t;
  827|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  828|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  829|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  830|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  831|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91);
  832|       |      }
  833|       |      else if constexpr (N == 93) {
  834|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  835|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  836|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  837|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
  838|       |                p86, p87, p88, p89, p90, p91, p92] = t;
  839|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  840|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  841|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  842|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  843|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92);
  844|       |      }
  845|       |      else if constexpr (N == 94) {
  846|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  847|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  848|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  849|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
  850|       |                p86, p87, p88, p89, p90, p91, p92, p93] = t;
  851|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  852|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  853|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  854|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  855|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93);
  856|       |      }
  857|       |      else if constexpr (N == 95) {
  858|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  859|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  860|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  861|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
  862|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94] = t;
  863|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  864|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  865|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  866|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  867|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94);
  868|       |      }
  869|       |      else if constexpr (N == 96) {
  870|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  871|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  872|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  873|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
  874|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95] = t;
  875|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  876|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  877|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  878|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  879|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95);
  880|       |      }
  881|       |      else if constexpr (N == 97) {
  882|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  883|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  884|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  885|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
  886|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96] = t;
  887|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  888|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  889|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  890|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  891|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96);
  892|       |      }
  893|       |      else if constexpr (N == 98) {
  894|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  895|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  896|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  897|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
  898|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97] = t;
  899|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  900|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  901|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  902|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  903|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
  904|       |                         p97);
  905|       |      }
  906|       |      else if constexpr (N == 99) {
  907|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  908|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  909|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  910|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
  911|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98] = t;
  912|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  913|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  914|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  915|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  916|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
  917|       |                         p97, p98);
  918|       |      }
  919|       |      else if constexpr (N == 100) {
  920|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  921|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  922|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  923|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
  924|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99] = t;
  925|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  926|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  927|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  928|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  929|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
  930|       |                         p97, p98, p99);
  931|       |      }
  932|       |      else if constexpr (N == 101) {
  933|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  934|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  935|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  936|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
  937|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100] = t;
  938|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  939|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  940|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  941|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  942|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
  943|       |                         p97, p98, p99, p100);
  944|       |      }
  945|       |      else if constexpr (N == 102) {
  946|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  947|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  948|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  949|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
  950|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101] = t;
  951|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  952|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  953|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  954|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  955|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
  956|       |                         p97, p98, p99, p100, p101);
  957|       |      }
  958|       |      else if constexpr (N == 103) {
  959|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  960|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  961|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  962|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
  963|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102] = t;
  964|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  965|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  966|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  967|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  968|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
  969|       |                         p97, p98, p99, p100, p101, p102);
  970|       |      }
  971|       |      else if constexpr (N == 104) {
  972|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  973|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  974|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  975|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
  976|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103] = t;
  977|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  978|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  979|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  980|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  981|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
  982|       |                         p97, p98, p99, p100, p101, p102, p103);
  983|       |      }
  984|       |      else if constexpr (N == 105) {
  985|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  986|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
  987|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
  988|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
  989|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104] = t;
  990|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
  991|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
  992|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
  993|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
  994|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
  995|       |                         p97, p98, p99, p100, p101, p102, p103, p104);
  996|       |      }
  997|       |      else if constexpr (N == 106) {
  998|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
  999|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1000|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1001|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1002|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1003|       |                p105] = t;
 1004|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1005|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1006|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1007|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1008|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1009|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105);
 1010|       |      }
 1011|       |      else if constexpr (N == 107) {
 1012|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
 1013|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1014|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1015|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1016|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1017|       |                p105, p106] = t;
 1018|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1019|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1020|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1021|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1022|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1023|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106);
 1024|       |      }
 1025|       |      else if constexpr (N == 108) {
 1026|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
 1027|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1028|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1029|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1030|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1031|       |                p105, p106, p107] = t;
 1032|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1033|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1034|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1035|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1036|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1037|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107);
 1038|       |      }
 1039|       |      else if constexpr (N == 109) {
 1040|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
 1041|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1042|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1043|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1044|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1045|       |                p105, p106, p107, p108] = t;
 1046|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1047|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1048|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1049|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1050|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1051|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108);
 1052|       |      }
 1053|       |      else if constexpr (N == 110) {
 1054|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
 1055|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1056|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1057|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1058|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1059|       |                p105, p106, p107, p108, p109] = t;
 1060|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1061|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1062|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1063|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1064|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1065|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109);
 1066|       |      }
 1067|       |      else if constexpr (N == 111) {
 1068|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
 1069|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1070|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1071|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1072|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1073|       |                p105, p106, p107, p108, p109, p110] = t;
 1074|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1075|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1076|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1077|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1078|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1079|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110);
 1080|       |      }
 1081|       |      else if constexpr (N == 112) {
 1082|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
 1083|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1084|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1085|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1086|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1087|       |                p105, p106, p107, p108, p109, p110, p111] = t;
 1088|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1089|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1090|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1091|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1092|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1093|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111);
 1094|       |      }
 1095|       |      else if constexpr (N == 113) {
 1096|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
 1097|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1098|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1099|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1100|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1101|       |                p105, p106, p107, p108, p109, p110, p111, p112] = t;
 1102|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1103|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1104|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1105|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1106|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1107|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112);
 1108|       |      }
 1109|       |      else if constexpr (N == 114) {
 1110|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
 1111|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1112|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1113|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1114|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1115|       |                p105, p106, p107, p108, p109, p110, p111, p112, p113] = t;
 1116|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1117|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1118|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1119|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1120|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1121|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112,
 1122|       |                         p113);
 1123|       |      }
 1124|       |      else if constexpr (N == 115) {
 1125|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
 1126|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1127|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1128|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1129|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1130|       |                p105, p106, p107, p108, p109, p110, p111, p112, p113, p114] = t;
 1131|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1132|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1133|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1134|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1135|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1136|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112,
 1137|       |                         p113, p114);
 1138|       |      }
 1139|       |      else if constexpr (N == 116) {
 1140|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
 1141|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1142|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1143|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1144|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1145|       |                p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115] = t;
 1146|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1147|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1148|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1149|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1150|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1151|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112,
 1152|       |                         p113, p114, p115);
 1153|       |      }
 1154|       |      else if constexpr (N == 117) {
 1155|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
 1156|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1157|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1158|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1159|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1160|       |                p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116] = t;
 1161|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1162|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1163|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1164|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1165|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1166|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112,
 1167|       |                         p113, p114, p115, p116);
 1168|       |      }
 1169|       |      else if constexpr (N == 118) {
 1170|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
 1171|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1172|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1173|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1174|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1175|       |                p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117] = t;
 1176|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1177|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1178|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1179|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1180|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1181|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112,
 1182|       |                         p113, p114, p115, p116, p117);
 1183|       |      }
 1184|       |      else if constexpr (N == 119) {
 1185|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
 1186|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1187|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1188|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1189|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1190|       |                p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118] = t;
 1191|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1192|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1193|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1194|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1195|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1196|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112,
 1197|       |                         p113, p114, p115, p116, p117, p118);
 1198|       |      }
 1199|       |      else if constexpr (N == 120) {
 1200|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
 1201|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1202|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1203|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1204|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1205|       |                p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119] = t;
 1206|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1207|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1208|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1209|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1210|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1211|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112,
 1212|       |                         p113, p114, p115, p116, p117, p118, p119);
 1213|       |      }
 1214|       |      else if constexpr (N == 121) {
 1215|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
 1216|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1217|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1218|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1219|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1220|       |                p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119, p120] = t;
 1221|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1222|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1223|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1224|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1225|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1226|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112,
 1227|       |                         p113, p114, p115, p116, p117, p118, p119, p120);
 1228|       |      }
 1229|       |      else if constexpr (N == 122) {
 1230|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
 1231|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1232|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1233|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1234|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1235|       |                p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119, p120, p121] =
 1236|       |            t;
 1237|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1238|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1239|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1240|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1241|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1242|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112,
 1243|       |                         p113, p114, p115, p116, p117, p118, p119, p120, p121);
 1244|       |      }
 1245|       |      else if constexpr (N == 123) {
 1246|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
 1247|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1248|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1249|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1250|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1251|       |                p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119, p120, p121,
 1252|       |                p122] = t;
 1253|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1254|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1255|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1256|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1257|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1258|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112,
 1259|       |                         p113, p114, p115, p116, p117, p118, p119, p120, p121, p122);
 1260|       |      }
 1261|       |      else if constexpr (N == 124) {
 1262|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
 1263|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1264|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1265|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1266|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1267|       |                p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119, p120, p121,
 1268|       |                p122, p123] = t;
 1269|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1270|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1271|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1272|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1273|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1274|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112,
 1275|       |                         p113, p114, p115, p116, p117, p118, p119, p120, p121, p122, p123);
 1276|       |      }
 1277|       |      else if constexpr (N == 125) {
 1278|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
 1279|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1280|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1281|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1282|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1283|       |                p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119, p120, p121,
 1284|       |                p122, p123, p124] = t;
 1285|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1286|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1287|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1288|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1289|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1290|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112,
 1291|       |                         p113, p114, p115, p116, p117, p118, p119, p120, p121, p122, p123, p124);
 1292|       |      }
 1293|       |      else if constexpr (N == 126) {
 1294|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
 1295|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1296|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1297|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1298|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1299|       |                p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119, p120, p121,
 1300|       |                p122, p123, p124, p125] = t;
 1301|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1302|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1303|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1304|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1305|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1306|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112,
 1307|       |                         p113, p114, p115, p116, p117, p118, p119, p120, p121, p122, p123, p124, p125);
 1308|       |      }
 1309|       |      else if constexpr (N == 127) {
 1310|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
 1311|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1312|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1313|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1314|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1315|       |                p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119, p120, p121,
 1316|       |                p122, p123, p124, p125, p126] = t;
 1317|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1318|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1319|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1320|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1321|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1322|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112,
 1323|       |                         p113, p114, p115, p116, p117, p118, p119, p120, p121, p122, p123, p124, p125, p126);
 1324|       |      }
 1325|       |      else if constexpr (N == 128) {
 1326|       |         auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22,
 1327|       |                p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43,
 1328|       |                p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64,
 1329|       |                p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85,
 1330|       |                p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104,
 1331|       |                p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119, p120, p121,
 1332|       |                p122, p123, p124, p125, p126, p127] = t;
 1333|       |         return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
 1334|       |                         p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39,
 1335|       |                         p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58,
 1336|       |                         p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77,
 1337|       |                         p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96,
 1338|       |                         p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112,
 1339|       |                         p113, p114, p115, p116, p117, p118, p119, p120, p121, p122, p123, p124, p125, p126, p127);
 1340|       |      }
 1341|    303|   }

_ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE17register_endpointIN12jsonrpc_fuzz10member_apiENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNSt3__117basic_string_viewIcNS8_11char_traitsIcEEEERT_RT0_:
  151|  61.1k|      {
  152|  61.1k|         register_read_write_endpoint(path, value, reg);
  153|  61.1k|      }
_ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE28register_read_write_endpointIN12jsonrpc_fuzz10member_apiENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNSt3__117basic_string_viewIcNS8_11char_traitsIcEEEERT_RT0_:
  127|  61.1k|      {
  128|  61.1k|         reg.endpoints[path] = [&value](jsonrpc::state&& state) mutable {
  129|  61.1k|            if (state.has_body()) {
  130|  61.1k|               if (!jsonrpc::read_params<Opts>(value, state)) {
  131|  61.1k|                  return;
  132|  61.1k|               }
  133|  61.1k|            }
  134|       |
  135|  61.1k|            if (state.notify()) {
  136|  61.1k|               return;
  137|  61.1k|            }
  138|       |
  139|  61.1k|            if (!state.has_body()) {
  140|  61.1k|               jsonrpc::write_response<Opts>(value, state);
  141|  61.1k|            }
  142|  61.1k|            else {
  143|  61.1k|               jsonrpc::write_response<Opts>(state);
  144|  61.1k|            }
  145|  61.1k|         };
  146|  61.1k|      }
_ZNK3glz7jsonrpc5state8has_bodyEv:
   28|  58.7k|         bool has_body() const { return has_params; }
_ZN3glz7jsonrpc11write_errorITkNS0_8is_stateERNS0_5stateEEEvOT_NS_3rpc7error_eERKNSt3__112basic_stringIcNS8_11char_traitsIcEENS8_9allocatorIcEEEERKNS8_8optionalISE_EE:
   76|  14.7k|      {
   77|  14.7k|         if (state.notify()) {
  ------------------
  |  Branch (77:14): [True: 2.31k, False: 12.4k]
  ------------------
   78|  2.31k|            return; // No response for notifications
   79|  2.31k|         }
   80|       |
   81|  12.4k|         state.response = R"({"jsonrpc":"2.0","error":{"code":)";
   82|  12.4k|         state.response += std::to_string(static_cast<int>(code));
   83|  12.4k|         state.response += R"(,"message":)";
   84|  12.4k|         state.response += write_json(message).value_or("\"\"");
   85|  12.4k|         if (data) {
  ------------------
  |  Branch (85:14): [True: 12.4k, False: 0]
  ------------------
   86|  12.4k|            state.response += R"(,"data":)";
   87|  12.4k|            state.response += write_json(*data).value_or("null");
   88|  12.4k|         }
   89|  12.4k|         state.response += R"(},"id":)";
   90|  12.4k|         state.response += write_json(state.id).value_or("null");
   91|  12.4k|         state.response += "}";
   92|  12.4k|      }
_ZNK3glz7jsonrpc5state6notifyEv:
   27|  46.9k|         bool notify() const { return is_notification; }
_ZN3glz7jsonrpc14write_responseITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETkNS0_8is_stateERNS0_5stateEEEvOT0_:
   63|  3.94k|      {
   64|  3.94k|         if (state.notify()) {
  ------------------
  |  Branch (64:14): [True: 0, False: 3.94k]
  ------------------
   65|      0|            return; // No response for notifications
   66|      0|         }
   67|       |
   68|  3.94k|         state.response = R"({"jsonrpc":"2.0","result":null,"id":)";
   69|  3.94k|         state.response += write_json(state.id).value_or("null");
   70|  3.94k|         state.response += "}";
   71|  3.94k|      }
_ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE26register_variable_endpointIiNS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNSt3__117basic_string_viewIcNS6_11char_traitsIcEEEERT_RT0_:
  241|   183k|      {
  242|   183k|         register_read_write_endpoint(path, var, reg);
  243|   183k|      }
_ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE28register_read_write_endpointIiNS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNSt3__117basic_string_viewIcNS6_11char_traitsIcEEEERT_RT0_:
  127|   183k|      {
  128|   183k|         reg.endpoints[path] = [&value](jsonrpc::state&& state) mutable {
  129|   183k|            if (state.has_body()) {
  130|   183k|               if (!jsonrpc::read_params<Opts>(value, state)) {
  131|   183k|                  return;
  132|   183k|               }
  133|   183k|            }
  134|       |
  135|   183k|            if (state.notify()) {
  136|   183k|               return;
  137|   183k|            }
  138|       |
  139|   183k|            if (!state.has_body()) {
  140|   183k|               jsonrpc::write_response<Opts>(value, state);
  141|   183k|            }
  142|   183k|            else {
  143|   183k|               jsonrpc::write_response<Opts>(state);
  144|   183k|            }
  145|   183k|         };
  146|   183k|      }
_ZZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE28register_read_write_endpointIiNS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNSt3__117basic_string_viewIcNS6_11char_traitsIcEEEERT_RT0_ENUlONS_7jsonrpc5stateEE_clESH_:
  128|    741|         reg.endpoints[path] = [&value](jsonrpc::state&& state) mutable {
  129|    741|            if (state.has_body()) {
  ------------------
  |  Branch (129:17): [True: 298, False: 443]
  ------------------
  130|    298|               if (!jsonrpc::read_params<Opts>(value, state)) {
  ------------------
  |  Branch (130:20): [True: 220, False: 78]
  ------------------
  131|    220|                  return;
  132|    220|               }
  133|    298|            }
  134|       |
  135|    521|            if (state.notify()) {
  ------------------
  |  Branch (135:17): [True: 431, False: 90]
  ------------------
  136|    431|               return;
  137|    431|            }
  138|       |
  139|     90|            if (!state.has_body()) {
  ------------------
  |  Branch (139:17): [True: 34, False: 56]
  ------------------
  140|     34|               jsonrpc::write_response<Opts>(value, state);
  141|     34|            }
  142|     56|            else {
  143|     56|               jsonrpc::write_response<Opts>(state);
  144|     56|            }
  145|     90|         };
_ZN3glz7jsonrpc11read_paramsITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERiTkNS0_8is_stateERNS0_5stateEEEbOT0_OT1_:
   97|  1.94k|      {
   98|  1.94k|         if (!state.has_body()) {
  ------------------
  |  Branch (98:14): [True: 642, False: 1.30k]
  ------------------
   99|    642|            return true; // No params to read
  100|    642|         }
  101|       |
  102|  1.30k|         auto ec = read<Opts>(std::forward<Value>(value), state.params_json);
  103|  1.30k|         if (ec) {
  ------------------
  |  Branch (103:14): [True: 648, False: 652]
  ------------------
  104|    648|            write_error(state, rpc::error_e::invalid_params, "Invalid params", format_error(ec, state.params_json));
  105|    648|            return false;
  106|    648|         }
  107|    652|         return true;
  108|  1.30k|      }
_ZN3glz7jsonrpc14write_responseITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERiTkNS0_8is_stateERNS0_5stateEEEvOT0_OT1_:
   37|    337|      {
   38|    337|         if (state.notify()) {
  ------------------
  |  Branch (38:14): [True: 0, False: 337]
  ------------------
   39|      0|            return; // No response for notifications
   40|      0|         }
   41|       |
   42|    337|         std::string result_json;
   43|    337|         auto ec = write<Opts>(std::forward<Value>(value), result_json);
   44|    337|         if (ec) {
  ------------------
  |  Branch (44:14): [True: 0, False: 337]
  ------------------
   45|       |            // Write error response
   46|      0|            state.response =
   47|      0|               R"({"jsonrpc":"2.0","error":{"code":-32603,"message":"Internal error","data":"Failed to serialize result"},"id":)";
   48|      0|            state.response += write_json(state.id).value_or("null");
   49|      0|            state.response += "}";
   50|      0|            return;
   51|      0|         }
   52|       |
   53|    337|         state.response = R"({"jsonrpc":"2.0","result":)";
   54|    337|         state.response += result_json;
   55|    337|         state.response += R"(,"id":)";
   56|    337|         state.response += write_json(state.id).value_or("null");
   57|    337|         state.response += "}";
   58|    337|      }
_ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE45register_member_function_with_params_endpointIN12jsonrpc_fuzz10member_apiEMS5_FiiEiiNS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNSt3__117basic_string_viewIcNSA_11char_traitsIcEEEERT_T0_RT3_:
  271|  61.1k|      {
  272|  61.1k|         reg.endpoints[path] = [&value, func](jsonrpc::state&& state) mutable {
  273|  61.1k|            static thread_local Input input{};
  274|  61.1k|            input = {}; // reset to avoid stale optional/variant fields across calls
  275|  61.1k|            if (state.has_body()) {
  276|  61.1k|               if (!jsonrpc::read_params<Opts>(input, state)) {
  277|  61.1k|                  return;
  278|  61.1k|               }
  279|  61.1k|            }
  280|       |
  281|  61.1k|            if constexpr (std::same_as<Ret, void>) {
  282|  61.1k|               (value.*func)(input);
  283|       |
  284|  61.1k|               if (state.notify()) {
  285|  61.1k|                  return;
  286|  61.1k|               }
  287|       |
  288|  61.1k|               jsonrpc::write_response<Opts>(state);
  289|  61.1k|            }
  290|  61.1k|            else {
  291|  61.1k|               if (state.notify()) {
  292|  61.1k|                  std::ignore = (value.*func)(input);
  293|  61.1k|                  return;
  294|  61.1k|               }
  295|       |
  296|  61.1k|               jsonrpc::write_response<Opts>((value.*func)(input), state);
  297|  61.1k|            }
  298|  61.1k|         };
  299|  61.1k|      }
_ZZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE45register_member_function_with_params_endpointIN12jsonrpc_fuzz10member_apiEMS5_FiiEiiNS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNSt3__117basic_string_viewIcNSA_11char_traitsIcEEEERT_T0_RT3_ENUlONS_7jsonrpc5stateEE_clESM_:
  272|    868|         reg.endpoints[path] = [&value, func](jsonrpc::state&& state) mutable {
  273|    868|            static thread_local Input input{};
  274|    868|            input = {}; // reset to avoid stale optional/variant fields across calls
  275|    868|            if (state.has_body()) {
  ------------------
  |  Branch (275:17): [True: 499, False: 369]
  ------------------
  276|    499|               if (!jsonrpc::read_params<Opts>(input, state)) {
  ------------------
  |  Branch (276:20): [True: 180, False: 319]
  ------------------
  277|    180|                  return;
  278|    180|               }
  279|    499|            }
  280|       |
  281|       |            if constexpr (std::same_as<Ret, void>) {
  282|       |               (value.*func)(input);
  283|       |
  284|       |               if (state.notify()) {
  285|       |                  return;
  286|       |               }
  287|       |
  288|       |               jsonrpc::write_response<Opts>(state);
  289|       |            }
  290|    688|            else {
  291|    688|               if (state.notify()) {
  ------------------
  |  Branch (291:20): [True: 341, False: 347]
  ------------------
  292|    341|                  std::ignore = (value.*func)(input);
  293|    341|                  return;
  294|    341|               }
  295|       |
  296|    347|               jsonrpc::write_response<Opts>((value.*func)(input), state);
  297|    347|            }
  298|    688|         };
_ZN3glz7jsonrpc14write_responseITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEiTkNS0_8is_stateERNS0_5stateEEEvOT0_OT1_:
   37|    347|      {
   38|    347|         if (state.notify()) {
  ------------------
  |  Branch (38:14): [True: 0, False: 347]
  ------------------
   39|      0|            return; // No response for notifications
   40|      0|         }
   41|       |
   42|    347|         std::string result_json;
   43|    347|         auto ec = write<Opts>(std::forward<Value>(value), result_json);
   44|    347|         if (ec) {
  ------------------
  |  Branch (44:14): [True: 0, False: 347]
  ------------------
   45|       |            // Write error response
   46|      0|            state.response =
   47|      0|               R"({"jsonrpc":"2.0","error":{"code":-32603,"message":"Internal error","data":"Failed to serialize result"},"id":)";
   48|      0|            state.response += write_json(state.id).value_or("null");
   49|      0|            state.response += "}";
   50|      0|            return;
   51|      0|         }
   52|       |
   53|    347|         state.response = R"({"jsonrpc":"2.0","result":)";
   54|    347|         state.response += result_json;
   55|    347|         state.response += R"(,"id":)";
   56|    347|         state.response += write_json(state.id).value_or("null");
   57|    347|         state.response += "}";
   58|    347|      }
_ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE33register_member_function_endpointIN12jsonrpc_fuzz10member_apiEMS5_FvvEvNS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNSt3__117basic_string_viewIcNSA_11char_traitsIcEEEERT_T0_RT2_:
  247|  61.1k|      {
  248|  61.1k|         reg.endpoints[path] = [&value, func](jsonrpc::state&& state) mutable {
  249|  61.1k|            if constexpr (std::same_as<Ret, void>) {
  250|  61.1k|               (value.*func)();
  251|       |
  252|  61.1k|               if (state.notify()) {
  253|  61.1k|                  return;
  254|  61.1k|               }
  255|       |
  256|  61.1k|               jsonrpc::write_response<Opts>(state);
  257|  61.1k|            }
  258|  61.1k|            else {
  259|  61.1k|               if (state.notify()) {
  260|  61.1k|                  std::ignore = (value.*func)();
  261|  61.1k|                  return;
  262|  61.1k|               }
  263|       |
  264|  61.1k|               jsonrpc::write_response<Opts>((value.*func)(), state);
  265|  61.1k|            }
  266|  61.1k|         };
  267|  61.1k|      }
_ZZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE33register_member_function_endpointIN12jsonrpc_fuzz10member_apiEMS5_FvvEvNS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNSt3__117basic_string_viewIcNSA_11char_traitsIcEEEERT_T0_RT2_ENUlONS_7jsonrpc5stateEE_clESM_:
  248|    312|         reg.endpoints[path] = [&value, func](jsonrpc::state&& state) mutable {
  249|    312|            if constexpr (std::same_as<Ret, void>) {
  250|    312|               (value.*func)();
  251|       |
  252|    312|               if (state.notify()) {
  ------------------
  |  Branch (252:20): [True: 244, False: 68]
  ------------------
  253|    244|                  return;
  254|    244|               }
  255|       |
  256|     68|               jsonrpc::write_response<Opts>(state);
  257|       |            }
  258|       |            else {
  259|       |               if (state.notify()) {
  260|       |                  std::ignore = (value.*func)();
  261|       |                  return;
  262|       |               }
  263|       |
  264|       |               jsonrpc::write_response<Opts>((value.*func)(), state);
  265|       |            }
  266|    312|         };
_ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE45register_member_function_with_params_endpointIN12jsonrpc_fuzz10member_apiEMS5_FNS4_5pointERKS6_ES6_S6_NS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNSt3__117basic_string_viewIcNSD_11char_traitsIcEEEERT_T0_RT3_:
  271|  61.1k|      {
  272|  61.1k|         reg.endpoints[path] = [&value, func](jsonrpc::state&& state) mutable {
  273|  61.1k|            static thread_local Input input{};
  274|  61.1k|            input = {}; // reset to avoid stale optional/variant fields across calls
  275|  61.1k|            if (state.has_body()) {
  276|  61.1k|               if (!jsonrpc::read_params<Opts>(input, state)) {
  277|  61.1k|                  return;
  278|  61.1k|               }
  279|  61.1k|            }
  280|       |
  281|  61.1k|            if constexpr (std::same_as<Ret, void>) {
  282|  61.1k|               (value.*func)(input);
  283|       |
  284|  61.1k|               if (state.notify()) {
  285|  61.1k|                  return;
  286|  61.1k|               }
  287|       |
  288|  61.1k|               jsonrpc::write_response<Opts>(state);
  289|  61.1k|            }
  290|  61.1k|            else {
  291|  61.1k|               if (state.notify()) {
  292|  61.1k|                  std::ignore = (value.*func)(input);
  293|  61.1k|                  return;
  294|  61.1k|               }
  295|       |
  296|  61.1k|               jsonrpc::write_response<Opts>((value.*func)(input), state);
  297|  61.1k|            }
  298|  61.1k|         };
  299|  61.1k|      }
_ZZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE45register_member_function_with_params_endpointIN12jsonrpc_fuzz10member_apiEMS5_FNS4_5pointERKS6_ES6_S6_NS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNSt3__117basic_string_viewIcNSD_11char_traitsIcEEEERT_T0_RT3_ENUlONS_7jsonrpc5stateEE_clESP_:
  272|  1.12k|         reg.endpoints[path] = [&value, func](jsonrpc::state&& state) mutable {
  273|  1.12k|            static thread_local Input input{};
  274|  1.12k|            input = {}; // reset to avoid stale optional/variant fields across calls
  275|  1.12k|            if (state.has_body()) {
  ------------------
  |  Branch (275:17): [True: 586, False: 538]
  ------------------
  276|    586|               if (!jsonrpc::read_params<Opts>(input, state)) {
  ------------------
  |  Branch (276:20): [True: 543, False: 43]
  ------------------
  277|    543|                  return;
  278|    543|               }
  279|    586|            }
  280|       |
  281|       |            if constexpr (std::same_as<Ret, void>) {
  282|       |               (value.*func)(input);
  283|       |
  284|       |               if (state.notify()) {
  285|       |                  return;
  286|       |               }
  287|       |
  288|       |               jsonrpc::write_response<Opts>(state);
  289|       |            }
  290|    581|            else {
  291|    581|               if (state.notify()) {
  ------------------
  |  Branch (291:20): [True: 420, False: 161]
  ------------------
  292|    420|                  std::ignore = (value.*func)(input);
  293|    420|                  return;
  294|    420|               }
  295|       |
  296|    161|               jsonrpc::write_response<Opts>((value.*func)(input), state);
  297|    161|            }
  298|    581|         };
_ZN3glz7jsonrpc11read_paramsITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERN12jsonrpc_fuzz5pointETkNS0_8is_stateERNS0_5stateEEEbOT0_OT1_:
   97|  1.83k|      {
   98|  1.83k|         if (!state.has_body()) {
  ------------------
  |  Branch (98:14): [True: 646, False: 1.18k]
  ------------------
   99|    646|            return true; // No params to read
  100|    646|         }
  101|       |
  102|  1.18k|         auto ec = read<Opts>(std::forward<Value>(value), state.params_json);
  103|  1.18k|         if (ec) {
  ------------------
  |  Branch (103:14): [True: 1.07k, False: 114]
  ------------------
  104|  1.07k|            write_error(state, rpc::error_e::invalid_params, "Invalid params", format_error(ec, state.params_json));
  105|  1.07k|            return false;
  106|  1.07k|         }
  107|    114|         return true;
  108|  1.18k|      }
_ZN3glz7jsonrpc14write_responseITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz5pointETkNS0_8is_stateERNS0_5stateEEEvOT0_OT1_:
   37|    161|      {
   38|    161|         if (state.notify()) {
  ------------------
  |  Branch (38:14): [True: 0, False: 161]
  ------------------
   39|      0|            return; // No response for notifications
   40|      0|         }
   41|       |
   42|    161|         std::string result_json;
   43|    161|         auto ec = write<Opts>(std::forward<Value>(value), result_json);
   44|    161|         if (ec) {
  ------------------
  |  Branch (44:14): [True: 0, False: 161]
  ------------------
   45|       |            // Write error response
   46|      0|            state.response =
   47|      0|               R"({"jsonrpc":"2.0","error":{"code":-32603,"message":"Internal error","data":"Failed to serialize result"},"id":)";
   48|      0|            state.response += write_json(state.id).value_or("null");
   49|      0|            state.response += "}";
   50|      0|            return;
   51|      0|         }
   52|       |
   53|    161|         state.response = R"({"jsonrpc":"2.0","result":)";
   54|    161|         state.response += result_json;
   55|    161|         state.response += R"(,"id":)";
   56|    161|         state.response += write_json(state.id).value_or("null");
   57|    161|         state.response += "}";
   58|    161|      }
_ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE17register_endpointIN12jsonrpc_fuzz8fuzz_apiENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNSt3__117basic_string_viewIcNS8_11char_traitsIcEEEERT_RT0_:
  151|  61.1k|      {
  152|  61.1k|         register_read_write_endpoint(path, value, reg);
  153|  61.1k|      }
_ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE28register_read_write_endpointIN12jsonrpc_fuzz8fuzz_apiENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNSt3__117basic_string_viewIcNS8_11char_traitsIcEEEERT_RT0_:
  127|  61.1k|      {
  128|  61.1k|         reg.endpoints[path] = [&value](jsonrpc::state&& state) mutable {
  129|  61.1k|            if (state.has_body()) {
  130|  61.1k|               if (!jsonrpc::read_params<Opts>(value, state)) {
  131|  61.1k|                  return;
  132|  61.1k|               }
  133|  61.1k|            }
  134|       |
  135|  61.1k|            if (state.notify()) {
  136|  61.1k|               return;
  137|  61.1k|            }
  138|       |
  139|  61.1k|            if (!state.has_body()) {
  140|  61.1k|               jsonrpc::write_response<Opts>(value, state);
  141|  61.1k|            }
  142|  61.1k|            else {
  143|  61.1k|               jsonrpc::write_response<Opts>(state);
  144|  61.1k|            }
  145|  61.1k|         };
  146|  61.1k|      }
_ZZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE28register_read_write_endpointIN12jsonrpc_fuzz8fuzz_apiENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNSt3__117basic_string_viewIcNS8_11char_traitsIcEEEERT_RT0_ENUlONS_7jsonrpc5stateEE_clESJ_:
  128|  7.70k|         reg.endpoints[path] = [&value](jsonrpc::state&& state) mutable {
  129|  7.70k|            if (state.has_body()) {
  ------------------
  |  Branch (129:17): [True: 5.21k, False: 2.49k]
  ------------------
  130|  5.21k|               if (!jsonrpc::read_params<Opts>(value, state)) {
  ------------------
  |  Branch (130:20): [True: 4.57k, False: 640]
  ------------------
  131|  4.57k|                  return;
  132|  4.57k|               }
  133|  5.21k|            }
  134|       |
  135|  3.13k|            if (state.notify()) {
  ------------------
  |  Branch (135:17): [True: 2.57k, False: 562]
  ------------------
  136|  2.57k|               return;
  137|  2.57k|            }
  138|       |
  139|    562|            if (!state.has_body()) {
  ------------------
  |  Branch (139:17): [True: 43, False: 519]
  ------------------
  140|     43|               jsonrpc::write_response<Opts>(value, state);
  141|     43|            }
  142|    519|            else {
  143|    519|               jsonrpc::write_response<Opts>(state);
  144|    519|            }
  145|    562|         };
_ZN3glz7jsonrpc11read_paramsITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERN12jsonrpc_fuzz8fuzz_apiETkNS0_8is_stateERNS0_5stateEEEbOT0_OT1_:
   97|  5.21k|      {
   98|  5.21k|         if (!state.has_body()) {
  ------------------
  |  Branch (98:14): [True: 0, False: 5.21k]
  ------------------
   99|      0|            return true; // No params to read
  100|      0|         }
  101|       |
  102|  5.21k|         auto ec = read<Opts>(std::forward<Value>(value), state.params_json);
  103|  5.21k|         if (ec) {
  ------------------
  |  Branch (103:14): [True: 4.57k, False: 640]
  ------------------
  104|  4.57k|            write_error(state, rpc::error_e::invalid_params, "Invalid params", format_error(ec, state.params_json));
  105|  4.57k|            return false;
  106|  4.57k|         }
  107|    640|         return true;
  108|  5.21k|      }
_ZN3glz7jsonrpc14write_responseITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERN12jsonrpc_fuzz8fuzz_apiETkNS0_8is_stateERNS0_5stateEEEvOT0_OT1_:
   37|     43|      {
   38|     43|         if (state.notify()) {
  ------------------
  |  Branch (38:14): [True: 0, False: 43]
  ------------------
   39|      0|            return; // No response for notifications
   40|      0|         }
   41|       |
   42|     43|         std::string result_json;
   43|     43|         auto ec = write<Opts>(std::forward<Value>(value), result_json);
   44|     43|         if (ec) {
  ------------------
  |  Branch (44:14): [True: 0, False: 43]
  ------------------
   45|       |            // Write error response
   46|      0|            state.response =
   47|      0|               R"({"jsonrpc":"2.0","error":{"code":-32603,"message":"Internal error","data":"Failed to serialize result"},"id":)";
   48|      0|            state.response += write_json(state.id).value_or("null");
   49|      0|            state.response += "}";
   50|      0|            return;
   51|      0|         }
   52|       |
   53|     43|         state.response = R"({"jsonrpc":"2.0","result":)";
   54|     43|         state.response += result_json;
   55|     43|         state.response += R"(,"id":)";
   56|     43|         state.response += write_json(state.id).value_or("null");
   57|     43|         state.response += "}";
   58|     43|      }
_ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE26register_variable_endpointINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNS4_17basic_string_viewIcS7_EERT_RT0_:
  241|   122k|      {
  242|   122k|         register_read_write_endpoint(path, var, reg);
  243|   122k|      }
_ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE28register_read_write_endpointINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNS4_17basic_string_viewIcS7_EERT_RT0_:
  127|   122k|      {
  128|   122k|         reg.endpoints[path] = [&value](jsonrpc::state&& state) mutable {
  129|   122k|            if (state.has_body()) {
  130|   122k|               if (!jsonrpc::read_params<Opts>(value, state)) {
  131|   122k|                  return;
  132|   122k|               }
  133|   122k|            }
  134|       |
  135|   122k|            if (state.notify()) {
  136|   122k|               return;
  137|   122k|            }
  138|       |
  139|   122k|            if (!state.has_body()) {
  140|   122k|               jsonrpc::write_response<Opts>(value, state);
  141|   122k|            }
  142|   122k|            else {
  143|   122k|               jsonrpc::write_response<Opts>(state);
  144|   122k|            }
  145|   122k|         };
  146|   122k|      }
_ZZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE28register_read_write_endpointINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNS4_17basic_string_viewIcS7_EERT_RT0_ENUlONS_7jsonrpc5stateEE_clESL_:
  128|    609|         reg.endpoints[path] = [&value](jsonrpc::state&& state) mutable {
  129|    609|            if (state.has_body()) {
  ------------------
  |  Branch (129:17): [True: 318, False: 291]
  ------------------
  130|    318|               if (!jsonrpc::read_params<Opts>(value, state)) {
  ------------------
  |  Branch (130:20): [True: 221, False: 97]
  ------------------
  131|    221|                  return;
  132|    221|               }
  133|    318|            }
  134|       |
  135|    388|            if (state.notify()) {
  ------------------
  |  Branch (135:17): [True: 285, False: 103]
  ------------------
  136|    285|               return;
  137|    285|            }
  138|       |
  139|    103|            if (!state.has_body()) {
  ------------------
  |  Branch (139:17): [True: 25, False: 78]
  ------------------
  140|     25|               jsonrpc::write_response<Opts>(value, state);
  141|     25|            }
  142|     78|            else {
  143|     78|               jsonrpc::write_response<Opts>(state);
  144|     78|            }
  145|    103|         };
_ZN3glz7jsonrpc11read_paramsITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEETkNS0_8is_stateERNS0_5stateEEEbOT0_OT1_:
   97|  3.18k|      {
   98|  3.18k|         if (!state.has_body()) {
  ------------------
  |  Branch (98:14): [True: 1.89k, False: 1.28k]
  ------------------
   99|  1.89k|            return true; // No params to read
  100|  1.89k|         }
  101|       |
  102|  1.28k|         auto ec = read<Opts>(std::forward<Value>(value), state.params_json);
  103|  1.28k|         if (ec) {
  ------------------
  |  Branch (103:14): [True: 681, False: 606]
  ------------------
  104|    681|            write_error(state, rpc::error_e::invalid_params, "Invalid params", format_error(ec, state.params_json));
  105|    681|            return false;
  106|    681|         }
  107|    606|         return true;
  108|  1.28k|      }
_ZN3glz7jsonrpc14write_responseITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEETkNS0_8is_stateERNS0_5stateEEEvOT0_OT1_:
   37|    611|      {
   38|    611|         if (state.notify()) {
  ------------------
  |  Branch (38:14): [True: 0, False: 611]
  ------------------
   39|      0|            return; // No response for notifications
   40|      0|         }
   41|       |
   42|    611|         std::string result_json;
   43|    611|         auto ec = write<Opts>(std::forward<Value>(value), result_json);
   44|    611|         if (ec) {
  ------------------
  |  Branch (44:14): [True: 0, False: 611]
  ------------------
   45|       |            // Write error response
   46|      0|            state.response =
   47|      0|               R"({"jsonrpc":"2.0","error":{"code":-32603,"message":"Internal error","data":"Failed to serialize result"},"id":)";
   48|      0|            state.response += write_json(state.id).value_or("null");
   49|      0|            state.response += "}";
   50|      0|            return;
   51|      0|         }
   52|       |
   53|    611|         state.response = R"({"jsonrpc":"2.0","result":)";
   54|    611|         state.response += result_json;
   55|    611|         state.response += R"(,"id":)";
   56|    611|         state.response += write_json(state.id).value_or("null");
   57|    611|         state.response += "}";
   58|    611|      }
_ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE26register_variable_endpointIdNS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNSt3__117basic_string_viewIcNS6_11char_traitsIcEEEERT_RT0_:
  241|   122k|      {
  242|   122k|         register_read_write_endpoint(path, var, reg);
  243|   122k|      }
_ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE28register_read_write_endpointIdNS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNSt3__117basic_string_viewIcNS6_11char_traitsIcEEEERT_RT0_:
  127|   122k|      {
  128|   122k|         reg.endpoints[path] = [&value](jsonrpc::state&& state) mutable {
  129|   122k|            if (state.has_body()) {
  130|   122k|               if (!jsonrpc::read_params<Opts>(value, state)) {
  131|   122k|                  return;
  132|   122k|               }
  133|   122k|            }
  134|       |
  135|   122k|            if (state.notify()) {
  136|   122k|               return;
  137|   122k|            }
  138|       |
  139|   122k|            if (!state.has_body()) {
  140|   122k|               jsonrpc::write_response<Opts>(value, state);
  141|   122k|            }
  142|   122k|            else {
  143|   122k|               jsonrpc::write_response<Opts>(state);
  144|   122k|            }
  145|   122k|         };
  146|   122k|      }
_ZZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE28register_read_write_endpointIdNS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNSt3__117basic_string_viewIcNS6_11char_traitsIcEEEERT_RT0_ENUlONS_7jsonrpc5stateEE_clESH_:
  128|  1.06k|         reg.endpoints[path] = [&value](jsonrpc::state&& state) mutable {
  129|  1.06k|            if (state.has_body()) {
  ------------------
  |  Branch (129:17): [True: 559, False: 510]
  ------------------
  130|    559|               if (!jsonrpc::read_params<Opts>(value, state)) {
  ------------------
  |  Branch (130:20): [True: 159, False: 400]
  ------------------
  131|    159|                  return;
  132|    159|               }
  133|    559|            }
  134|       |
  135|    910|            if (state.notify()) {
  ------------------
  |  Branch (135:17): [True: 512, False: 398]
  ------------------
  136|    512|               return;
  137|    512|            }
  138|       |
  139|    398|            if (!state.has_body()) {
  ------------------
  |  Branch (139:17): [True: 30, False: 368]
  ------------------
  140|     30|               jsonrpc::write_response<Opts>(value, state);
  141|     30|            }
  142|    368|            else {
  143|    368|               jsonrpc::write_response<Opts>(state);
  144|    368|            }
  145|    398|         };
_ZN3glz7jsonrpc11read_paramsITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERdTkNS0_8is_stateERNS0_5stateEEEbOT0_OT1_:
   97|    559|      {
   98|    559|         if (!state.has_body()) {
  ------------------
  |  Branch (98:14): [True: 0, False: 559]
  ------------------
   99|      0|            return true; // No params to read
  100|      0|         }
  101|       |
  102|    559|         auto ec = read<Opts>(std::forward<Value>(value), state.params_json);
  103|    559|         if (ec) {
  ------------------
  |  Branch (103:14): [True: 159, False: 400]
  ------------------
  104|    159|            write_error(state, rpc::error_e::invalid_params, "Invalid params", format_error(ec, state.params_json));
  105|    159|            return false;
  106|    159|         }
  107|    400|         return true;
  108|    559|      }
_ZN3glz7jsonrpc14write_responseITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERdTkNS0_8is_stateERNS0_5stateEEEvOT0_OT1_:
   37|  1.78k|      {
   38|  1.78k|         if (state.notify()) {
  ------------------
  |  Branch (38:14): [True: 0, False: 1.78k]
  ------------------
   39|      0|            return; // No response for notifications
   40|      0|         }
   41|       |
   42|  1.78k|         std::string result_json;
   43|  1.78k|         auto ec = write<Opts>(std::forward<Value>(value), result_json);
   44|  1.78k|         if (ec) {
  ------------------
  |  Branch (44:14): [True: 0, False: 1.78k]
  ------------------
   45|       |            // Write error response
   46|      0|            state.response =
   47|      0|               R"({"jsonrpc":"2.0","error":{"code":-32603,"message":"Internal error","data":"Failed to serialize result"},"id":)";
   48|      0|            state.response += write_json(state.id).value_or("null");
   49|      0|            state.response += "}";
   50|      0|            return;
   51|      0|         }
   52|       |
   53|  1.78k|         state.response = R"({"jsonrpc":"2.0","result":)";
   54|  1.78k|         state.response += result_json;
   55|  1.78k|         state.response += R"(,"id":)";
   56|  1.78k|         state.response += write_json(state.id).value_or("null");
   57|  1.78k|         state.response += "}";
   58|  1.78k|      }
_ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE24register_object_endpointIN12jsonrpc_fuzz5pointENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNSt3__117basic_string_viewIcNS8_11char_traitsIcEEEERT_RT0_:
  212|  61.1k|      {
  213|  61.1k|         register_read_write_endpoint(path, obj, reg);
  214|  61.1k|      }
_ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE28register_read_write_endpointIN12jsonrpc_fuzz5pointENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNSt3__117basic_string_viewIcNS8_11char_traitsIcEEEERT_RT0_:
  127|  61.1k|      {
  128|  61.1k|         reg.endpoints[path] = [&value](jsonrpc::state&& state) mutable {
  129|  61.1k|            if (state.has_body()) {
  130|  61.1k|               if (!jsonrpc::read_params<Opts>(value, state)) {
  131|  61.1k|                  return;
  132|  61.1k|               }
  133|  61.1k|            }
  134|       |
  135|  61.1k|            if (state.notify()) {
  136|  61.1k|               return;
  137|  61.1k|            }
  138|       |
  139|  61.1k|            if (!state.has_body()) {
  140|  61.1k|               jsonrpc::write_response<Opts>(value, state);
  141|  61.1k|            }
  142|  61.1k|            else {
  143|  61.1k|               jsonrpc::write_response<Opts>(state);
  144|  61.1k|            }
  145|  61.1k|         };
  146|  61.1k|      }
_ZZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE28register_read_write_endpointIN12jsonrpc_fuzz5pointENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNSt3__117basic_string_viewIcNS8_11char_traitsIcEEEERT_RT0_ENUlONS_7jsonrpc5stateEE_clESJ_:
  128|  1.04k|         reg.endpoints[path] = [&value](jsonrpc::state&& state) mutable {
  129|  1.04k|            if (state.has_body()) {
  ------------------
  |  Branch (129:17): [True: 191, False: 852]
  ------------------
  130|    191|               if (!jsonrpc::read_params<Opts>(value, state)) {
  ------------------
  |  Branch (130:20): [True: 180, False: 11]
  ------------------
  131|    180|                  return;
  132|    180|               }
  133|    191|            }
  134|       |
  135|    863|            if (state.notify()) {
  ------------------
  |  Branch (135:17): [True: 740, False: 123]
  ------------------
  136|    740|               return;
  137|    740|            }
  138|       |
  139|    123|            if (!state.has_body()) {
  ------------------
  |  Branch (139:17): [True: 114, False: 9]
  ------------------
  140|    114|               jsonrpc::write_response<Opts>(value, state);
  141|    114|            }
  142|      9|            else {
  143|      9|               jsonrpc::write_response<Opts>(state);
  144|      9|            }
  145|    123|         };
_ZN3glz7jsonrpc14write_responseITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERN12jsonrpc_fuzz5pointETkNS0_8is_stateERNS0_5stateEEEvOT0_OT1_:
   37|    219|      {
   38|    219|         if (state.notify()) {
  ------------------
  |  Branch (38:14): [True: 0, False: 219]
  ------------------
   39|      0|            return; // No response for notifications
   40|      0|         }
   41|       |
   42|    219|         std::string result_json;
   43|    219|         auto ec = write<Opts>(std::forward<Value>(value), result_json);
   44|    219|         if (ec) {
  ------------------
  |  Branch (44:14): [True: 0, False: 219]
  ------------------
   45|       |            // Write error response
   46|      0|            state.response =
   47|      0|               R"({"jsonrpc":"2.0","error":{"code":-32603,"message":"Internal error","data":"Failed to serialize result"},"id":)";
   48|      0|            state.response += write_json(state.id).value_or("null");
   49|      0|            state.response += "}";
   50|      0|            return;
   51|      0|         }
   52|       |
   53|    219|         state.response = R"({"jsonrpc":"2.0","result":)";
   54|    219|         state.response += result_json;
   55|    219|         state.response += R"(,"id":)";
   56|    219|         state.response += write_json(state.id).value_or("null");
   57|    219|         state.response += "}";
   58|    219|      }
_ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE24register_object_endpointIN12jsonrpc_fuzz6nestedENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNSt3__117basic_string_viewIcNS8_11char_traitsIcEEEERT_RT0_:
  212|  61.1k|      {
  213|  61.1k|         register_read_write_endpoint(path, obj, reg);
  214|  61.1k|      }
_ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE28register_read_write_endpointIN12jsonrpc_fuzz6nestedENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNSt3__117basic_string_viewIcNS8_11char_traitsIcEEEERT_RT0_:
  127|  61.1k|      {
  128|  61.1k|         reg.endpoints[path] = [&value](jsonrpc::state&& state) mutable {
  129|  61.1k|            if (state.has_body()) {
  130|  61.1k|               if (!jsonrpc::read_params<Opts>(value, state)) {
  131|  61.1k|                  return;
  132|  61.1k|               }
  133|  61.1k|            }
  134|       |
  135|  61.1k|            if (state.notify()) {
  136|  61.1k|               return;
  137|  61.1k|            }
  138|       |
  139|  61.1k|            if (!state.has_body()) {
  140|  61.1k|               jsonrpc::write_response<Opts>(value, state);
  141|  61.1k|            }
  142|  61.1k|            else {
  143|  61.1k|               jsonrpc::write_response<Opts>(state);
  144|  61.1k|            }
  145|  61.1k|         };
  146|  61.1k|      }
_ZZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE28register_read_write_endpointIN12jsonrpc_fuzz6nestedENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNSt3__117basic_string_viewIcNS8_11char_traitsIcEEEERT_RT0_ENUlONS_7jsonrpc5stateEE_clESJ_:
  128|  2.46k|         reg.endpoints[path] = [&value](jsonrpc::state&& state) mutable {
  129|  2.46k|            if (state.has_body()) {
  ------------------
  |  Branch (129:17): [True: 1.56k, False: 906]
  ------------------
  130|  1.56k|               if (!jsonrpc::read_params<Opts>(value, state)) {
  ------------------
  |  Branch (130:20): [True: 1.36k, False: 200]
  ------------------
  131|  1.36k|                  return;
  132|  1.36k|               }
  133|  1.56k|            }
  134|       |
  135|  1.10k|            if (state.notify()) {
  ------------------
  |  Branch (135:17): [True: 889, False: 217]
  ------------------
  136|    889|               return;
  137|    889|            }
  138|       |
  139|    217|            if (!state.has_body()) {
  ------------------
  |  Branch (139:17): [True: 56, False: 161]
  ------------------
  140|     56|               jsonrpc::write_response<Opts>(value, state);
  141|     56|            }
  142|    161|            else {
  143|    161|               jsonrpc::write_response<Opts>(state);
  144|    161|            }
  145|    217|         };
_ZN3glz7jsonrpc11read_paramsITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERN12jsonrpc_fuzz6nestedETkNS0_8is_stateERNS0_5stateEEEbOT0_OT1_:
   97|  1.56k|      {
   98|  1.56k|         if (!state.has_body()) {
  ------------------
  |  Branch (98:14): [True: 0, False: 1.56k]
  ------------------
   99|      0|            return true; // No params to read
  100|      0|         }
  101|       |
  102|  1.56k|         auto ec = read<Opts>(std::forward<Value>(value), state.params_json);
  103|  1.56k|         if (ec) {
  ------------------
  |  Branch (103:14): [True: 1.36k, False: 200]
  ------------------
  104|  1.36k|            write_error(state, rpc::error_e::invalid_params, "Invalid params", format_error(ec, state.params_json));
  105|  1.36k|            return false;
  106|  1.36k|         }
  107|    200|         return true;
  108|  1.56k|      }
_ZN3glz7jsonrpc14write_responseITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERN12jsonrpc_fuzz6nestedETkNS0_8is_stateERNS0_5stateEEEvOT0_OT1_:
   37|     56|      {
   38|     56|         if (state.notify()) {
  ------------------
  |  Branch (38:14): [True: 0, False: 56]
  ------------------
   39|      0|            return; // No response for notifications
   40|      0|         }
   41|       |
   42|     56|         std::string result_json;
   43|     56|         auto ec = write<Opts>(std::forward<Value>(value), result_json);
   44|     56|         if (ec) {
  ------------------
  |  Branch (44:14): [True: 0, False: 56]
  ------------------
   45|       |            // Write error response
   46|      0|            state.response =
   47|      0|               R"({"jsonrpc":"2.0","error":{"code":-32603,"message":"Internal error","data":"Failed to serialize result"},"id":)";
   48|      0|            state.response += write_json(state.id).value_or("null");
   49|      0|            state.response += "}";
   50|      0|            return;
   51|      0|         }
   52|       |
   53|     56|         state.response = R"({"jsonrpc":"2.0","result":)";
   54|     56|         state.response += result_json;
   55|     56|         state.response += R"(,"id":)";
   56|     56|         state.response += write_json(state.id).value_or("null");
   57|     56|         state.response += "}";
   58|     56|      }
_ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE26register_variable_endpointINSt3__16vectorIiNS4_9allocatorIiEEEENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNS4_17basic_string_viewIcNS4_11char_traitsIcEEEERT_RT0_:
  241|  61.1k|      {
  242|  61.1k|         register_read_write_endpoint(path, var, reg);
  243|  61.1k|      }
_ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE28register_read_write_endpointINSt3__16vectorIiNS4_9allocatorIiEEEENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNS4_17basic_string_viewIcNS4_11char_traitsIcEEEERT_RT0_:
  127|  61.1k|      {
  128|  61.1k|         reg.endpoints[path] = [&value](jsonrpc::state&& state) mutable {
  129|  61.1k|            if (state.has_body()) {
  130|  61.1k|               if (!jsonrpc::read_params<Opts>(value, state)) {
  131|  61.1k|                  return;
  132|  61.1k|               }
  133|  61.1k|            }
  134|       |
  135|  61.1k|            if (state.notify()) {
  136|  61.1k|               return;
  137|  61.1k|            }
  138|       |
  139|  61.1k|            if (!state.has_body()) {
  140|  61.1k|               jsonrpc::write_response<Opts>(value, state);
  141|  61.1k|            }
  142|  61.1k|            else {
  143|  61.1k|               jsonrpc::write_response<Opts>(state);
  144|  61.1k|            }
  145|  61.1k|         };
  146|  61.1k|      }
_ZZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE28register_read_write_endpointINSt3__16vectorIiNS4_9allocatorIiEEEENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNS4_17basic_string_viewIcNS4_11char_traitsIcEEEERT_RT0_ENUlONS_7jsonrpc5stateEE_clESL_:
  128|  3.33k|         reg.endpoints[path] = [&value](jsonrpc::state&& state) mutable {
  129|  3.33k|            if (state.has_body()) {
  ------------------
  |  Branch (129:17): [True: 1.99k, False: 1.33k]
  ------------------
  130|  1.99k|               if (!jsonrpc::read_params<Opts>(value, state)) {
  ------------------
  |  Branch (130:20): [True: 1.55k, False: 435]
  ------------------
  131|  1.55k|                  return;
  132|  1.55k|               }
  133|  1.99k|            }
  134|       |
  135|  1.77k|            if (state.notify()) {
  ------------------
  |  Branch (135:17): [True: 1.20k, False: 568]
  ------------------
  136|  1.20k|               return;
  137|  1.20k|            }
  138|       |
  139|    568|            if (!state.has_body()) {
  ------------------
  |  Branch (139:17): [True: 147, False: 421]
  ------------------
  140|    147|               jsonrpc::write_response<Opts>(value, state);
  141|    147|            }
  142|    421|            else {
  143|    421|               jsonrpc::write_response<Opts>(state);
  144|    421|            }
  145|    568|         };
_ZN3glz7jsonrpc11read_paramsITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__16vectorIiNS3_9allocatorIiEEEETkNS0_8is_stateERNS0_5stateEEEbOT0_OT1_:
   97|  1.99k|      {
   98|  1.99k|         if (!state.has_body()) {
  ------------------
  |  Branch (98:14): [True: 0, False: 1.99k]
  ------------------
   99|      0|            return true; // No params to read
  100|      0|         }
  101|       |
  102|  1.99k|         auto ec = read<Opts>(std::forward<Value>(value), state.params_json);
  103|  1.99k|         if (ec) {
  ------------------
  |  Branch (103:14): [True: 1.55k, False: 435]
  ------------------
  104|  1.55k|            write_error(state, rpc::error_e::invalid_params, "Invalid params", format_error(ec, state.params_json));
  105|  1.55k|            return false;
  106|  1.55k|         }
  107|    435|         return true;
  108|  1.99k|      }
_ZN3glz7jsonrpc14write_responseITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__16vectorIiNS3_9allocatorIiEEEETkNS0_8is_stateERNS0_5stateEEEvOT0_OT1_:
   37|    147|      {
   38|    147|         if (state.notify()) {
  ------------------
  |  Branch (38:14): [True: 0, False: 147]
  ------------------
   39|      0|            return; // No response for notifications
   40|      0|         }
   41|       |
   42|    147|         std::string result_json;
   43|    147|         auto ec = write<Opts>(std::forward<Value>(value), result_json);
   44|    147|         if (ec) {
  ------------------
  |  Branch (44:14): [True: 0, False: 147]
  ------------------
   45|       |            // Write error response
   46|      0|            state.response =
   47|      0|               R"({"jsonrpc":"2.0","error":{"code":-32603,"message":"Internal error","data":"Failed to serialize result"},"id":)";
   48|      0|            state.response += write_json(state.id).value_or("null");
   49|      0|            state.response += "}";
   50|      0|            return;
   51|      0|         }
   52|       |
   53|    147|         state.response = R"({"jsonrpc":"2.0","result":)";
   54|    147|         state.response += result_json;
   55|    147|         state.response += R"(,"id":)";
   56|    147|         state.response += write_json(state.id).value_or("null");
   57|    147|         state.response += "}";
   58|    147|      }
_ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE26register_variable_endpointINSt3__13mapINS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEiNS4_4lessISB_EENS9_INS4_4pairIKSB_iEEEEEENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNS4_17basic_string_viewIcS8_EERT_RT0_:
  241|  61.1k|      {
  242|  61.1k|         register_read_write_endpoint(path, var, reg);
  243|  61.1k|      }
_ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE28register_read_write_endpointINSt3__13mapINS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEiNS4_4lessISB_EENS9_INS4_4pairIKSB_iEEEEEENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNS4_17basic_string_viewIcS8_EERT_RT0_:
  127|  61.1k|      {
  128|  61.1k|         reg.endpoints[path] = [&value](jsonrpc::state&& state) mutable {
  129|  61.1k|            if (state.has_body()) {
  130|  61.1k|               if (!jsonrpc::read_params<Opts>(value, state)) {
  131|  61.1k|                  return;
  132|  61.1k|               }
  133|  61.1k|            }
  134|       |
  135|  61.1k|            if (state.notify()) {
  136|  61.1k|               return;
  137|  61.1k|            }
  138|       |
  139|  61.1k|            if (!state.has_body()) {
  140|  61.1k|               jsonrpc::write_response<Opts>(value, state);
  141|  61.1k|            }
  142|  61.1k|            else {
  143|  61.1k|               jsonrpc::write_response<Opts>(state);
  144|  61.1k|            }
  145|  61.1k|         };
  146|  61.1k|      }
_ZZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE28register_read_write_endpointINSt3__13mapINS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEiNS4_4lessISB_EENS9_INS4_4pairIKSB_iEEEEEENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNS4_17basic_string_viewIcS8_EERT_RT0_ENUlONS_7jsonrpc5stateEE_clEST_:
  128|  2.81k|         reg.endpoints[path] = [&value](jsonrpc::state&& state) mutable {
  129|  2.81k|            if (state.has_body()) {
  ------------------
  |  Branch (129:17): [True: 1.84k, False: 964]
  ------------------
  130|  1.84k|               if (!jsonrpc::read_params<Opts>(value, state)) {
  ------------------
  |  Branch (130:20): [True: 1.53k, False: 316]
  ------------------
  131|  1.53k|                  return;
  132|  1.53k|               }
  133|  1.84k|            }
  134|       |
  135|  1.28k|            if (state.notify()) {
  ------------------
  |  Branch (135:17): [True: 995, False: 285]
  ------------------
  136|    995|               return;
  137|    995|            }
  138|       |
  139|    285|            if (!state.has_body()) {
  ------------------
  |  Branch (139:17): [True: 32, False: 253]
  ------------------
  140|     32|               jsonrpc::write_response<Opts>(value, state);
  141|     32|            }
  142|    253|            else {
  143|    253|               jsonrpc::write_response<Opts>(state);
  144|    253|            }
  145|    285|         };
_ZN3glz7jsonrpc11read_paramsITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__13mapINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEiNS3_4lessISA_EENS8_INS3_4pairIKSA_iEEEEEETkNS0_8is_stateERNS0_5stateEEEbOT0_OT1_:
   97|  1.84k|      {
   98|  1.84k|         if (!state.has_body()) {
  ------------------
  |  Branch (98:14): [True: 0, False: 1.84k]
  ------------------
   99|      0|            return true; // No params to read
  100|      0|         }
  101|       |
  102|  1.84k|         auto ec = read<Opts>(std::forward<Value>(value), state.params_json);
  103|  1.84k|         if (ec) {
  ------------------
  |  Branch (103:14): [True: 1.53k, False: 316]
  ------------------
  104|  1.53k|            write_error(state, rpc::error_e::invalid_params, "Invalid params", format_error(ec, state.params_json));
  105|  1.53k|            return false;
  106|  1.53k|         }
  107|    316|         return true;
  108|  1.84k|      }
_ZN3glz7jsonrpc14write_responseITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__13mapINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEiNS3_4lessISA_EENS8_INS3_4pairIKSA_iEEEEEETkNS0_8is_stateERNS0_5stateEEEvOT0_OT1_:
   37|     32|      {
   38|     32|         if (state.notify()) {
  ------------------
  |  Branch (38:14): [True: 0, False: 32]
  ------------------
   39|      0|            return; // No response for notifications
   40|      0|         }
   41|       |
   42|     32|         std::string result_json;
   43|     32|         auto ec = write<Opts>(std::forward<Value>(value), result_json);
   44|     32|         if (ec) {
  ------------------
  |  Branch (44:14): [True: 0, False: 32]
  ------------------
   45|       |            // Write error response
   46|      0|            state.response =
   47|      0|               R"({"jsonrpc":"2.0","error":{"code":-32603,"message":"Internal error","data":"Failed to serialize result"},"id":)";
   48|      0|            state.response += write_json(state.id).value_or("null");
   49|      0|            state.response += "}";
   50|      0|            return;
   51|      0|         }
   52|       |
   53|     32|         state.response = R"({"jsonrpc":"2.0","result":)";
   54|     32|         state.response += result_json;
   55|     32|         state.response += R"(,"id":)";
   56|     32|         state.response += write_json(state.id).value_or("null");
   57|     32|         state.response += "}";
   58|     32|      }
_ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE26register_variable_endpointINSt3__18optionalIdEENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNS4_17basic_string_viewIcNS4_11char_traitsIcEEEERT_RT0_:
  241|  61.1k|      {
  242|  61.1k|         register_read_write_endpoint(path, var, reg);
  243|  61.1k|      }
_ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE28register_read_write_endpointINSt3__18optionalIdEENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNS4_17basic_string_viewIcNS4_11char_traitsIcEEEERT_RT0_:
  127|  61.1k|      {
  128|  61.1k|         reg.endpoints[path] = [&value](jsonrpc::state&& state) mutable {
  129|  61.1k|            if (state.has_body()) {
  130|  61.1k|               if (!jsonrpc::read_params<Opts>(value, state)) {
  131|  61.1k|                  return;
  132|  61.1k|               }
  133|  61.1k|            }
  134|       |
  135|  61.1k|            if (state.notify()) {
  136|  61.1k|               return;
  137|  61.1k|            }
  138|       |
  139|  61.1k|            if (!state.has_body()) {
  140|  61.1k|               jsonrpc::write_response<Opts>(value, state);
  141|  61.1k|            }
  142|  61.1k|            else {
  143|  61.1k|               jsonrpc::write_response<Opts>(state);
  144|  61.1k|            }
  145|  61.1k|         };
  146|  61.1k|      }
_ZZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE28register_read_write_endpointINSt3__18optionalIdEENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNS4_17basic_string_viewIcNS4_11char_traitsIcEEEERT_RT0_ENUlONS_7jsonrpc5stateEE_clESJ_:
  128|  3.28k|         reg.endpoints[path] = [&value](jsonrpc::state&& state) mutable {
  129|  3.28k|            if (state.has_body()) {
  ------------------
  |  Branch (129:17): [True: 2.00k, False: 1.27k]
  ------------------
  130|  2.00k|               if (!jsonrpc::read_params<Opts>(value, state)) {
  ------------------
  |  Branch (130:20): [True: 336, False: 1.67k]
  ------------------
  131|    336|                  return;
  132|    336|               }
  133|  2.00k|            }
  134|       |
  135|  2.94k|            if (state.notify()) {
  ------------------
  |  Branch (135:17): [True: 1.42k, False: 1.51k]
  ------------------
  136|  1.42k|               return;
  137|  1.42k|            }
  138|       |
  139|  1.51k|            if (!state.has_body()) {
  ------------------
  |  Branch (139:17): [True: 56, False: 1.46k]
  ------------------
  140|     56|               jsonrpc::write_response<Opts>(value, state);
  141|     56|            }
  142|  1.46k|            else {
  143|  1.46k|               jsonrpc::write_response<Opts>(state);
  144|  1.46k|            }
  145|  1.51k|         };
_ZN3glz7jsonrpc11read_paramsITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__18optionalIdEETkNS0_8is_stateERNS0_5stateEEEbOT0_OT1_:
   97|  2.00k|      {
   98|  2.00k|         if (!state.has_body()) {
  ------------------
  |  Branch (98:14): [True: 0, False: 2.00k]
  ------------------
   99|      0|            return true; // No params to read
  100|      0|         }
  101|       |
  102|  2.00k|         auto ec = read<Opts>(std::forward<Value>(value), state.params_json);
  103|  2.00k|         if (ec) {
  ------------------
  |  Branch (103:14): [True: 336, False: 1.67k]
  ------------------
  104|    336|            write_error(state, rpc::error_e::invalid_params, "Invalid params", format_error(ec, state.params_json));
  105|    336|            return false;
  106|    336|         }
  107|  1.67k|         return true;
  108|  2.00k|      }
_ZN3glz7jsonrpc14write_responseITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__18optionalIdEETkNS0_8is_stateERNS0_5stateEEEvOT0_OT1_:
   37|     56|      {
   38|     56|         if (state.notify()) {
  ------------------
  |  Branch (38:14): [True: 0, False: 56]
  ------------------
   39|      0|            return; // No response for notifications
   40|      0|         }
   41|       |
   42|     56|         std::string result_json;
   43|     56|         auto ec = write<Opts>(std::forward<Value>(value), result_json);
   44|     56|         if (ec) {
  ------------------
  |  Branch (44:14): [True: 0, False: 56]
  ------------------
   45|       |            // Write error response
   46|      0|            state.response =
   47|      0|               R"({"jsonrpc":"2.0","error":{"code":-32603,"message":"Internal error","data":"Failed to serialize result"},"id":)";
   48|      0|            state.response += write_json(state.id).value_or("null");
   49|      0|            state.response += "}";
   50|      0|            return;
   51|      0|         }
   52|       |
   53|     56|         state.response = R"({"jsonrpc":"2.0","result":)";
   54|     56|         state.response += result_json;
   55|     56|         state.response += R"(,"id":)";
   56|     56|         state.response += write_json(state.id).value_or("null");
   57|     56|         state.response += "}";
   58|     56|      }
_ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE26register_variable_endpointINSt3__17variantIJNS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEN12jsonrpc_fuzz6amountEEEENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNS4_17basic_string_viewIcS8_EERT_RT0_:
  241|  61.1k|      {
  242|  61.1k|         register_read_write_endpoint(path, var, reg);
  243|  61.1k|      }
_ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE28register_read_write_endpointINSt3__17variantIJNS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEN12jsonrpc_fuzz6amountEEEENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNS4_17basic_string_viewIcS8_EERT_RT0_:
  127|  61.1k|      {
  128|  61.1k|         reg.endpoints[path] = [&value](jsonrpc::state&& state) mutable {
  129|  61.1k|            if (state.has_body()) {
  130|  61.1k|               if (!jsonrpc::read_params<Opts>(value, state)) {
  131|  61.1k|                  return;
  132|  61.1k|               }
  133|  61.1k|            }
  134|       |
  135|  61.1k|            if (state.notify()) {
  136|  61.1k|               return;
  137|  61.1k|            }
  138|       |
  139|  61.1k|            if (!state.has_body()) {
  140|  61.1k|               jsonrpc::write_response<Opts>(value, state);
  141|  61.1k|            }
  142|  61.1k|            else {
  143|  61.1k|               jsonrpc::write_response<Opts>(state);
  144|  61.1k|            }
  145|  61.1k|         };
  146|  61.1k|      }
_ZZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE28register_read_write_endpointINSt3__17variantIJNS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEN12jsonrpc_fuzz6amountEEEENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNS4_17basic_string_viewIcS8_EERT_RT0_ENUlONS_7jsonrpc5stateEE_clESP_:
  128|  1.99k|         reg.endpoints[path] = [&value](jsonrpc::state&& state) mutable {
  129|  1.99k|            if (state.has_body()) {
  ------------------
  |  Branch (129:17): [True: 1.09k, False: 897]
  ------------------
  130|  1.09k|               if (!jsonrpc::read_params<Opts>(value, state)) {
  ------------------
  |  Branch (130:20): [True: 689, False: 406]
  ------------------
  131|    689|                  return;
  132|    689|               }
  133|  1.09k|            }
  134|       |
  135|  1.30k|            if (state.notify()) {
  ------------------
  |  Branch (135:17): [True: 903, False: 400]
  ------------------
  136|    903|               return;
  137|    903|            }
  138|       |
  139|    400|            if (!state.has_body()) {
  ------------------
  |  Branch (139:17): [True: 63, False: 337]
  ------------------
  140|     63|               jsonrpc::write_response<Opts>(value, state);
  141|     63|            }
  142|    337|            else {
  143|    337|               jsonrpc::write_response<Opts>(state);
  144|    337|            }
  145|    400|         };
_ZN3glz7jsonrpc11read_paramsITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__17variantIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEN12jsonrpc_fuzz6amountEEEETkNS0_8is_stateERNS0_5stateEEEbOT0_OT1_:
   97|  1.09k|      {
   98|  1.09k|         if (!state.has_body()) {
  ------------------
  |  Branch (98:14): [True: 0, False: 1.09k]
  ------------------
   99|      0|            return true; // No params to read
  100|      0|         }
  101|       |
  102|  1.09k|         auto ec = read<Opts>(std::forward<Value>(value), state.params_json);
  103|  1.09k|         if (ec) {
  ------------------
  |  Branch (103:14): [True: 689, False: 406]
  ------------------
  104|    689|            write_error(state, rpc::error_e::invalid_params, "Invalid params", format_error(ec, state.params_json));
  105|    689|            return false;
  106|    689|         }
  107|    406|         return true;
  108|  1.09k|      }
_ZN3glz7jsonrpc14write_responseITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__17variantIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEN12jsonrpc_fuzz6amountEEEETkNS0_8is_stateERNS0_5stateEEEvOT0_OT1_:
   37|     63|      {
   38|     63|         if (state.notify()) {
  ------------------
  |  Branch (38:14): [True: 0, False: 63]
  ------------------
   39|      0|            return; // No response for notifications
   40|      0|         }
   41|       |
   42|     63|         std::string result_json;
   43|     63|         auto ec = write<Opts>(std::forward<Value>(value), result_json);
   44|     63|         if (ec) {
  ------------------
  |  Branch (44:14): [True: 0, False: 63]
  ------------------
   45|       |            // Write error response
   46|      0|            state.response =
   47|      0|               R"({"jsonrpc":"2.0","error":{"code":-32603,"message":"Internal error","data":"Failed to serialize result"},"id":)";
   48|      0|            state.response += write_json(state.id).value_or("null");
   49|      0|            state.response += "}";
   50|      0|            return;
   51|      0|         }
   52|       |
   53|     63|         state.response = R"({"jsonrpc":"2.0","result":)";
   54|     63|         state.response += result_json;
   55|     63|         state.response += R"(,"id":)";
   56|     63|         state.response += write_json(state.id).value_or("null");
   57|     63|         state.response += "}";
   58|     63|      }
_ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE32register_param_function_endpointIRNSt3__18functionIFiiEEEiNS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNS4_17basic_string_viewIcNS4_11char_traitsIcEEEERT_RT1_:
  180|  61.1k|      {
  181|  61.1k|         reg.endpoints[path] = [&func](jsonrpc::state&& state) mutable {
  182|  61.1k|            static thread_local std::decay_t<Params> params{};
  183|  61.1k|            params = {}; // reset to avoid stale optional/variant fields across calls
  184|  61.1k|            if (!jsonrpc::read_params<Opts>(params, state)) {
  185|  61.1k|               return;
  186|  61.1k|            }
  187|       |
  188|  61.1k|            using Result = std::invoke_result_t<decltype(func), Params>;
  189|       |
  190|  61.1k|            if (state.notify()) {
  191|  61.1k|               if constexpr (std::same_as<Result, void>) {
  192|  61.1k|                  func(params);
  193|  61.1k|               }
  194|  61.1k|               else {
  195|  61.1k|                  std::ignore = func(params);
  196|  61.1k|               }
  197|  61.1k|               return;
  198|  61.1k|            }
  199|  61.1k|            if constexpr (std::same_as<Result, void>) {
  200|  61.1k|               func(params);
  201|  61.1k|               jsonrpc::write_response<Opts>(state);
  202|  61.1k|            }
  203|  61.1k|            else {
  204|  61.1k|               auto ret = func(params);
  205|  61.1k|               jsonrpc::write_response<Opts>(ret, state);
  206|  61.1k|            }
  207|  61.1k|         };
  208|  61.1k|      }
_ZZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE32register_param_function_endpointIRNSt3__18functionIFiiEEEiNS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNS4_17basic_string_viewIcNS4_11char_traitsIcEEEERT_RT1_ENUlONS_7jsonrpc5stateEE_clESL_:
  181|  1.14k|         reg.endpoints[path] = [&func](jsonrpc::state&& state) mutable {
  182|  1.14k|            static thread_local std::decay_t<Params> params{};
  183|  1.14k|            params = {}; // reset to avoid stale optional/variant fields across calls
  184|  1.14k|            if (!jsonrpc::read_params<Opts>(params, state)) {
  ------------------
  |  Branch (184:17): [True: 248, False: 897]
  ------------------
  185|    248|               return;
  186|    248|            }
  187|       |
  188|    897|            using Result = std::invoke_result_t<decltype(func), Params>;
  189|       |
  190|    897|            if (state.notify()) {
  ------------------
  |  Branch (190:17): [True: 594, False: 303]
  ------------------
  191|       |               if constexpr (std::same_as<Result, void>) {
  192|       |                  func(params);
  193|       |               }
  194|    594|               else {
  195|    594|                  std::ignore = func(params);
  196|    594|               }
  197|    594|               return;
  198|    594|            }
  199|       |            if constexpr (std::same_as<Result, void>) {
  200|       |               func(params);
  201|       |               jsonrpc::write_response<Opts>(state);
  202|       |            }
  203|    303|            else {
  204|    303|               auto ret = func(params);
  205|    303|               jsonrpc::write_response<Opts>(ret, state);
  206|    303|            }
  207|    303|         };
_ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE32register_param_function_endpointIRNSt3__18functionIFNS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERKSB_EEESD_NS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNS4_17basic_string_viewIcS8_EERT_RT1_:
  180|  61.1k|      {
  181|  61.1k|         reg.endpoints[path] = [&func](jsonrpc::state&& state) mutable {
  182|  61.1k|            static thread_local std::decay_t<Params> params{};
  183|  61.1k|            params = {}; // reset to avoid stale optional/variant fields across calls
  184|  61.1k|            if (!jsonrpc::read_params<Opts>(params, state)) {
  185|  61.1k|               return;
  186|  61.1k|            }
  187|       |
  188|  61.1k|            using Result = std::invoke_result_t<decltype(func), Params>;
  189|       |
  190|  61.1k|            if (state.notify()) {
  191|  61.1k|               if constexpr (std::same_as<Result, void>) {
  192|  61.1k|                  func(params);
  193|  61.1k|               }
  194|  61.1k|               else {
  195|  61.1k|                  std::ignore = func(params);
  196|  61.1k|               }
  197|  61.1k|               return;
  198|  61.1k|            }
  199|  61.1k|            if constexpr (std::same_as<Result, void>) {
  200|  61.1k|               func(params);
  201|  61.1k|               jsonrpc::write_response<Opts>(state);
  202|  61.1k|            }
  203|  61.1k|            else {
  204|  61.1k|               auto ret = func(params);
  205|  61.1k|               jsonrpc::write_response<Opts>(ret, state);
  206|  61.1k|            }
  207|  61.1k|         };
  208|  61.1k|      }
_ZZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE32register_param_function_endpointIRNSt3__18functionIFNS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERKSB_EEESD_NS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNS4_17basic_string_viewIcS8_EERT_RT1_ENUlONS_7jsonrpc5stateEE_clESR_:
  181|  2.86k|         reg.endpoints[path] = [&func](jsonrpc::state&& state) mutable {
  182|  2.86k|            static thread_local std::decay_t<Params> params{};
  183|  2.86k|            params = {}; // reset to avoid stale optional/variant fields across calls
  184|  2.86k|            if (!jsonrpc::read_params<Opts>(params, state)) {
  ------------------
  |  Branch (184:17): [True: 460, False: 2.40k]
  ------------------
  185|    460|               return;
  186|    460|            }
  187|       |
  188|  2.40k|            using Result = std::invoke_result_t<decltype(func), Params>;
  189|       |
  190|  2.40k|            if (state.notify()) {
  ------------------
  |  Branch (190:17): [True: 1.81k, False: 586]
  ------------------
  191|       |               if constexpr (std::same_as<Result, void>) {
  192|       |                  func(params);
  193|       |               }
  194|  1.81k|               else {
  195|  1.81k|                  std::ignore = func(params);
  196|  1.81k|               }
  197|  1.81k|               return;
  198|  1.81k|            }
  199|       |            if constexpr (std::same_as<Result, void>) {
  200|       |               func(params);
  201|       |               jsonrpc::write_response<Opts>(state);
  202|       |            }
  203|    586|            else {
  204|    586|               auto ret = func(params);
  205|    586|               jsonrpc::write_response<Opts>(ret, state);
  206|    586|            }
  207|    586|         };
_ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE32register_param_function_endpointIRNSt3__18functionIFN12jsonrpc_fuzz5pointERKS7_EEES9_NS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNS4_17basic_string_viewIcNS4_11char_traitsIcEEEERT_RT1_:
  180|  61.1k|      {
  181|  61.1k|         reg.endpoints[path] = [&func](jsonrpc::state&& state) mutable {
  182|  61.1k|            static thread_local std::decay_t<Params> params{};
  183|  61.1k|            params = {}; // reset to avoid stale optional/variant fields across calls
  184|  61.1k|            if (!jsonrpc::read_params<Opts>(params, state)) {
  185|  61.1k|               return;
  186|  61.1k|            }
  187|       |
  188|  61.1k|            using Result = std::invoke_result_t<decltype(func), Params>;
  189|       |
  190|  61.1k|            if (state.notify()) {
  191|  61.1k|               if constexpr (std::same_as<Result, void>) {
  192|  61.1k|                  func(params);
  193|  61.1k|               }
  194|  61.1k|               else {
  195|  61.1k|                  std::ignore = func(params);
  196|  61.1k|               }
  197|  61.1k|               return;
  198|  61.1k|            }
  199|  61.1k|            if constexpr (std::same_as<Result, void>) {
  200|  61.1k|               func(params);
  201|  61.1k|               jsonrpc::write_response<Opts>(state);
  202|  61.1k|            }
  203|  61.1k|            else {
  204|  61.1k|               auto ret = func(params);
  205|  61.1k|               jsonrpc::write_response<Opts>(ret, state);
  206|  61.1k|            }
  207|  61.1k|         };
  208|  61.1k|      }
_ZZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE32register_param_function_endpointIRNSt3__18functionIFN12jsonrpc_fuzz5pointERKS7_EEES9_NS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNS4_17basic_string_viewIcNS4_11char_traitsIcEEEERT_RT1_ENUlONS_7jsonrpc5stateEE_clESP_:
  181|  1.05k|         reg.endpoints[path] = [&func](jsonrpc::state&& state) mutable {
  182|  1.05k|            static thread_local std::decay_t<Params> params{};
  183|  1.05k|            params = {}; // reset to avoid stale optional/variant fields across calls
  184|  1.05k|            if (!jsonrpc::read_params<Opts>(params, state)) {
  ------------------
  |  Branch (184:17): [True: 349, False: 706]
  ------------------
  185|    349|               return;
  186|    349|            }
  187|       |
  188|    706|            using Result = std::invoke_result_t<decltype(func), Params>;
  189|       |
  190|    706|            if (state.notify()) {
  ------------------
  |  Branch (190:17): [True: 601, False: 105]
  ------------------
  191|       |               if constexpr (std::same_as<Result, void>) {
  192|       |                  func(params);
  193|       |               }
  194|    601|               else {
  195|    601|                  std::ignore = func(params);
  196|    601|               }
  197|    601|               return;
  198|    601|            }
  199|       |            if constexpr (std::same_as<Result, void>) {
  200|       |               func(params);
  201|       |               jsonrpc::write_response<Opts>(state);
  202|       |            }
  203|    105|            else {
  204|    105|               auto ret = func(params);
  205|    105|               jsonrpc::write_response<Opts>(ret, state);
  206|    105|            }
  207|    105|         };
_ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE32register_param_function_endpointIRNSt3__18functionIFdRNS4_6vectorIdNS4_9allocatorIdEEEEEEESA_NS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNS4_17basic_string_viewIcNS4_11char_traitsIcEEEERT_RT1_:
  180|  61.1k|      {
  181|  61.1k|         reg.endpoints[path] = [&func](jsonrpc::state&& state) mutable {
  182|  61.1k|            static thread_local std::decay_t<Params> params{};
  183|  61.1k|            params = {}; // reset to avoid stale optional/variant fields across calls
  184|  61.1k|            if (!jsonrpc::read_params<Opts>(params, state)) {
  185|  61.1k|               return;
  186|  61.1k|            }
  187|       |
  188|  61.1k|            using Result = std::invoke_result_t<decltype(func), Params>;
  189|       |
  190|  61.1k|            if (state.notify()) {
  191|  61.1k|               if constexpr (std::same_as<Result, void>) {
  192|  61.1k|                  func(params);
  193|  61.1k|               }
  194|  61.1k|               else {
  195|  61.1k|                  std::ignore = func(params);
  196|  61.1k|               }
  197|  61.1k|               return;
  198|  61.1k|            }
  199|  61.1k|            if constexpr (std::same_as<Result, void>) {
  200|  61.1k|               func(params);
  201|  61.1k|               jsonrpc::write_response<Opts>(state);
  202|  61.1k|            }
  203|  61.1k|            else {
  204|  61.1k|               auto ret = func(params);
  205|  61.1k|               jsonrpc::write_response<Opts>(ret, state);
  206|  61.1k|            }
  207|  61.1k|         };
  208|  61.1k|      }
_ZZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE32register_param_function_endpointIRNSt3__18functionIFdRNS4_6vectorIdNS4_9allocatorIdEEEEEEESA_NS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNS4_17basic_string_viewIcNS4_11char_traitsIcEEEERT_RT1_ENUlONS_7jsonrpc5stateEE_clESQ_:
  181|  6.25k|         reg.endpoints[path] = [&func](jsonrpc::state&& state) mutable {
  182|  6.25k|            static thread_local std::decay_t<Params> params{};
  183|  6.25k|            params = {}; // reset to avoid stale optional/variant fields across calls
  184|  6.25k|            if (!jsonrpc::read_params<Opts>(params, state)) {
  ------------------
  |  Branch (184:17): [True: 2.12k, False: 4.12k]
  ------------------
  185|  2.12k|               return;
  186|  2.12k|            }
  187|       |
  188|  4.12k|            using Result = std::invoke_result_t<decltype(func), Params>;
  189|       |
  190|  4.12k|            if (state.notify()) {
  ------------------
  |  Branch (190:17): [True: 2.37k, False: 1.75k]
  ------------------
  191|       |               if constexpr (std::same_as<Result, void>) {
  192|       |                  func(params);
  193|       |               }
  194|  2.37k|               else {
  195|  2.37k|                  std::ignore = func(params);
  196|  2.37k|               }
  197|  2.37k|               return;
  198|  2.37k|            }
  199|       |            if constexpr (std::same_as<Result, void>) {
  200|       |               func(params);
  201|       |               jsonrpc::write_response<Opts>(state);
  202|       |            }
  203|  1.75k|            else {
  204|  1.75k|               auto ret = func(params);
  205|  1.75k|               jsonrpc::write_response<Opts>(ret, state);
  206|  1.75k|            }
  207|  1.75k|         };
_ZN3glz7jsonrpc11read_paramsITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__16vectorIdNS3_9allocatorIdEEEETkNS0_8is_stateERNS0_5stateEEEbOT0_OT1_:
   97|  6.25k|      {
   98|  6.25k|         if (!state.has_body()) {
  ------------------
  |  Branch (98:14): [True: 2.38k, False: 3.87k]
  ------------------
   99|  2.38k|            return true; // No params to read
  100|  2.38k|         }
  101|       |
  102|  3.87k|         auto ec = read<Opts>(std::forward<Value>(value), state.params_json);
  103|  3.87k|         if (ec) {
  ------------------
  |  Branch (103:14): [True: 2.12k, False: 1.74k]
  ------------------
  104|  2.12k|            write_error(state, rpc::error_e::invalid_params, "Invalid params", format_error(ec, state.params_json));
  105|  2.12k|            return false;
  106|  2.12k|         }
  107|  1.74k|         return true;
  108|  3.87k|      }
_ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE26register_function_endpointIRNSt3__18functionIFvvEEEvNS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNS4_17basic_string_viewIcNS4_11char_traitsIcEEEERT_RT1_:
  157|  61.1k|      {
  158|  61.1k|         if constexpr (std::same_as<Result, void>) {
  159|  61.1k|            reg.endpoints[path] = [&func](jsonrpc::state&& state) mutable {
  160|  61.1k|               func();
  161|  61.1k|               if (state.notify()) {
  162|  61.1k|                  return;
  163|  61.1k|               }
  164|  61.1k|               jsonrpc::write_response<Opts>(state);
  165|  61.1k|            };
  166|       |         }
  167|       |         else {
  168|       |            reg.endpoints[path] = [&func](jsonrpc::state&& state) mutable {
  169|       |               if (state.notify()) {
  170|       |                  std::ignore = func();
  171|       |                  return;
  172|       |               }
  173|       |               jsonrpc::write_response<Opts>(func(), state);
  174|       |            };
  175|       |         }
  176|  61.1k|      }
_ZZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE26register_function_endpointIRNSt3__18functionIFvvEEEvNS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNS4_17basic_string_viewIcNS4_11char_traitsIcEEEERT_RT1_ENUlONS_7jsonrpc5stateEE_clESL_:
  159|    517|            reg.endpoints[path] = [&func](jsonrpc::state&& state) mutable {
  160|    517|               func();
  161|    517|               if (state.notify()) {
  ------------------
  |  Branch (161:20): [True: 310, False: 207]
  ------------------
  162|    310|                  return;
  163|    310|               }
  164|    207|               jsonrpc::write_response<Opts>(state);
  165|    207|            };

jsonrpc_registry.cpp:_ZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE2onIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz10member_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_:
  306|  61.1k|      {
  307|  61.1k|         using impl = registry_impl<read_opts, Proto>;
  308|       |
  309|  61.1k|         if constexpr (parent == root && (glaze_object_t<T> || reflectable<T>)) {
  310|  61.1k|            impl::register_endpoint(root, value, *this);
  311|  61.1k|         }
  312|       |
  313|  61.1k|         register_members<root, T, parent>(value);
  314|  61.1k|      }
jsonrpc_registry.cpp:_ZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz10member_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_:
  175|  61.1k|      {
  176|  61.1k|         using namespace glz::detail;
  177|  61.1k|         static constexpr auto N = reflect<T>::size;
  178|       |
  179|  61.1k|         [[maybe_unused]] decltype(auto) t = [&]() -> decltype(auto) {
  180|  61.1k|            if constexpr (reflectable<T> && requires { to_tie(value); }) {
  181|  61.1k|               return to_tie(value);
  182|  61.1k|            }
  183|  61.1k|            else {
  184|  61.1k|               return nullptr;
  185|  61.1k|            }
  186|  61.1k|         }();
  187|       |
  188|  61.1k|         using impl = registry_impl<read_opts, Proto>;
  189|       |
  190|  61.1k|         for_each<N>([&]<auto I>() {
  191|  61.1k|            decltype(auto) func = [&]() -> decltype(auto) {
  192|  61.1k|               if constexpr (reflectable<T>) {
  193|  61.1k|                  return get_member(value, get<I>(t));
  194|  61.1k|               }
  195|  61.1k|               else {
  196|  61.1k|                  return get_member(value, get<I>(reflect<T>::values));
  197|  61.1k|               }
  198|  61.1k|            }();
  199|       |
  200|  61.1k|            static constexpr auto key = reflect<T>::keys[I];
  201|       |
  202|  61.1k|            static constexpr std::string_view full_key = [&] {
  203|  61.1k|               if constexpr (parent == detail::empty_path) {
  204|  61.1k|                  return join_v<chars<"/">, key>;
  205|  61.1k|               }
  206|  61.1k|               else {
  207|  61.1k|                  return join_v<parent, chars<"/">, key>;
  208|  61.1k|               }
  209|  61.1k|            }();
  210|       |
  211|       |            // This logic chain should match glz::cli_menu
  212|  61.1k|            using Func = decltype(func);
  213|  61.1k|            if constexpr (std::is_invocable_v<Func>) {
  214|  61.1k|               using Result = std::decay_t<std::invoke_result_t<Func>>;
  215|  61.1k|               impl::template register_function_endpoint<Func, Result>(full_key, func, *this);
  216|  61.1k|            }
  217|  61.1k|            else if constexpr (is_invocable_concrete<std::remove_cvref_t<Func>>) {
  218|  61.1k|               using Tuple = invocable_args_t<std::remove_cvref_t<Func>>;
  219|  61.1k|               constexpr auto N = glz::tuple_size_v<Tuple>;
  220|  61.1k|               static_assert(N == 1, "Only one input is allowed for your function");
  221|       |
  222|  61.1k|               using Params = glz::tuple_element_t<0, Tuple>;
  223|       |
  224|  61.1k|               impl::template register_param_function_endpoint<Func, Params>(full_key, func, *this);
  225|  61.1k|            }
  226|  61.1k|            else if constexpr (is_function_ptr_invocable<std::remove_cvref_t<Func>>) {
  227|       |               // Handle function pointers with arguments (e.g., void(*)(int))
  228|  61.1k|               using Tuple = function_ptr_args_t<std::remove_cvref_t<Func>>;
  229|  61.1k|               constexpr auto N = glz::tuple_size_v<Tuple>;
  230|  61.1k|               static_assert(N == 1, "Only one input is allowed for your function pointer");
  231|       |
  232|  61.1k|               using Params = glz::tuple_element_t<0, Tuple>;
  233|       |
  234|  61.1k|               impl::template register_param_function_endpoint<Func, Params>(full_key, func, *this);
  235|  61.1k|            }
  236|  61.1k|            else if constexpr (std::is_pointer_v<std::remove_cvref_t<Func>> &&
  237|  61.1k|                               (glaze_object_t<std::remove_pointer_t<std::remove_cvref_t<Func>>> ||
  238|  61.1k|                                reflectable<std::remove_pointer_t<std::remove_cvref_t<Func>>>)) {
  239|       |               // Handle pointer members explicitly for RPC traversal
  240|  61.1k|               if (func) { // Only traverse if pointer is valid
  241|  61.1k|                  on<root, std::remove_pointer_t<std::remove_cvref_t<Func>>, full_key>(*func);
  242|  61.1k|                  impl::template register_object_endpoint<std::remove_pointer_t<std::remove_cvref_t<Func>>>(
  243|  61.1k|                     full_key, *func, *this);
  244|  61.1k|               }
  245|       |               // else: skip registration for null pointers - no endpoints created
  246|  61.1k|            }
  247|  61.1k|            else if constexpr (glaze_object_t<std::remove_cvref_t<Func>> || reflectable<std::remove_cvref_t<Func>>) {
  248|  61.1k|               on<root, std::remove_cvref_t<Func>, full_key>(func);
  249|       |
  250|  61.1k|               impl::template register_object_endpoint<std::remove_cvref_t<Func>>(full_key, func, *this);
  251|  61.1k|            }
  252|  61.1k|            else if constexpr (not std::is_lvalue_reference_v<Func>) {
  253|       |               // For glz::custom, glz::manage, etc.
  254|  61.1k|               impl::template register_value_endpoint<std::remove_cvref_t<Func>>(full_key, func, *this);
  255|  61.1k|            }
  256|  61.1k|            else {
  257|  61.1k|               static_assert(std::is_lvalue_reference_v<Func>);
  258|       |
  259|  61.1k|               if constexpr (std::is_member_function_pointer_v<std::decay_t<Func>>) {
  260|  61.1k|                  using F = std::decay_t<Func>;
  261|  61.1k|                  using Ret = typename return_type<F>::type;
  262|  61.1k|                  using Tuple = typename inputs_as_tuple<F>::type;
  263|  61.1k|                  constexpr auto n_args = glz::tuple_size_v<Tuple>;
  264|  61.1k|                  if constexpr (std::is_void_v<Ret>) {
  265|  61.1k|                     if constexpr (n_args == 0) {
  266|  61.1k|                        impl::template register_member_function_endpoint<T, F, void>(full_key, value, func, *this);
  267|  61.1k|                     }
  268|  61.1k|                     else if constexpr (n_args == 1) {
  269|  61.1k|                        using Input = std::decay_t<glz::tuple_element_t<0, Tuple>>;
  270|  61.1k|                        impl::template register_member_function_with_params_endpoint<T, F, Input, void>(full_key, value,
  271|  61.1k|                                                                                                        func, *this);
  272|  61.1k|                     }
  273|  61.1k|                     else {
  274|  61.1k|                        static_assert(false_v<Func>, "function cannot have more than one input");
  275|  61.1k|                     }
  276|  61.1k|                  }
  277|  61.1k|                  else {
  278|       |                     // Member function pointers
  279|  61.1k|                     if constexpr (n_args == 0) {
  280|  61.1k|                        impl::template register_member_function_endpoint<T, F, Ret>(full_key, value, func, *this);
  281|  61.1k|                     }
  282|  61.1k|                     else if constexpr (n_args == 1) {
  283|  61.1k|                        using Input = std::decay_t<glz::tuple_element_t<0, Tuple>>;
  284|  61.1k|                        impl::template register_member_function_with_params_endpoint<T, F, Input, Ret>(full_key, value,
  285|  61.1k|                                                                                                       func, *this);
  286|  61.1k|                     }
  287|  61.1k|                     else {
  288|  61.1k|                        static_assert(false_v<Func>, "function cannot have more than one input");
  289|  61.1k|                     }
  290|  61.1k|                  }
  291|  61.1k|               }
  292|  61.1k|               else {
  293|       |                  // this is a variable and not a function, so we build RPC read/write calls
  294|       |                  // We can't remove const here, because const fields need to be able to be written
  295|  61.1k|                  impl::template register_variable_endpoint<std::remove_reference_t<Func>>(full_key, func, *this);
  296|  61.1k|               }
  297|  61.1k|            }
  298|  61.1k|         });
  299|  61.1k|      }
jsonrpc_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz10member_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlvE_clEv:
  179|  61.1k|         [[maybe_unused]] decltype(auto) t = [&]() -> decltype(auto) {
  180|       |            if constexpr (reflectable<T> && requires { to_tie(value); }) {
  181|       |               return to_tie(value);
  182|       |            }
  183|  61.1k|            else {
  184|  61.1k|               return nullptr;
  185|  61.1k|            }
  186|  61.1k|         }();
jsonrpc_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz10member_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILi0EEEDav:
  190|  61.1k|         for_each<N>([&]<auto I>() {
  191|  61.1k|            decltype(auto) func = [&]() -> decltype(auto) {
  192|  61.1k|               if constexpr (reflectable<T>) {
  193|  61.1k|                  return get_member(value, get<I>(t));
  194|  61.1k|               }
  195|  61.1k|               else {
  196|  61.1k|                  return get_member(value, get<I>(reflect<T>::values));
  197|  61.1k|               }
  198|  61.1k|            }();
  199|       |
  200|  61.1k|            static constexpr auto key = reflect<T>::keys[I];
  201|       |
  202|  61.1k|            static constexpr std::string_view full_key = [&] {
  203|  61.1k|               if constexpr (parent == detail::empty_path) {
  204|  61.1k|                  return join_v<chars<"/">, key>;
  205|  61.1k|               }
  206|  61.1k|               else {
  207|  61.1k|                  return join_v<parent, chars<"/">, key>;
  208|  61.1k|               }
  209|  61.1k|            }();
  210|       |
  211|       |            // This logic chain should match glz::cli_menu
  212|  61.1k|            using Func = decltype(func);
  213|       |            if constexpr (std::is_invocable_v<Func>) {
  214|       |               using Result = std::decay_t<std::invoke_result_t<Func>>;
  215|       |               impl::template register_function_endpoint<Func, Result>(full_key, func, *this);
  216|       |            }
  217|       |            else if constexpr (is_invocable_concrete<std::remove_cvref_t<Func>>) {
  218|       |               using Tuple = invocable_args_t<std::remove_cvref_t<Func>>;
  219|       |               constexpr auto N = glz::tuple_size_v<Tuple>;
  220|       |               static_assert(N == 1, "Only one input is allowed for your function");
  221|       |
  222|       |               using Params = glz::tuple_element_t<0, Tuple>;
  223|       |
  224|       |               impl::template register_param_function_endpoint<Func, Params>(full_key, func, *this);
  225|       |            }
  226|       |            else if constexpr (is_function_ptr_invocable<std::remove_cvref_t<Func>>) {
  227|       |               // Handle function pointers with arguments (e.g., void(*)(int))
  228|       |               using Tuple = function_ptr_args_t<std::remove_cvref_t<Func>>;
  229|       |               constexpr auto N = glz::tuple_size_v<Tuple>;
  230|       |               static_assert(N == 1, "Only one input is allowed for your function pointer");
  231|       |
  232|       |               using Params = glz::tuple_element_t<0, Tuple>;
  233|       |
  234|       |               impl::template register_param_function_endpoint<Func, Params>(full_key, func, *this);
  235|       |            }
  236|       |            else if constexpr (std::is_pointer_v<std::remove_cvref_t<Func>> &&
  237|       |                               (glaze_object_t<std::remove_pointer_t<std::remove_cvref_t<Func>>> ||
  238|       |                                reflectable<std::remove_pointer_t<std::remove_cvref_t<Func>>>)) {
  239|       |               // Handle pointer members explicitly for RPC traversal
  240|       |               if (func) { // Only traverse if pointer is valid
  241|       |                  on<root, std::remove_pointer_t<std::remove_cvref_t<Func>>, full_key>(*func);
  242|       |                  impl::template register_object_endpoint<std::remove_pointer_t<std::remove_cvref_t<Func>>>(
  243|       |                     full_key, *func, *this);
  244|       |               }
  245|       |               // else: skip registration for null pointers - no endpoints created
  246|       |            }
  247|       |            else if constexpr (glaze_object_t<std::remove_cvref_t<Func>> || reflectable<std::remove_cvref_t<Func>>) {
  248|       |               on<root, std::remove_cvref_t<Func>, full_key>(func);
  249|       |
  250|       |               impl::template register_object_endpoint<std::remove_cvref_t<Func>>(full_key, func, *this);
  251|       |            }
  252|       |            else if constexpr (not std::is_lvalue_reference_v<Func>) {
  253|       |               // For glz::custom, glz::manage, etc.
  254|       |               impl::template register_value_endpoint<std::remove_cvref_t<Func>>(full_key, func, *this);
  255|       |            }
  256|  61.1k|            else {
  257|  61.1k|               static_assert(std::is_lvalue_reference_v<Func>);
  258|       |
  259|       |               if constexpr (std::is_member_function_pointer_v<std::decay_t<Func>>) {
  260|       |                  using F = std::decay_t<Func>;
  261|       |                  using Ret = typename return_type<F>::type;
  262|       |                  using Tuple = typename inputs_as_tuple<F>::type;
  263|       |                  constexpr auto n_args = glz::tuple_size_v<Tuple>;
  264|       |                  if constexpr (std::is_void_v<Ret>) {
  265|       |                     if constexpr (n_args == 0) {
  266|       |                        impl::template register_member_function_endpoint<T, F, void>(full_key, value, func, *this);
  267|       |                     }
  268|       |                     else if constexpr (n_args == 1) {
  269|       |                        using Input = std::decay_t<glz::tuple_element_t<0, Tuple>>;
  270|       |                        impl::template register_member_function_with_params_endpoint<T, F, Input, void>(full_key, value,
  271|       |                                                                                                        func, *this);
  272|       |                     }
  273|       |                     else {
  274|       |                        static_assert(false_v<Func>, "function cannot have more than one input");
  275|       |                     }
  276|       |                  }
  277|       |                  else {
  278|       |                     // Member function pointers
  279|       |                     if constexpr (n_args == 0) {
  280|       |                        impl::template register_member_function_endpoint<T, F, Ret>(full_key, value, func, *this);
  281|       |                     }
  282|       |                     else if constexpr (n_args == 1) {
  283|       |                        using Input = std::decay_t<glz::tuple_element_t<0, Tuple>>;
  284|       |                        impl::template register_member_function_with_params_endpoint<T, F, Input, Ret>(full_key, value,
  285|       |                                                                                                       func, *this);
  286|       |                     }
  287|       |                     else {
  288|       |                        static_assert(false_v<Func>, "function cannot have more than one input");
  289|       |                     }
  290|       |                  }
  291|       |               }
  292|  61.1k|               else {
  293|       |                  // this is a variable and not a function, so we build RPC read/write calls
  294|       |                  // We can't remove const here, because const fields need to be able to be written
  295|  61.1k|                  impl::template register_variable_endpoint<std::remove_reference_t<Func>>(full_key, func, *this);
  296|  61.1k|               }
  297|  61.1k|            }
  298|  61.1k|         });
jsonrpc_registry.cpp:_ZZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz10member_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILi0EEEDavENKUlvE_clEv:
  191|  61.1k|            decltype(auto) func = [&]() -> decltype(auto) {
  192|       |               if constexpr (reflectable<T>) {
  193|       |                  return get_member(value, get<I>(t));
  194|       |               }
  195|  61.1k|               else {
  196|  61.1k|                  return get_member(value, get<I>(reflect<T>::values));
  197|  61.1k|               }
  198|  61.1k|            }();
jsonrpc_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz10member_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILi1EEEDav:
  190|  61.1k|         for_each<N>([&]<auto I>() {
  191|  61.1k|            decltype(auto) func = [&]() -> decltype(auto) {
  192|  61.1k|               if constexpr (reflectable<T>) {
  193|  61.1k|                  return get_member(value, get<I>(t));
  194|  61.1k|               }
  195|  61.1k|               else {
  196|  61.1k|                  return get_member(value, get<I>(reflect<T>::values));
  197|  61.1k|               }
  198|  61.1k|            }();
  199|       |
  200|  61.1k|            static constexpr auto key = reflect<T>::keys[I];
  201|       |
  202|  61.1k|            static constexpr std::string_view full_key = [&] {
  203|  61.1k|               if constexpr (parent == detail::empty_path) {
  204|  61.1k|                  return join_v<chars<"/">, key>;
  205|  61.1k|               }
  206|  61.1k|               else {
  207|  61.1k|                  return join_v<parent, chars<"/">, key>;
  208|  61.1k|               }
  209|  61.1k|            }();
  210|       |
  211|       |            // This logic chain should match glz::cli_menu
  212|  61.1k|            using Func = decltype(func);
  213|       |            if constexpr (std::is_invocable_v<Func>) {
  214|       |               using Result = std::decay_t<std::invoke_result_t<Func>>;
  215|       |               impl::template register_function_endpoint<Func, Result>(full_key, func, *this);
  216|       |            }
  217|       |            else if constexpr (is_invocable_concrete<std::remove_cvref_t<Func>>) {
  218|       |               using Tuple = invocable_args_t<std::remove_cvref_t<Func>>;
  219|       |               constexpr auto N = glz::tuple_size_v<Tuple>;
  220|       |               static_assert(N == 1, "Only one input is allowed for your function");
  221|       |
  222|       |               using Params = glz::tuple_element_t<0, Tuple>;
  223|       |
  224|       |               impl::template register_param_function_endpoint<Func, Params>(full_key, func, *this);
  225|       |            }
  226|       |            else if constexpr (is_function_ptr_invocable<std::remove_cvref_t<Func>>) {
  227|       |               // Handle function pointers with arguments (e.g., void(*)(int))
  228|       |               using Tuple = function_ptr_args_t<std::remove_cvref_t<Func>>;
  229|       |               constexpr auto N = glz::tuple_size_v<Tuple>;
  230|       |               static_assert(N == 1, "Only one input is allowed for your function pointer");
  231|       |
  232|       |               using Params = glz::tuple_element_t<0, Tuple>;
  233|       |
  234|       |               impl::template register_param_function_endpoint<Func, Params>(full_key, func, *this);
  235|       |            }
  236|       |            else if constexpr (std::is_pointer_v<std::remove_cvref_t<Func>> &&
  237|       |                               (glaze_object_t<std::remove_pointer_t<std::remove_cvref_t<Func>>> ||
  238|       |                                reflectable<std::remove_pointer_t<std::remove_cvref_t<Func>>>)) {
  239|       |               // Handle pointer members explicitly for RPC traversal
  240|       |               if (func) { // Only traverse if pointer is valid
  241|       |                  on<root, std::remove_pointer_t<std::remove_cvref_t<Func>>, full_key>(*func);
  242|       |                  impl::template register_object_endpoint<std::remove_pointer_t<std::remove_cvref_t<Func>>>(
  243|       |                     full_key, *func, *this);
  244|       |               }
  245|       |               // else: skip registration for null pointers - no endpoints created
  246|       |            }
  247|       |            else if constexpr (glaze_object_t<std::remove_cvref_t<Func>> || reflectable<std::remove_cvref_t<Func>>) {
  248|       |               on<root, std::remove_cvref_t<Func>, full_key>(func);
  249|       |
  250|       |               impl::template register_object_endpoint<std::remove_cvref_t<Func>>(full_key, func, *this);
  251|       |            }
  252|       |            else if constexpr (not std::is_lvalue_reference_v<Func>) {
  253|       |               // For glz::custom, glz::manage, etc.
  254|       |               impl::template register_value_endpoint<std::remove_cvref_t<Func>>(full_key, func, *this);
  255|       |            }
  256|  61.1k|            else {
  257|  61.1k|               static_assert(std::is_lvalue_reference_v<Func>);
  258|       |
  259|  61.1k|               if constexpr (std::is_member_function_pointer_v<std::decay_t<Func>>) {
  260|  61.1k|                  using F = std::decay_t<Func>;
  261|  61.1k|                  using Ret = typename return_type<F>::type;
  262|  61.1k|                  using Tuple = typename inputs_as_tuple<F>::type;
  263|  61.1k|                  constexpr auto n_args = glz::tuple_size_v<Tuple>;
  264|       |                  if constexpr (std::is_void_v<Ret>) {
  265|       |                     if constexpr (n_args == 0) {
  266|       |                        impl::template register_member_function_endpoint<T, F, void>(full_key, value, func, *this);
  267|       |                     }
  268|       |                     else if constexpr (n_args == 1) {
  269|       |                        using Input = std::decay_t<glz::tuple_element_t<0, Tuple>>;
  270|       |                        impl::template register_member_function_with_params_endpoint<T, F, Input, void>(full_key, value,
  271|       |                                                                                                        func, *this);
  272|       |                     }
  273|       |                     else {
  274|       |                        static_assert(false_v<Func>, "function cannot have more than one input");
  275|       |                     }
  276|       |                  }
  277|  61.1k|                  else {
  278|       |                     // Member function pointers
  279|       |                     if constexpr (n_args == 0) {
  280|       |                        impl::template register_member_function_endpoint<T, F, Ret>(full_key, value, func, *this);
  281|       |                     }
  282|  61.1k|                     else if constexpr (n_args == 1) {
  283|  61.1k|                        using Input = std::decay_t<glz::tuple_element_t<0, Tuple>>;
  284|  61.1k|                        impl::template register_member_function_with_params_endpoint<T, F, Input, Ret>(full_key, value,
  285|  61.1k|                                                                                                       func, *this);
  286|       |                     }
  287|       |                     else {
  288|       |                        static_assert(false_v<Func>, "function cannot have more than one input");
  289|       |                     }
  290|  61.1k|                  }
  291|       |               }
  292|       |               else {
  293|       |                  // this is a variable and not a function, so we build RPC read/write calls
  294|       |                  // We can't remove const here, because const fields need to be able to be written
  295|       |                  impl::template register_variable_endpoint<std::remove_reference_t<Func>>(full_key, func, *this);
  296|       |               }
  297|  61.1k|            }
  298|  61.1k|         });
jsonrpc_registry.cpp:_ZZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz10member_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILi1EEEDavENKUlvE_clEv:
  191|  61.1k|            decltype(auto) func = [&]() -> decltype(auto) {
  192|       |               if constexpr (reflectable<T>) {
  193|       |                  return get_member(value, get<I>(t));
  194|       |               }
  195|  61.1k|               else {
  196|  61.1k|                  return get_member(value, get<I>(reflect<T>::values));
  197|  61.1k|               }
  198|  61.1k|            }();
jsonrpc_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz10member_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILi2EEEDav:
  190|  61.1k|         for_each<N>([&]<auto I>() {
  191|  61.1k|            decltype(auto) func = [&]() -> decltype(auto) {
  192|  61.1k|               if constexpr (reflectable<T>) {
  193|  61.1k|                  return get_member(value, get<I>(t));
  194|  61.1k|               }
  195|  61.1k|               else {
  196|  61.1k|                  return get_member(value, get<I>(reflect<T>::values));
  197|  61.1k|               }
  198|  61.1k|            }();
  199|       |
  200|  61.1k|            static constexpr auto key = reflect<T>::keys[I];
  201|       |
  202|  61.1k|            static constexpr std::string_view full_key = [&] {
  203|  61.1k|               if constexpr (parent == detail::empty_path) {
  204|  61.1k|                  return join_v<chars<"/">, key>;
  205|  61.1k|               }
  206|  61.1k|               else {
  207|  61.1k|                  return join_v<parent, chars<"/">, key>;
  208|  61.1k|               }
  209|  61.1k|            }();
  210|       |
  211|       |            // This logic chain should match glz::cli_menu
  212|  61.1k|            using Func = decltype(func);
  213|       |            if constexpr (std::is_invocable_v<Func>) {
  214|       |               using Result = std::decay_t<std::invoke_result_t<Func>>;
  215|       |               impl::template register_function_endpoint<Func, Result>(full_key, func, *this);
  216|       |            }
  217|       |            else if constexpr (is_invocable_concrete<std::remove_cvref_t<Func>>) {
  218|       |               using Tuple = invocable_args_t<std::remove_cvref_t<Func>>;
  219|       |               constexpr auto N = glz::tuple_size_v<Tuple>;
  220|       |               static_assert(N == 1, "Only one input is allowed for your function");
  221|       |
  222|       |               using Params = glz::tuple_element_t<0, Tuple>;
  223|       |
  224|       |               impl::template register_param_function_endpoint<Func, Params>(full_key, func, *this);
  225|       |            }
  226|       |            else if constexpr (is_function_ptr_invocable<std::remove_cvref_t<Func>>) {
  227|       |               // Handle function pointers with arguments (e.g., void(*)(int))
  228|       |               using Tuple = function_ptr_args_t<std::remove_cvref_t<Func>>;
  229|       |               constexpr auto N = glz::tuple_size_v<Tuple>;
  230|       |               static_assert(N == 1, "Only one input is allowed for your function pointer");
  231|       |
  232|       |               using Params = glz::tuple_element_t<0, Tuple>;
  233|       |
  234|       |               impl::template register_param_function_endpoint<Func, Params>(full_key, func, *this);
  235|       |            }
  236|       |            else if constexpr (std::is_pointer_v<std::remove_cvref_t<Func>> &&
  237|       |                               (glaze_object_t<std::remove_pointer_t<std::remove_cvref_t<Func>>> ||
  238|       |                                reflectable<std::remove_pointer_t<std::remove_cvref_t<Func>>>)) {
  239|       |               // Handle pointer members explicitly for RPC traversal
  240|       |               if (func) { // Only traverse if pointer is valid
  241|       |                  on<root, std::remove_pointer_t<std::remove_cvref_t<Func>>, full_key>(*func);
  242|       |                  impl::template register_object_endpoint<std::remove_pointer_t<std::remove_cvref_t<Func>>>(
  243|       |                     full_key, *func, *this);
  244|       |               }
  245|       |               // else: skip registration for null pointers - no endpoints created
  246|       |            }
  247|       |            else if constexpr (glaze_object_t<std::remove_cvref_t<Func>> || reflectable<std::remove_cvref_t<Func>>) {
  248|       |               on<root, std::remove_cvref_t<Func>, full_key>(func);
  249|       |
  250|       |               impl::template register_object_endpoint<std::remove_cvref_t<Func>>(full_key, func, *this);
  251|       |            }
  252|       |            else if constexpr (not std::is_lvalue_reference_v<Func>) {
  253|       |               // For glz::custom, glz::manage, etc.
  254|       |               impl::template register_value_endpoint<std::remove_cvref_t<Func>>(full_key, func, *this);
  255|       |            }
  256|  61.1k|            else {
  257|  61.1k|               static_assert(std::is_lvalue_reference_v<Func>);
  258|       |
  259|  61.1k|               if constexpr (std::is_member_function_pointer_v<std::decay_t<Func>>) {
  260|  61.1k|                  using F = std::decay_t<Func>;
  261|  61.1k|                  using Ret = typename return_type<F>::type;
  262|  61.1k|                  using Tuple = typename inputs_as_tuple<F>::type;
  263|  61.1k|                  constexpr auto n_args = glz::tuple_size_v<Tuple>;
  264|  61.1k|                  if constexpr (std::is_void_v<Ret>) {
  265|  61.1k|                     if constexpr (n_args == 0) {
  266|  61.1k|                        impl::template register_member_function_endpoint<T, F, void>(full_key, value, func, *this);
  267|       |                     }
  268|       |                     else if constexpr (n_args == 1) {
  269|       |                        using Input = std::decay_t<glz::tuple_element_t<0, Tuple>>;
  270|       |                        impl::template register_member_function_with_params_endpoint<T, F, Input, void>(full_key, value,
  271|       |                                                                                                        func, *this);
  272|       |                     }
  273|       |                     else {
  274|       |                        static_assert(false_v<Func>, "function cannot have more than one input");
  275|       |                     }
  276|       |                  }
  277|       |                  else {
  278|       |                     // Member function pointers
  279|       |                     if constexpr (n_args == 0) {
  280|       |                        impl::template register_member_function_endpoint<T, F, Ret>(full_key, value, func, *this);
  281|       |                     }
  282|       |                     else if constexpr (n_args == 1) {
  283|       |                        using Input = std::decay_t<glz::tuple_element_t<0, Tuple>>;
  284|       |                        impl::template register_member_function_with_params_endpoint<T, F, Input, Ret>(full_key, value,
  285|       |                                                                                                       func, *this);
  286|       |                     }
  287|       |                     else {
  288|       |                        static_assert(false_v<Func>, "function cannot have more than one input");
  289|       |                     }
  290|       |                  }
  291|       |               }
  292|       |               else {
  293|       |                  // this is a variable and not a function, so we build RPC read/write calls
  294|       |                  // We can't remove const here, because const fields need to be able to be written
  295|       |                  impl::template register_variable_endpoint<std::remove_reference_t<Func>>(full_key, func, *this);
  296|       |               }
  297|  61.1k|            }
  298|  61.1k|         });
jsonrpc_registry.cpp:_ZZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz10member_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILi2EEEDavENKUlvE_clEv:
  191|  61.1k|            decltype(auto) func = [&]() -> decltype(auto) {
  192|       |               if constexpr (reflectable<T>) {
  193|       |                  return get_member(value, get<I>(t));
  194|       |               }
  195|  61.1k|               else {
  196|  61.1k|                  return get_member(value, get<I>(reflect<T>::values));
  197|  61.1k|               }
  198|  61.1k|            }();
jsonrpc_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz10member_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILi3EEEDav:
  190|  61.1k|         for_each<N>([&]<auto I>() {
  191|  61.1k|            decltype(auto) func = [&]() -> decltype(auto) {
  192|  61.1k|               if constexpr (reflectable<T>) {
  193|  61.1k|                  return get_member(value, get<I>(t));
  194|  61.1k|               }
  195|  61.1k|               else {
  196|  61.1k|                  return get_member(value, get<I>(reflect<T>::values));
  197|  61.1k|               }
  198|  61.1k|            }();
  199|       |
  200|  61.1k|            static constexpr auto key = reflect<T>::keys[I];
  201|       |
  202|  61.1k|            static constexpr std::string_view full_key = [&] {
  203|  61.1k|               if constexpr (parent == detail::empty_path) {
  204|  61.1k|                  return join_v<chars<"/">, key>;
  205|  61.1k|               }
  206|  61.1k|               else {
  207|  61.1k|                  return join_v<parent, chars<"/">, key>;
  208|  61.1k|               }
  209|  61.1k|            }();
  210|       |
  211|       |            // This logic chain should match glz::cli_menu
  212|  61.1k|            using Func = decltype(func);
  213|       |            if constexpr (std::is_invocable_v<Func>) {
  214|       |               using Result = std::decay_t<std::invoke_result_t<Func>>;
  215|       |               impl::template register_function_endpoint<Func, Result>(full_key, func, *this);
  216|       |            }
  217|       |            else if constexpr (is_invocable_concrete<std::remove_cvref_t<Func>>) {
  218|       |               using Tuple = invocable_args_t<std::remove_cvref_t<Func>>;
  219|       |               constexpr auto N = glz::tuple_size_v<Tuple>;
  220|       |               static_assert(N == 1, "Only one input is allowed for your function");
  221|       |
  222|       |               using Params = glz::tuple_element_t<0, Tuple>;
  223|       |
  224|       |               impl::template register_param_function_endpoint<Func, Params>(full_key, func, *this);
  225|       |            }
  226|       |            else if constexpr (is_function_ptr_invocable<std::remove_cvref_t<Func>>) {
  227|       |               // Handle function pointers with arguments (e.g., void(*)(int))
  228|       |               using Tuple = function_ptr_args_t<std::remove_cvref_t<Func>>;
  229|       |               constexpr auto N = glz::tuple_size_v<Tuple>;
  230|       |               static_assert(N == 1, "Only one input is allowed for your function pointer");
  231|       |
  232|       |               using Params = glz::tuple_element_t<0, Tuple>;
  233|       |
  234|       |               impl::template register_param_function_endpoint<Func, Params>(full_key, func, *this);
  235|       |            }
  236|       |            else if constexpr (std::is_pointer_v<std::remove_cvref_t<Func>> &&
  237|       |                               (glaze_object_t<std::remove_pointer_t<std::remove_cvref_t<Func>>> ||
  238|       |                                reflectable<std::remove_pointer_t<std::remove_cvref_t<Func>>>)) {
  239|       |               // Handle pointer members explicitly for RPC traversal
  240|       |               if (func) { // Only traverse if pointer is valid
  241|       |                  on<root, std::remove_pointer_t<std::remove_cvref_t<Func>>, full_key>(*func);
  242|       |                  impl::template register_object_endpoint<std::remove_pointer_t<std::remove_cvref_t<Func>>>(
  243|       |                     full_key, *func, *this);
  244|       |               }
  245|       |               // else: skip registration for null pointers - no endpoints created
  246|       |            }
  247|       |            else if constexpr (glaze_object_t<std::remove_cvref_t<Func>> || reflectable<std::remove_cvref_t<Func>>) {
  248|       |               on<root, std::remove_cvref_t<Func>, full_key>(func);
  249|       |
  250|       |               impl::template register_object_endpoint<std::remove_cvref_t<Func>>(full_key, func, *this);
  251|       |            }
  252|       |            else if constexpr (not std::is_lvalue_reference_v<Func>) {
  253|       |               // For glz::custom, glz::manage, etc.
  254|       |               impl::template register_value_endpoint<std::remove_cvref_t<Func>>(full_key, func, *this);
  255|       |            }
  256|  61.1k|            else {
  257|  61.1k|               static_assert(std::is_lvalue_reference_v<Func>);
  258|       |
  259|  61.1k|               if constexpr (std::is_member_function_pointer_v<std::decay_t<Func>>) {
  260|  61.1k|                  using F = std::decay_t<Func>;
  261|  61.1k|                  using Ret = typename return_type<F>::type;
  262|  61.1k|                  using Tuple = typename inputs_as_tuple<F>::type;
  263|  61.1k|                  constexpr auto n_args = glz::tuple_size_v<Tuple>;
  264|       |                  if constexpr (std::is_void_v<Ret>) {
  265|       |                     if constexpr (n_args == 0) {
  266|       |                        impl::template register_member_function_endpoint<T, F, void>(full_key, value, func, *this);
  267|       |                     }
  268|       |                     else if constexpr (n_args == 1) {
  269|       |                        using Input = std::decay_t<glz::tuple_element_t<0, Tuple>>;
  270|       |                        impl::template register_member_function_with_params_endpoint<T, F, Input, void>(full_key, value,
  271|       |                                                                                                        func, *this);
  272|       |                     }
  273|       |                     else {
  274|       |                        static_assert(false_v<Func>, "function cannot have more than one input");
  275|       |                     }
  276|       |                  }
  277|  61.1k|                  else {
  278|       |                     // Member function pointers
  279|       |                     if constexpr (n_args == 0) {
  280|       |                        impl::template register_member_function_endpoint<T, F, Ret>(full_key, value, func, *this);
  281|       |                     }
  282|  61.1k|                     else if constexpr (n_args == 1) {
  283|  61.1k|                        using Input = std::decay_t<glz::tuple_element_t<0, Tuple>>;
  284|  61.1k|                        impl::template register_member_function_with_params_endpoint<T, F, Input, Ret>(full_key, value,
  285|  61.1k|                                                                                                       func, *this);
  286|       |                     }
  287|       |                     else {
  288|       |                        static_assert(false_v<Func>, "function cannot have more than one input");
  289|       |                     }
  290|  61.1k|                  }
  291|       |               }
  292|       |               else {
  293|       |                  // this is a variable and not a function, so we build RPC read/write calls
  294|       |                  // We can't remove const here, because const fields need to be able to be written
  295|       |                  impl::template register_variable_endpoint<std::remove_reference_t<Func>>(full_key, func, *this);
  296|       |               }
  297|  61.1k|            }
  298|  61.1k|         });
jsonrpc_registry.cpp:_ZZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz10member_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILi3EEEDavENKUlvE_clEv:
  191|  61.1k|            decltype(auto) func = [&]() -> decltype(auto) {
  192|       |               if constexpr (reflectable<T>) {
  193|       |                  return get_member(value, get<I>(t));
  194|       |               }
  195|  61.1k|               else {
  196|  61.1k|                  return get_member(value, get<I>(reflect<T>::values));
  197|  61.1k|               }
  198|  61.1k|            }();
jsonrpc_registry.cpp:_ZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE2onIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_:
  306|  61.1k|      {
  307|  61.1k|         using impl = registry_impl<read_opts, Proto>;
  308|       |
  309|  61.1k|         if constexpr (parent == root && (glaze_object_t<T> || reflectable<T>)) {
  310|  61.1k|            impl::register_endpoint(root, value, *this);
  311|  61.1k|         }
  312|       |
  313|  61.1k|         register_members<root, T, parent>(value);
  314|  61.1k|      }
jsonrpc_registry.cpp:_ZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_:
  175|  61.1k|      {
  176|  61.1k|         using namespace glz::detail;
  177|  61.1k|         static constexpr auto N = reflect<T>::size;
  178|       |
  179|  61.1k|         [[maybe_unused]] decltype(auto) t = [&]() -> decltype(auto) {
  180|  61.1k|            if constexpr (reflectable<T> && requires { to_tie(value); }) {
  181|  61.1k|               return to_tie(value);
  182|  61.1k|            }
  183|  61.1k|            else {
  184|  61.1k|               return nullptr;
  185|  61.1k|            }
  186|  61.1k|         }();
  187|       |
  188|  61.1k|         using impl = registry_impl<read_opts, Proto>;
  189|       |
  190|  61.1k|         for_each<N>([&]<auto I>() {
  191|  61.1k|            decltype(auto) func = [&]() -> decltype(auto) {
  192|  61.1k|               if constexpr (reflectable<T>) {
  193|  61.1k|                  return get_member(value, get<I>(t));
  194|  61.1k|               }
  195|  61.1k|               else {
  196|  61.1k|                  return get_member(value, get<I>(reflect<T>::values));
  197|  61.1k|               }
  198|  61.1k|            }();
  199|       |
  200|  61.1k|            static constexpr auto key = reflect<T>::keys[I];
  201|       |
  202|  61.1k|            static constexpr std::string_view full_key = [&] {
  203|  61.1k|               if constexpr (parent == detail::empty_path) {
  204|  61.1k|                  return join_v<chars<"/">, key>;
  205|  61.1k|               }
  206|  61.1k|               else {
  207|  61.1k|                  return join_v<parent, chars<"/">, key>;
  208|  61.1k|               }
  209|  61.1k|            }();
  210|       |
  211|       |            // This logic chain should match glz::cli_menu
  212|  61.1k|            using Func = decltype(func);
  213|  61.1k|            if constexpr (std::is_invocable_v<Func>) {
  214|  61.1k|               using Result = std::decay_t<std::invoke_result_t<Func>>;
  215|  61.1k|               impl::template register_function_endpoint<Func, Result>(full_key, func, *this);
  216|  61.1k|            }
  217|  61.1k|            else if constexpr (is_invocable_concrete<std::remove_cvref_t<Func>>) {
  218|  61.1k|               using Tuple = invocable_args_t<std::remove_cvref_t<Func>>;
  219|  61.1k|               constexpr auto N = glz::tuple_size_v<Tuple>;
  220|  61.1k|               static_assert(N == 1, "Only one input is allowed for your function");
  221|       |
  222|  61.1k|               using Params = glz::tuple_element_t<0, Tuple>;
  223|       |
  224|  61.1k|               impl::template register_param_function_endpoint<Func, Params>(full_key, func, *this);
  225|  61.1k|            }
  226|  61.1k|            else if constexpr (is_function_ptr_invocable<std::remove_cvref_t<Func>>) {
  227|       |               // Handle function pointers with arguments (e.g., void(*)(int))
  228|  61.1k|               using Tuple = function_ptr_args_t<std::remove_cvref_t<Func>>;
  229|  61.1k|               constexpr auto N = glz::tuple_size_v<Tuple>;
  230|  61.1k|               static_assert(N == 1, "Only one input is allowed for your function pointer");
  231|       |
  232|  61.1k|               using Params = glz::tuple_element_t<0, Tuple>;
  233|       |
  234|  61.1k|               impl::template register_param_function_endpoint<Func, Params>(full_key, func, *this);
  235|  61.1k|            }
  236|  61.1k|            else if constexpr (std::is_pointer_v<std::remove_cvref_t<Func>> &&
  237|  61.1k|                               (glaze_object_t<std::remove_pointer_t<std::remove_cvref_t<Func>>> ||
  238|  61.1k|                                reflectable<std::remove_pointer_t<std::remove_cvref_t<Func>>>)) {
  239|       |               // Handle pointer members explicitly for RPC traversal
  240|  61.1k|               if (func) { // Only traverse if pointer is valid
  241|  61.1k|                  on<root, std::remove_pointer_t<std::remove_cvref_t<Func>>, full_key>(*func);
  242|  61.1k|                  impl::template register_object_endpoint<std::remove_pointer_t<std::remove_cvref_t<Func>>>(
  243|  61.1k|                     full_key, *func, *this);
  244|  61.1k|               }
  245|       |               // else: skip registration for null pointers - no endpoints created
  246|  61.1k|            }
  247|  61.1k|            else if constexpr (glaze_object_t<std::remove_cvref_t<Func>> || reflectable<std::remove_cvref_t<Func>>) {
  248|  61.1k|               on<root, std::remove_cvref_t<Func>, full_key>(func);
  249|       |
  250|  61.1k|               impl::template register_object_endpoint<std::remove_cvref_t<Func>>(full_key, func, *this);
  251|  61.1k|            }
  252|  61.1k|            else if constexpr (not std::is_lvalue_reference_v<Func>) {
  253|       |               // For glz::custom, glz::manage, etc.
  254|  61.1k|               impl::template register_value_endpoint<std::remove_cvref_t<Func>>(full_key, func, *this);
  255|  61.1k|            }
  256|  61.1k|            else {
  257|  61.1k|               static_assert(std::is_lvalue_reference_v<Func>);
  258|       |
  259|  61.1k|               if constexpr (std::is_member_function_pointer_v<std::decay_t<Func>>) {
  260|  61.1k|                  using F = std::decay_t<Func>;
  261|  61.1k|                  using Ret = typename return_type<F>::type;
  262|  61.1k|                  using Tuple = typename inputs_as_tuple<F>::type;
  263|  61.1k|                  constexpr auto n_args = glz::tuple_size_v<Tuple>;
  264|  61.1k|                  if constexpr (std::is_void_v<Ret>) {
  265|  61.1k|                     if constexpr (n_args == 0) {
  266|  61.1k|                        impl::template register_member_function_endpoint<T, F, void>(full_key, value, func, *this);
  267|  61.1k|                     }
  268|  61.1k|                     else if constexpr (n_args == 1) {
  269|  61.1k|                        using Input = std::decay_t<glz::tuple_element_t<0, Tuple>>;
  270|  61.1k|                        impl::template register_member_function_with_params_endpoint<T, F, Input, void>(full_key, value,
  271|  61.1k|                                                                                                        func, *this);
  272|  61.1k|                     }
  273|  61.1k|                     else {
  274|  61.1k|                        static_assert(false_v<Func>, "function cannot have more than one input");
  275|  61.1k|                     }
  276|  61.1k|                  }
  277|  61.1k|                  else {
  278|       |                     // Member function pointers
  279|  61.1k|                     if constexpr (n_args == 0) {
  280|  61.1k|                        impl::template register_member_function_endpoint<T, F, Ret>(full_key, value, func, *this);
  281|  61.1k|                     }
  282|  61.1k|                     else if constexpr (n_args == 1) {
  283|  61.1k|                        using Input = std::decay_t<glz::tuple_element_t<0, Tuple>>;
  284|  61.1k|                        impl::template register_member_function_with_params_endpoint<T, F, Input, Ret>(full_key, value,
  285|  61.1k|                                                                                                       func, *this);
  286|  61.1k|                     }
  287|  61.1k|                     else {
  288|  61.1k|                        static_assert(false_v<Func>, "function cannot have more than one input");
  289|  61.1k|                     }
  290|  61.1k|                  }
  291|  61.1k|               }
  292|  61.1k|               else {
  293|       |                  // this is a variable and not a function, so we build RPC read/write calls
  294|       |                  // We can't remove const here, because const fields need to be able to be written
  295|  61.1k|                  impl::template register_variable_endpoint<std::remove_reference_t<Func>>(full_key, func, *this);
  296|  61.1k|               }
  297|  61.1k|            }
  298|  61.1k|         });
  299|  61.1k|      }
jsonrpc_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlvE_clEv:
  179|  61.1k|         [[maybe_unused]] decltype(auto) t = [&]() -> decltype(auto) {
  180|  61.1k|            if constexpr (reflectable<T> && requires { to_tie(value); }) {
  181|  61.1k|               return to_tie(value);
  182|       |            }
  183|       |            else {
  184|       |               return nullptr;
  185|       |            }
  186|  61.1k|         }();
jsonrpc_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm0EEEDav:
  190|  61.1k|         for_each<N>([&]<auto I>() {
  191|  61.1k|            decltype(auto) func = [&]() -> decltype(auto) {
  192|  61.1k|               if constexpr (reflectable<T>) {
  193|  61.1k|                  return get_member(value, get<I>(t));
  194|  61.1k|               }
  195|  61.1k|               else {
  196|  61.1k|                  return get_member(value, get<I>(reflect<T>::values));
  197|  61.1k|               }
  198|  61.1k|            }();
  199|       |
  200|  61.1k|            static constexpr auto key = reflect<T>::keys[I];
  201|       |
  202|  61.1k|            static constexpr std::string_view full_key = [&] {
  203|  61.1k|               if constexpr (parent == detail::empty_path) {
  204|  61.1k|                  return join_v<chars<"/">, key>;
  205|  61.1k|               }
  206|  61.1k|               else {
  207|  61.1k|                  return join_v<parent, chars<"/">, key>;
  208|  61.1k|               }
  209|  61.1k|            }();
  210|       |
  211|       |            // This logic chain should match glz::cli_menu
  212|  61.1k|            using Func = decltype(func);
  213|       |            if constexpr (std::is_invocable_v<Func>) {
  214|       |               using Result = std::decay_t<std::invoke_result_t<Func>>;
  215|       |               impl::template register_function_endpoint<Func, Result>(full_key, func, *this);
  216|       |            }
  217|       |            else if constexpr (is_invocable_concrete<std::remove_cvref_t<Func>>) {
  218|       |               using Tuple = invocable_args_t<std::remove_cvref_t<Func>>;
  219|       |               constexpr auto N = glz::tuple_size_v<Tuple>;
  220|       |               static_assert(N == 1, "Only one input is allowed for your function");
  221|       |
  222|       |               using Params = glz::tuple_element_t<0, Tuple>;
  223|       |
  224|       |               impl::template register_param_function_endpoint<Func, Params>(full_key, func, *this);
  225|       |            }
  226|       |            else if constexpr (is_function_ptr_invocable<std::remove_cvref_t<Func>>) {
  227|       |               // Handle function pointers with arguments (e.g., void(*)(int))
  228|       |               using Tuple = function_ptr_args_t<std::remove_cvref_t<Func>>;
  229|       |               constexpr auto N = glz::tuple_size_v<Tuple>;
  230|       |               static_assert(N == 1, "Only one input is allowed for your function pointer");
  231|       |
  232|       |               using Params = glz::tuple_element_t<0, Tuple>;
  233|       |
  234|       |               impl::template register_param_function_endpoint<Func, Params>(full_key, func, *this);
  235|       |            }
  236|       |            else if constexpr (std::is_pointer_v<std::remove_cvref_t<Func>> &&
  237|       |                               (glaze_object_t<std::remove_pointer_t<std::remove_cvref_t<Func>>> ||
  238|       |                                reflectable<std::remove_pointer_t<std::remove_cvref_t<Func>>>)) {
  239|       |               // Handle pointer members explicitly for RPC traversal
  240|       |               if (func) { // Only traverse if pointer is valid
  241|       |                  on<root, std::remove_pointer_t<std::remove_cvref_t<Func>>, full_key>(*func);
  242|       |                  impl::template register_object_endpoint<std::remove_pointer_t<std::remove_cvref_t<Func>>>(
  243|       |                     full_key, *func, *this);
  244|       |               }
  245|       |               // else: skip registration for null pointers - no endpoints created
  246|       |            }
  247|       |            else if constexpr (glaze_object_t<std::remove_cvref_t<Func>> || reflectable<std::remove_cvref_t<Func>>) {
  248|       |               on<root, std::remove_cvref_t<Func>, full_key>(func);
  249|       |
  250|       |               impl::template register_object_endpoint<std::remove_cvref_t<Func>>(full_key, func, *this);
  251|       |            }
  252|       |            else if constexpr (not std::is_lvalue_reference_v<Func>) {
  253|       |               // For glz::custom, glz::manage, etc.
  254|       |               impl::template register_value_endpoint<std::remove_cvref_t<Func>>(full_key, func, *this);
  255|       |            }
  256|  61.1k|            else {
  257|  61.1k|               static_assert(std::is_lvalue_reference_v<Func>);
  258|       |
  259|       |               if constexpr (std::is_member_function_pointer_v<std::decay_t<Func>>) {
  260|       |                  using F = std::decay_t<Func>;
  261|       |                  using Ret = typename return_type<F>::type;
  262|       |                  using Tuple = typename inputs_as_tuple<F>::type;
  263|       |                  constexpr auto n_args = glz::tuple_size_v<Tuple>;
  264|       |                  if constexpr (std::is_void_v<Ret>) {
  265|       |                     if constexpr (n_args == 0) {
  266|       |                        impl::template register_member_function_endpoint<T, F, void>(full_key, value, func, *this);
  267|       |                     }
  268|       |                     else if constexpr (n_args == 1) {
  269|       |                        using Input = std::decay_t<glz::tuple_element_t<0, Tuple>>;
  270|       |                        impl::template register_member_function_with_params_endpoint<T, F, Input, void>(full_key, value,
  271|       |                                                                                                        func, *this);
  272|       |                     }
  273|       |                     else {
  274|       |                        static_assert(false_v<Func>, "function cannot have more than one input");
  275|       |                     }
  276|       |                  }
  277|       |                  else {
  278|       |                     // Member function pointers
  279|       |                     if constexpr (n_args == 0) {
  280|       |                        impl::template register_member_function_endpoint<T, F, Ret>(full_key, value, func, *this);
  281|       |                     }
  282|       |                     else if constexpr (n_args == 1) {
  283|       |                        using Input = std::decay_t<glz::tuple_element_t<0, Tuple>>;
  284|       |                        impl::template register_member_function_with_params_endpoint<T, F, Input, Ret>(full_key, value,
  285|       |                                                                                                       func, *this);
  286|       |                     }
  287|       |                     else {
  288|       |                        static_assert(false_v<Func>, "function cannot have more than one input");
  289|       |                     }
  290|       |                  }
  291|       |               }
  292|  61.1k|               else {
  293|       |                  // this is a variable and not a function, so we build RPC read/write calls
  294|       |                  // We can't remove const here, because const fields need to be able to be written
  295|  61.1k|                  impl::template register_variable_endpoint<std::remove_reference_t<Func>>(full_key, func, *this);
  296|  61.1k|               }
  297|  61.1k|            }
  298|  61.1k|         });
jsonrpc_registry.cpp:_ZZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm0EEEDavENKUlvE_clEv:
  191|  61.1k|            decltype(auto) func = [&]() -> decltype(auto) {
  192|  61.1k|               if constexpr (reflectable<T>) {
  193|  61.1k|                  return get_member(value, get<I>(t));
  194|       |               }
  195|       |               else {
  196|       |                  return get_member(value, get<I>(reflect<T>::values));
  197|       |               }
  198|  61.1k|            }();
jsonrpc_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm1EEEDav:
  190|  61.1k|         for_each<N>([&]<auto I>() {
  191|  61.1k|            decltype(auto) func = [&]() -> decltype(auto) {
  192|  61.1k|               if constexpr (reflectable<T>) {
  193|  61.1k|                  return get_member(value, get<I>(t));
  194|  61.1k|               }
  195|  61.1k|               else {
  196|  61.1k|                  return get_member(value, get<I>(reflect<T>::values));
  197|  61.1k|               }
  198|  61.1k|            }();
  199|       |
  200|  61.1k|            static constexpr auto key = reflect<T>::keys[I];
  201|       |
  202|  61.1k|            static constexpr std::string_view full_key = [&] {
  203|  61.1k|               if constexpr (parent == detail::empty_path) {
  204|  61.1k|                  return join_v<chars<"/">, key>;
  205|  61.1k|               }
  206|  61.1k|               else {
  207|  61.1k|                  return join_v<parent, chars<"/">, key>;
  208|  61.1k|               }
  209|  61.1k|            }();
  210|       |
  211|       |            // This logic chain should match glz::cli_menu
  212|  61.1k|            using Func = decltype(func);
  213|       |            if constexpr (std::is_invocable_v<Func>) {
  214|       |               using Result = std::decay_t<std::invoke_result_t<Func>>;
  215|       |               impl::template register_function_endpoint<Func, Result>(full_key, func, *this);
  216|       |            }
  217|       |            else if constexpr (is_invocable_concrete<std::remove_cvref_t<Func>>) {
  218|       |               using Tuple = invocable_args_t<std::remove_cvref_t<Func>>;
  219|       |               constexpr auto N = glz::tuple_size_v<Tuple>;
  220|       |               static_assert(N == 1, "Only one input is allowed for your function");
  221|       |
  222|       |               using Params = glz::tuple_element_t<0, Tuple>;
  223|       |
  224|       |               impl::template register_param_function_endpoint<Func, Params>(full_key, func, *this);
  225|       |            }
  226|       |            else if constexpr (is_function_ptr_invocable<std::remove_cvref_t<Func>>) {
  227|       |               // Handle function pointers with arguments (e.g., void(*)(int))
  228|       |               using Tuple = function_ptr_args_t<std::remove_cvref_t<Func>>;
  229|       |               constexpr auto N = glz::tuple_size_v<Tuple>;
  230|       |               static_assert(N == 1, "Only one input is allowed for your function pointer");
  231|       |
  232|       |               using Params = glz::tuple_element_t<0, Tuple>;
  233|       |
  234|       |               impl::template register_param_function_endpoint<Func, Params>(full_key, func, *this);
  235|       |            }
  236|       |            else if constexpr (std::is_pointer_v<std::remove_cvref_t<Func>> &&
  237|       |                               (glaze_object_t<std::remove_pointer_t<std::remove_cvref_t<Func>>> ||
  238|       |                                reflectable<std::remove_pointer_t<std::remove_cvref_t<Func>>>)) {
  239|       |               // Handle pointer members explicitly for RPC traversal
  240|       |               if (func) { // Only traverse if pointer is valid
  241|       |                  on<root, std::remove_pointer_t<std::remove_cvref_t<Func>>, full_key>(*func);
  242|       |                  impl::template register_object_endpoint<std::remove_pointer_t<std::remove_cvref_t<Func>>>(
  243|       |                     full_key, *func, *this);
  244|       |               }
  245|       |               // else: skip registration for null pointers - no endpoints created
  246|       |            }
  247|       |            else if constexpr (glaze_object_t<std::remove_cvref_t<Func>> || reflectable<std::remove_cvref_t<Func>>) {
  248|       |               on<root, std::remove_cvref_t<Func>, full_key>(func);
  249|       |
  250|       |               impl::template register_object_endpoint<std::remove_cvref_t<Func>>(full_key, func, *this);
  251|       |            }
  252|       |            else if constexpr (not std::is_lvalue_reference_v<Func>) {
  253|       |               // For glz::custom, glz::manage, etc.
  254|       |               impl::template register_value_endpoint<std::remove_cvref_t<Func>>(full_key, func, *this);
  255|       |            }
  256|  61.1k|            else {
  257|  61.1k|               static_assert(std::is_lvalue_reference_v<Func>);
  258|       |
  259|       |               if constexpr (std::is_member_function_pointer_v<std::decay_t<Func>>) {
  260|       |                  using F = std::decay_t<Func>;
  261|       |                  using Ret = typename return_type<F>::type;
  262|       |                  using Tuple = typename inputs_as_tuple<F>::type;
  263|       |                  constexpr auto n_args = glz::tuple_size_v<Tuple>;
  264|       |                  if constexpr (std::is_void_v<Ret>) {
  265|       |                     if constexpr (n_args == 0) {
  266|       |                        impl::template register_member_function_endpoint<T, F, void>(full_key, value, func, *this);
  267|       |                     }
  268|       |                     else if constexpr (n_args == 1) {
  269|       |                        using Input = std::decay_t<glz::tuple_element_t<0, Tuple>>;
  270|       |                        impl::template register_member_function_with_params_endpoint<T, F, Input, void>(full_key, value,
  271|       |                                                                                                        func, *this);
  272|       |                     }
  273|       |                     else {
  274|       |                        static_assert(false_v<Func>, "function cannot have more than one input");
  275|       |                     }
  276|       |                  }
  277|       |                  else {
  278|       |                     // Member function pointers
  279|       |                     if constexpr (n_args == 0) {
  280|       |                        impl::template register_member_function_endpoint<T, F, Ret>(full_key, value, func, *this);
  281|       |                     }
  282|       |                     else if constexpr (n_args == 1) {
  283|       |                        using Input = std::decay_t<glz::tuple_element_t<0, Tuple>>;
  284|       |                        impl::template register_member_function_with_params_endpoint<T, F, Input, Ret>(full_key, value,
  285|       |                                                                                                       func, *this);
  286|       |                     }
  287|       |                     else {
  288|       |                        static_assert(false_v<Func>, "function cannot have more than one input");
  289|       |                     }
  290|       |                  }
  291|       |               }
  292|  61.1k|               else {
  293|       |                  // this is a variable and not a function, so we build RPC read/write calls
  294|       |                  // We can't remove const here, because const fields need to be able to be written
  295|  61.1k|                  impl::template register_variable_endpoint<std::remove_reference_t<Func>>(full_key, func, *this);
  296|  61.1k|               }
  297|  61.1k|            }
  298|  61.1k|         });
jsonrpc_registry.cpp:_ZZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm1EEEDavENKUlvE_clEv:
  191|  61.1k|            decltype(auto) func = [&]() -> decltype(auto) {
  192|  61.1k|               if constexpr (reflectable<T>) {
  193|  61.1k|                  return get_member(value, get<I>(t));
  194|       |               }
  195|       |               else {
  196|       |                  return get_member(value, get<I>(reflect<T>::values));
  197|       |               }
  198|  61.1k|            }();
jsonrpc_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm2EEEDav:
  190|  61.1k|         for_each<N>([&]<auto I>() {
  191|  61.1k|            decltype(auto) func = [&]() -> decltype(auto) {
  192|  61.1k|               if constexpr (reflectable<T>) {
  193|  61.1k|                  return get_member(value, get<I>(t));
  194|  61.1k|               }
  195|  61.1k|               else {
  196|  61.1k|                  return get_member(value, get<I>(reflect<T>::values));
  197|  61.1k|               }
  198|  61.1k|            }();
  199|       |
  200|  61.1k|            static constexpr auto key = reflect<T>::keys[I];
  201|       |
  202|  61.1k|            static constexpr std::string_view full_key = [&] {
  203|  61.1k|               if constexpr (parent == detail::empty_path) {
  204|  61.1k|                  return join_v<chars<"/">, key>;
  205|  61.1k|               }
  206|  61.1k|               else {
  207|  61.1k|                  return join_v<parent, chars<"/">, key>;
  208|  61.1k|               }
  209|  61.1k|            }();
  210|       |
  211|       |            // This logic chain should match glz::cli_menu
  212|  61.1k|            using Func = decltype(func);
  213|       |            if constexpr (std::is_invocable_v<Func>) {
  214|       |               using Result = std::decay_t<std::invoke_result_t<Func>>;
  215|       |               impl::template register_function_endpoint<Func, Result>(full_key, func, *this);
  216|       |            }
  217|       |            else if constexpr (is_invocable_concrete<std::remove_cvref_t<Func>>) {
  218|       |               using Tuple = invocable_args_t<std::remove_cvref_t<Func>>;
  219|       |               constexpr auto N = glz::tuple_size_v<Tuple>;
  220|       |               static_assert(N == 1, "Only one input is allowed for your function");
  221|       |
  222|       |               using Params = glz::tuple_element_t<0, Tuple>;
  223|       |
  224|       |               impl::template register_param_function_endpoint<Func, Params>(full_key, func, *this);
  225|       |            }
  226|       |            else if constexpr (is_function_ptr_invocable<std::remove_cvref_t<Func>>) {
  227|       |               // Handle function pointers with arguments (e.g., void(*)(int))
  228|       |               using Tuple = function_ptr_args_t<std::remove_cvref_t<Func>>;
  229|       |               constexpr auto N = glz::tuple_size_v<Tuple>;
  230|       |               static_assert(N == 1, "Only one input is allowed for your function pointer");
  231|       |
  232|       |               using Params = glz::tuple_element_t<0, Tuple>;
  233|       |
  234|       |               impl::template register_param_function_endpoint<Func, Params>(full_key, func, *this);
  235|       |            }
  236|       |            else if constexpr (std::is_pointer_v<std::remove_cvref_t<Func>> &&
  237|       |                               (glaze_object_t<std::remove_pointer_t<std::remove_cvref_t<Func>>> ||
  238|       |                                reflectable<std::remove_pointer_t<std::remove_cvref_t<Func>>>)) {
  239|       |               // Handle pointer members explicitly for RPC traversal
  240|       |               if (func) { // Only traverse if pointer is valid
  241|       |                  on<root, std::remove_pointer_t<std::remove_cvref_t<Func>>, full_key>(*func);
  242|       |                  impl::template register_object_endpoint<std::remove_pointer_t<std::remove_cvref_t<Func>>>(
  243|       |                     full_key, *func, *this);
  244|       |               }
  245|       |               // else: skip registration for null pointers - no endpoints created
  246|       |            }
  247|  61.1k|            else if constexpr (glaze_object_t<std::remove_cvref_t<Func>> || reflectable<std::remove_cvref_t<Func>>) {
  248|  61.1k|               on<root, std::remove_cvref_t<Func>, full_key>(func);
  249|       |
  250|  61.1k|               impl::template register_object_endpoint<std::remove_cvref_t<Func>>(full_key, func, *this);
  251|       |            }
  252|       |            else if constexpr (not std::is_lvalue_reference_v<Func>) {
  253|       |               // For glz::custom, glz::manage, etc.
  254|       |               impl::template register_value_endpoint<std::remove_cvref_t<Func>>(full_key, func, *this);
  255|       |            }
  256|       |            else {
  257|       |               static_assert(std::is_lvalue_reference_v<Func>);
  258|       |
  259|       |               if constexpr (std::is_member_function_pointer_v<std::decay_t<Func>>) {
  260|       |                  using F = std::decay_t<Func>;
  261|       |                  using Ret = typename return_type<F>::type;
  262|       |                  using Tuple = typename inputs_as_tuple<F>::type;
  263|       |                  constexpr auto n_args = glz::tuple_size_v<Tuple>;
  264|       |                  if constexpr (std::is_void_v<Ret>) {
  265|       |                     if constexpr (n_args == 0) {
  266|       |                        impl::template register_member_function_endpoint<T, F, void>(full_key, value, func, *this);
  267|       |                     }
  268|       |                     else if constexpr (n_args == 1) {
  269|       |                        using Input = std::decay_t<glz::tuple_element_t<0, Tuple>>;
  270|       |                        impl::template register_member_function_with_params_endpoint<T, F, Input, void>(full_key, value,
  271|       |                                                                                                        func, *this);
  272|       |                     }
  273|       |                     else {
  274|       |                        static_assert(false_v<Func>, "function cannot have more than one input");
  275|       |                     }
  276|       |                  }
  277|       |                  else {
  278|       |                     // Member function pointers
  279|       |                     if constexpr (n_args == 0) {
  280|       |                        impl::template register_member_function_endpoint<T, F, Ret>(full_key, value, func, *this);
  281|       |                     }
  282|       |                     else if constexpr (n_args == 1) {
  283|       |                        using Input = std::decay_t<glz::tuple_element_t<0, Tuple>>;
  284|       |                        impl::template register_member_function_with_params_endpoint<T, F, Input, Ret>(full_key, value,
  285|       |                                                                                                       func, *this);
  286|       |                     }
  287|       |                     else {
  288|       |                        static_assert(false_v<Func>, "function cannot have more than one input");
  289|       |                     }
  290|       |                  }
  291|       |               }
  292|       |               else {
  293|       |                  // this is a variable and not a function, so we build RPC read/write calls
  294|       |                  // We can't remove const here, because const fields need to be able to be written
  295|       |                  impl::template register_variable_endpoint<std::remove_reference_t<Func>>(full_key, func, *this);
  296|       |               }
  297|       |            }
  298|  61.1k|         });
jsonrpc_registry.cpp:_ZZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm2EEEDavENKUlvE_clEv:
  191|  61.1k|            decltype(auto) func = [&]() -> decltype(auto) {
  192|  61.1k|               if constexpr (reflectable<T>) {
  193|  61.1k|                  return get_member(value, get<I>(t));
  194|       |               }
  195|       |               else {
  196|       |                  return get_member(value, get<I>(reflect<T>::values));
  197|       |               }
  198|  61.1k|            }();
jsonrpc_registry.cpp:_ZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE2onIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz5pointEL_ZZZNS2_16register_membersIL_ZNS4_L10empty_pathEENS5_8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS9_EEEvRT0_ENKUlTnDavE_clILm2EEEDavE8full_keyEQoo14glaze_object_tIS9_E11reflectableIS9_EEEvSB_:
  306|  61.1k|      {
  307|  61.1k|         using impl = registry_impl<read_opts, Proto>;
  308|       |
  309|       |         if constexpr (parent == root && (glaze_object_t<T> || reflectable<T>)) {
  310|       |            impl::register_endpoint(root, value, *this);
  311|       |         }
  312|       |
  313|  61.1k|         register_members<root, T, parent>(value);
  314|  61.1k|      }
jsonrpc_registry.cpp:_ZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz5pointEL_ZZZNS3_IL_ZNS4_L10empty_pathEENS5_8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS8_EEEvRT0_ENKUlTnDavE_clILm2EEEDavE8full_keyEQoo14glaze_object_tIS8_E11reflectableIS8_EEEvSA_:
  175|  61.1k|      {
  176|  61.1k|         using namespace glz::detail;
  177|  61.1k|         static constexpr auto N = reflect<T>::size;
  178|       |
  179|  61.1k|         [[maybe_unused]] decltype(auto) t = [&]() -> decltype(auto) {
  180|  61.1k|            if constexpr (reflectable<T> && requires { to_tie(value); }) {
  181|  61.1k|               return to_tie(value);
  182|  61.1k|            }
  183|  61.1k|            else {
  184|  61.1k|               return nullptr;
  185|  61.1k|            }
  186|  61.1k|         }();
  187|       |
  188|  61.1k|         using impl = registry_impl<read_opts, Proto>;
  189|       |
  190|  61.1k|         for_each<N>([&]<auto I>() {
  191|  61.1k|            decltype(auto) func = [&]() -> decltype(auto) {
  192|  61.1k|               if constexpr (reflectable<T>) {
  193|  61.1k|                  return get_member(value, get<I>(t));
  194|  61.1k|               }
  195|  61.1k|               else {
  196|  61.1k|                  return get_member(value, get<I>(reflect<T>::values));
  197|  61.1k|               }
  198|  61.1k|            }();
  199|       |
  200|  61.1k|            static constexpr auto key = reflect<T>::keys[I];
  201|       |
  202|  61.1k|            static constexpr std::string_view full_key = [&] {
  203|  61.1k|               if constexpr (parent == detail::empty_path) {
  204|  61.1k|                  return join_v<chars<"/">, key>;
  205|  61.1k|               }
  206|  61.1k|               else {
  207|  61.1k|                  return join_v<parent, chars<"/">, key>;
  208|  61.1k|               }
  209|  61.1k|            }();
  210|       |
  211|       |            // This logic chain should match glz::cli_menu
  212|  61.1k|            using Func = decltype(func);
  213|  61.1k|            if constexpr (std::is_invocable_v<Func>) {
  214|  61.1k|               using Result = std::decay_t<std::invoke_result_t<Func>>;
  215|  61.1k|               impl::template register_function_endpoint<Func, Result>(full_key, func, *this);
  216|  61.1k|            }
  217|  61.1k|            else if constexpr (is_invocable_concrete<std::remove_cvref_t<Func>>) {
  218|  61.1k|               using Tuple = invocable_args_t<std::remove_cvref_t<Func>>;
  219|  61.1k|               constexpr auto N = glz::tuple_size_v<Tuple>;
  220|  61.1k|               static_assert(N == 1, "Only one input is allowed for your function");
  221|       |
  222|  61.1k|               using Params = glz::tuple_element_t<0, Tuple>;
  223|       |
  224|  61.1k|               impl::template register_param_function_endpoint<Func, Params>(full_key, func, *this);
  225|  61.1k|            }
  226|  61.1k|            else if constexpr (is_function_ptr_invocable<std::remove_cvref_t<Func>>) {
  227|       |               // Handle function pointers with arguments (e.g., void(*)(int))
  228|  61.1k|               using Tuple = function_ptr_args_t<std::remove_cvref_t<Func>>;
  229|  61.1k|               constexpr auto N = glz::tuple_size_v<Tuple>;
  230|  61.1k|               static_assert(N == 1, "Only one input is allowed for your function pointer");
  231|       |
  232|  61.1k|               using Params = glz::tuple_element_t<0, Tuple>;
  233|       |
  234|  61.1k|               impl::template register_param_function_endpoint<Func, Params>(full_key, func, *this);
  235|  61.1k|            }
  236|  61.1k|            else if constexpr (std::is_pointer_v<std::remove_cvref_t<Func>> &&
  237|  61.1k|                               (glaze_object_t<std::remove_pointer_t<std::remove_cvref_t<Func>>> ||
  238|  61.1k|                                reflectable<std::remove_pointer_t<std::remove_cvref_t<Func>>>)) {
  239|       |               // Handle pointer members explicitly for RPC traversal
  240|  61.1k|               if (func) { // Only traverse if pointer is valid
  241|  61.1k|                  on<root, std::remove_pointer_t<std::remove_cvref_t<Func>>, full_key>(*func);
  242|  61.1k|                  impl::template register_object_endpoint<std::remove_pointer_t<std::remove_cvref_t<Func>>>(
  243|  61.1k|                     full_key, *func, *this);
  244|  61.1k|               }
  245|       |               // else: skip registration for null pointers - no endpoints created
  246|  61.1k|            }
  247|  61.1k|            else if constexpr (glaze_object_t<std::remove_cvref_t<Func>> || reflectable<std::remove_cvref_t<Func>>) {
  248|  61.1k|               on<root, std::remove_cvref_t<Func>, full_key>(func);
  249|       |
  250|  61.1k|               impl::template register_object_endpoint<std::remove_cvref_t<Func>>(full_key, func, *this);
  251|  61.1k|            }
  252|  61.1k|            else if constexpr (not std::is_lvalue_reference_v<Func>) {
  253|       |               // For glz::custom, glz::manage, etc.
  254|  61.1k|               impl::template register_value_endpoint<std::remove_cvref_t<Func>>(full_key, func, *this);
  255|  61.1k|            }
  256|  61.1k|            else {
  257|  61.1k|               static_assert(std::is_lvalue_reference_v<Func>);
  258|       |
  259|  61.1k|               if constexpr (std::is_member_function_pointer_v<std::decay_t<Func>>) {
  260|  61.1k|                  using F = std::decay_t<Func>;
  261|  61.1k|                  using Ret = typename return_type<F>::type;
  262|  61.1k|                  using Tuple = typename inputs_as_tuple<F>::type;
  263|  61.1k|                  constexpr auto n_args = glz::tuple_size_v<Tuple>;
  264|  61.1k|                  if constexpr (std::is_void_v<Ret>) {
  265|  61.1k|                     if constexpr (n_args == 0) {
  266|  61.1k|                        impl::template register_member_function_endpoint<T, F, void>(full_key, value, func, *this);
  267|  61.1k|                     }
  268|  61.1k|                     else if constexpr (n_args == 1) {
  269|  61.1k|                        using Input = std::decay_t<glz::tuple_element_t<0, Tuple>>;
  270|  61.1k|                        impl::template register_member_function_with_params_endpoint<T, F, Input, void>(full_key, value,
  271|  61.1k|                                                                                                        func, *this);
  272|  61.1k|                     }
  273|  61.1k|                     else {
  274|  61.1k|                        static_assert(false_v<Func>, "function cannot have more than one input");
  275|  61.1k|                     }
  276|  61.1k|                  }
  277|  61.1k|                  else {
  278|       |                     // Member function pointers
  279|  61.1k|                     if constexpr (n_args == 0) {
  280|  61.1k|                        impl::template register_member_function_endpoint<T, F, Ret>(full_key, value, func, *this);
  281|  61.1k|                     }
  282|  61.1k|                     else if constexpr (n_args == 1) {
  283|  61.1k|                        using Input = std::decay_t<glz::tuple_element_t<0, Tuple>>;
  284|  61.1k|                        impl::template register_member_function_with_params_endpoint<T, F, Input, Ret>(full_key, value,
  285|  61.1k|                                                                                                       func, *this);
  286|  61.1k|                     }
  287|  61.1k|                     else {
  288|  61.1k|                        static_assert(false_v<Func>, "function cannot have more than one input");
  289|  61.1k|                     }
  290|  61.1k|                  }
  291|  61.1k|               }
  292|  61.1k|               else {
  293|       |                  // this is a variable and not a function, so we build RPC read/write calls
  294|       |                  // We can't remove const here, because const fields need to be able to be written
  295|  61.1k|                  impl::template register_variable_endpoint<std::remove_reference_t<Func>>(full_key, func, *this);
  296|  61.1k|               }
  297|  61.1k|            }
  298|  61.1k|         });
  299|  61.1k|      }
jsonrpc_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz5pointEL_ZZZNS3_IL_ZNS4_L10empty_pathEENS5_8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS8_EEEvRT0_ENKUlTnDavE_clILm2EEEDavE8full_keyEQoo14glaze_object_tIS8_E11reflectableIS8_EEEvSA_ENKUlvE_clEv:
  179|  61.1k|         [[maybe_unused]] decltype(auto) t = [&]() -> decltype(auto) {
  180|  61.1k|            if constexpr (reflectable<T> && requires { to_tie(value); }) {
  181|  61.1k|               return to_tie(value);
  182|       |            }
  183|       |            else {
  184|       |               return nullptr;
  185|       |            }
  186|  61.1k|         }();
jsonrpc_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz5pointEL_ZZZNS3_IL_ZNS4_L10empty_pathEENS5_8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS8_EEEvRT0_ENKUlTnDavE_clILm2EEEDavE8full_keyEQoo14glaze_object_tIS8_E11reflectableIS8_EEEvSA_ENKUlTnDavE_clILi0EEEDav:
  190|  61.1k|         for_each<N>([&]<auto I>() {
  191|  61.1k|            decltype(auto) func = [&]() -> decltype(auto) {
  192|  61.1k|               if constexpr (reflectable<T>) {
  193|  61.1k|                  return get_member(value, get<I>(t));
  194|  61.1k|               }
  195|  61.1k|               else {
  196|  61.1k|                  return get_member(value, get<I>(reflect<T>::values));
  197|  61.1k|               }
  198|  61.1k|            }();
  199|       |
  200|  61.1k|            static constexpr auto key = reflect<T>::keys[I];
  201|       |
  202|  61.1k|            static constexpr std::string_view full_key = [&] {
  203|  61.1k|               if constexpr (parent == detail::empty_path) {
  204|  61.1k|                  return join_v<chars<"/">, key>;
  205|  61.1k|               }
  206|  61.1k|               else {
  207|  61.1k|                  return join_v<parent, chars<"/">, key>;
  208|  61.1k|               }
  209|  61.1k|            }();
  210|       |
  211|       |            // This logic chain should match glz::cli_menu
  212|  61.1k|            using Func = decltype(func);
  213|       |            if constexpr (std::is_invocable_v<Func>) {
  214|       |               using Result = std::decay_t<std::invoke_result_t<Func>>;
  215|       |               impl::template register_function_endpoint<Func, Result>(full_key, func, *this);
  216|       |            }
  217|       |            else if constexpr (is_invocable_concrete<std::remove_cvref_t<Func>>) {
  218|       |               using Tuple = invocable_args_t<std::remove_cvref_t<Func>>;
  219|       |               constexpr auto N = glz::tuple_size_v<Tuple>;
  220|       |               static_assert(N == 1, "Only one input is allowed for your function");
  221|       |
  222|       |               using Params = glz::tuple_element_t<0, Tuple>;
  223|       |
  224|       |               impl::template register_param_function_endpoint<Func, Params>(full_key, func, *this);
  225|       |            }
  226|       |            else if constexpr (is_function_ptr_invocable<std::remove_cvref_t<Func>>) {
  227|       |               // Handle function pointers with arguments (e.g., void(*)(int))
  228|       |               using Tuple = function_ptr_args_t<std::remove_cvref_t<Func>>;
  229|       |               constexpr auto N = glz::tuple_size_v<Tuple>;
  230|       |               static_assert(N == 1, "Only one input is allowed for your function pointer");
  231|       |
  232|       |               using Params = glz::tuple_element_t<0, Tuple>;
  233|       |
  234|       |               impl::template register_param_function_endpoint<Func, Params>(full_key, func, *this);
  235|       |            }
  236|       |            else if constexpr (std::is_pointer_v<std::remove_cvref_t<Func>> &&
  237|       |                               (glaze_object_t<std::remove_pointer_t<std::remove_cvref_t<Func>>> ||
  238|       |                                reflectable<std::remove_pointer_t<std::remove_cvref_t<Func>>>)) {
  239|       |               // Handle pointer members explicitly for RPC traversal
  240|       |               if (func) { // Only traverse if pointer is valid
  241|       |                  on<root, std::remove_pointer_t<std::remove_cvref_t<Func>>, full_key>(*func);
  242|       |                  impl::template register_object_endpoint<std::remove_pointer_t<std::remove_cvref_t<Func>>>(
  243|       |                     full_key, *func, *this);
  244|       |               }
  245|       |               // else: skip registration for null pointers - no endpoints created
  246|       |            }
  247|       |            else if constexpr (glaze_object_t<std::remove_cvref_t<Func>> || reflectable<std::remove_cvref_t<Func>>) {
  248|       |               on<root, std::remove_cvref_t<Func>, full_key>(func);
  249|       |
  250|       |               impl::template register_object_endpoint<std::remove_cvref_t<Func>>(full_key, func, *this);
  251|       |            }
  252|       |            else if constexpr (not std::is_lvalue_reference_v<Func>) {
  253|       |               // For glz::custom, glz::manage, etc.
  254|       |               impl::template register_value_endpoint<std::remove_cvref_t<Func>>(full_key, func, *this);
  255|       |            }
  256|  61.1k|            else {
  257|  61.1k|               static_assert(std::is_lvalue_reference_v<Func>);
  258|       |
  259|       |               if constexpr (std::is_member_function_pointer_v<std::decay_t<Func>>) {
  260|       |                  using F = std::decay_t<Func>;
  261|       |                  using Ret = typename return_type<F>::type;
  262|       |                  using Tuple = typename inputs_as_tuple<F>::type;
  263|       |                  constexpr auto n_args = glz::tuple_size_v<Tuple>;
  264|       |                  if constexpr (std::is_void_v<Ret>) {
  265|       |                     if constexpr (n_args == 0) {
  266|       |                        impl::template register_member_function_endpoint<T, F, void>(full_key, value, func, *this);
  267|       |                     }
  268|       |                     else if constexpr (n_args == 1) {
  269|       |                        using Input = std::decay_t<glz::tuple_element_t<0, Tuple>>;
  270|       |                        impl::template register_member_function_with_params_endpoint<T, F, Input, void>(full_key, value,
  271|       |                                                                                                        func, *this);
  272|       |                     }
  273|       |                     else {
  274|       |                        static_assert(false_v<Func>, "function cannot have more than one input");
  275|       |                     }
  276|       |                  }
  277|       |                  else {
  278|       |                     // Member function pointers
  279|       |                     if constexpr (n_args == 0) {
  280|       |                        impl::template register_member_function_endpoint<T, F, Ret>(full_key, value, func, *this);
  281|       |                     }
  282|       |                     else if constexpr (n_args == 1) {
  283|       |                        using Input = std::decay_t<glz::tuple_element_t<0, Tuple>>;
  284|       |                        impl::template register_member_function_with_params_endpoint<T, F, Input, Ret>(full_key, value,
  285|       |                                                                                                       func, *this);
  286|       |                     }
  287|       |                     else {
  288|       |                        static_assert(false_v<Func>, "function cannot have more than one input");
  289|       |                     }
  290|       |                  }
  291|       |               }
  292|  61.1k|               else {
  293|       |                  // this is a variable and not a function, so we build RPC read/write calls
  294|       |                  // We can't remove const here, because const fields need to be able to be written
  295|  61.1k|                  impl::template register_variable_endpoint<std::remove_reference_t<Func>>(full_key, func, *this);
  296|  61.1k|               }
  297|  61.1k|            }
  298|  61.1k|         });
jsonrpc_registry.cpp:_ZZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz5pointEL_ZZZNS3_IL_ZNS4_L10empty_pathEENS5_8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS8_EEEvRT0_ENKUlTnDavE_clILm2EEEDavE8full_keyEQoo14glaze_object_tIS8_E11reflectableIS8_EEEvSA_ENKUlTnDavE_clILi0EEEDavENKUlvE_clEv:
  191|  61.1k|            decltype(auto) func = [&]() -> decltype(auto) {
  192|  61.1k|               if constexpr (reflectable<T>) {
  193|  61.1k|                  return get_member(value, get<I>(t));
  194|       |               }
  195|       |               else {
  196|       |                  return get_member(value, get<I>(reflect<T>::values));
  197|       |               }
  198|  61.1k|            }();
jsonrpc_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz5pointEL_ZZZNS3_IL_ZNS4_L10empty_pathEENS5_8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS8_EEEvRT0_ENKUlTnDavE_clILm2EEEDavE8full_keyEQoo14glaze_object_tIS8_E11reflectableIS8_EEEvSA_ENKUlTnDavE_clILi1EEEDav:
  190|  61.1k|         for_each<N>([&]<auto I>() {
  191|  61.1k|            decltype(auto) func = [&]() -> decltype(auto) {
  192|  61.1k|               if constexpr (reflectable<T>) {
  193|  61.1k|                  return get_member(value, get<I>(t));
  194|  61.1k|               }
  195|  61.1k|               else {
  196|  61.1k|                  return get_member(value, get<I>(reflect<T>::values));
  197|  61.1k|               }
  198|  61.1k|            }();
  199|       |
  200|  61.1k|            static constexpr auto key = reflect<T>::keys[I];
  201|       |
  202|  61.1k|            static constexpr std::string_view full_key = [&] {
  203|  61.1k|               if constexpr (parent == detail::empty_path) {
  204|  61.1k|                  return join_v<chars<"/">, key>;
  205|  61.1k|               }
  206|  61.1k|               else {
  207|  61.1k|                  return join_v<parent, chars<"/">, key>;
  208|  61.1k|               }
  209|  61.1k|            }();
  210|       |
  211|       |            // This logic chain should match glz::cli_menu
  212|  61.1k|            using Func = decltype(func);
  213|       |            if constexpr (std::is_invocable_v<Func>) {
  214|       |               using Result = std::decay_t<std::invoke_result_t<Func>>;
  215|       |               impl::template register_function_endpoint<Func, Result>(full_key, func, *this);
  216|       |            }
  217|       |            else if constexpr (is_invocable_concrete<std::remove_cvref_t<Func>>) {
  218|       |               using Tuple = invocable_args_t<std::remove_cvref_t<Func>>;
  219|       |               constexpr auto N = glz::tuple_size_v<Tuple>;
  220|       |               static_assert(N == 1, "Only one input is allowed for your function");
  221|       |
  222|       |               using Params = glz::tuple_element_t<0, Tuple>;
  223|       |
  224|       |               impl::template register_param_function_endpoint<Func, Params>(full_key, func, *this);
  225|       |            }
  226|       |            else if constexpr (is_function_ptr_invocable<std::remove_cvref_t<Func>>) {
  227|       |               // Handle function pointers with arguments (e.g., void(*)(int))
  228|       |               using Tuple = function_ptr_args_t<std::remove_cvref_t<Func>>;
  229|       |               constexpr auto N = glz::tuple_size_v<Tuple>;
  230|       |               static_assert(N == 1, "Only one input is allowed for your function pointer");
  231|       |
  232|       |               using Params = glz::tuple_element_t<0, Tuple>;
  233|       |
  234|       |               impl::template register_param_function_endpoint<Func, Params>(full_key, func, *this);
  235|       |            }
  236|       |            else if constexpr (std::is_pointer_v<std::remove_cvref_t<Func>> &&
  237|       |                               (glaze_object_t<std::remove_pointer_t<std::remove_cvref_t<Func>>> ||
  238|       |                                reflectable<std::remove_pointer_t<std::remove_cvref_t<Func>>>)) {
  239|       |               // Handle pointer members explicitly for RPC traversal
  240|       |               if (func) { // Only traverse if pointer is valid
  241|       |                  on<root, std::remove_pointer_t<std::remove_cvref_t<Func>>, full_key>(*func);
  242|       |                  impl::template register_object_endpoint<std::remove_pointer_t<std::remove_cvref_t<Func>>>(
  243|       |                     full_key, *func, *this);
  244|       |               }
  245|       |               // else: skip registration for null pointers - no endpoints created
  246|       |            }
  247|       |            else if constexpr (glaze_object_t<std::remove_cvref_t<Func>> || reflectable<std::remove_cvref_t<Func>>) {
  248|       |               on<root, std::remove_cvref_t<Func>, full_key>(func);
  249|       |
  250|       |               impl::template register_object_endpoint<std::remove_cvref_t<Func>>(full_key, func, *this);
  251|       |            }
  252|       |            else if constexpr (not std::is_lvalue_reference_v<Func>) {
  253|       |               // For glz::custom, glz::manage, etc.
  254|       |               impl::template register_value_endpoint<std::remove_cvref_t<Func>>(full_key, func, *this);
  255|       |            }
  256|  61.1k|            else {
  257|  61.1k|               static_assert(std::is_lvalue_reference_v<Func>);
  258|       |
  259|       |               if constexpr (std::is_member_function_pointer_v<std::decay_t<Func>>) {
  260|       |                  using F = std::decay_t<Func>;
  261|       |                  using Ret = typename return_type<F>::type;
  262|       |                  using Tuple = typename inputs_as_tuple<F>::type;
  263|       |                  constexpr auto n_args = glz::tuple_size_v<Tuple>;
  264|       |                  if constexpr (std::is_void_v<Ret>) {
  265|       |                     if constexpr (n_args == 0) {
  266|       |                        impl::template register_member_function_endpoint<T, F, void>(full_key, value, func, *this);
  267|       |                     }
  268|       |                     else if constexpr (n_args == 1) {
  269|       |                        using Input = std::decay_t<glz::tuple_element_t<0, Tuple>>;
  270|       |                        impl::template register_member_function_with_params_endpoint<T, F, Input, void>(full_key, value,
  271|       |                                                                                                        func, *this);
  272|       |                     }
  273|       |                     else {
  274|       |                        static_assert(false_v<Func>, "function cannot have more than one input");
  275|       |                     }
  276|       |                  }
  277|       |                  else {
  278|       |                     // Member function pointers
  279|       |                     if constexpr (n_args == 0) {
  280|       |                        impl::template register_member_function_endpoint<T, F, Ret>(full_key, value, func, *this);
  281|       |                     }
  282|       |                     else if constexpr (n_args == 1) {
  283|       |                        using Input = std::decay_t<glz::tuple_element_t<0, Tuple>>;
  284|       |                        impl::template register_member_function_with_params_endpoint<T, F, Input, Ret>(full_key, value,
  285|       |                                                                                                       func, *this);
  286|       |                     }
  287|       |                     else {
  288|       |                        static_assert(false_v<Func>, "function cannot have more than one input");
  289|       |                     }
  290|       |                  }
  291|       |               }
  292|  61.1k|               else {
  293|       |                  // this is a variable and not a function, so we build RPC read/write calls
  294|       |                  // We can't remove const here, because const fields need to be able to be written
  295|  61.1k|                  impl::template register_variable_endpoint<std::remove_reference_t<Func>>(full_key, func, *this);
  296|  61.1k|               }
  297|  61.1k|            }
  298|  61.1k|         });
jsonrpc_registry.cpp:_ZZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz5pointEL_ZZZNS3_IL_ZNS4_L10empty_pathEENS5_8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS8_EEEvRT0_ENKUlTnDavE_clILm2EEEDavE8full_keyEQoo14glaze_object_tIS8_E11reflectableIS8_EEEvSA_ENKUlTnDavE_clILi1EEEDavENKUlvE_clEv:
  191|  61.1k|            decltype(auto) func = [&]() -> decltype(auto) {
  192|  61.1k|               if constexpr (reflectable<T>) {
  193|  61.1k|                  return get_member(value, get<I>(t));
  194|       |               }
  195|       |               else {
  196|       |                  return get_member(value, get<I>(reflect<T>::values));
  197|       |               }
  198|  61.1k|            }();
jsonrpc_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm3EEEDav:
  190|  61.1k|         for_each<N>([&]<auto I>() {
  191|  61.1k|            decltype(auto) func = [&]() -> decltype(auto) {
  192|  61.1k|               if constexpr (reflectable<T>) {
  193|  61.1k|                  return get_member(value, get<I>(t));
  194|  61.1k|               }
  195|  61.1k|               else {
  196|  61.1k|                  return get_member(value, get<I>(reflect<T>::values));
  197|  61.1k|               }
  198|  61.1k|            }();
  199|       |
  200|  61.1k|            static constexpr auto key = reflect<T>::keys[I];
  201|       |
  202|  61.1k|            static constexpr std::string_view full_key = [&] {
  203|  61.1k|               if constexpr (parent == detail::empty_path) {
  204|  61.1k|                  return join_v<chars<"/">, key>;
  205|  61.1k|               }
  206|  61.1k|               else {
  207|  61.1k|                  return join_v<parent, chars<"/">, key>;
  208|  61.1k|               }
  209|  61.1k|            }();
  210|       |
  211|       |            // This logic chain should match glz::cli_menu
  212|  61.1k|            using Func = decltype(func);
  213|       |            if constexpr (std::is_invocable_v<Func>) {
  214|       |               using Result = std::decay_t<std::invoke_result_t<Func>>;
  215|       |               impl::template register_function_endpoint<Func, Result>(full_key, func, *this);
  216|       |            }
  217|       |            else if constexpr (is_invocable_concrete<std::remove_cvref_t<Func>>) {
  218|       |               using Tuple = invocable_args_t<std::remove_cvref_t<Func>>;
  219|       |               constexpr auto N = glz::tuple_size_v<Tuple>;
  220|       |               static_assert(N == 1, "Only one input is allowed for your function");
  221|       |
  222|       |               using Params = glz::tuple_element_t<0, Tuple>;
  223|       |
  224|       |               impl::template register_param_function_endpoint<Func, Params>(full_key, func, *this);
  225|       |            }
  226|       |            else if constexpr (is_function_ptr_invocable<std::remove_cvref_t<Func>>) {
  227|       |               // Handle function pointers with arguments (e.g., void(*)(int))
  228|       |               using Tuple = function_ptr_args_t<std::remove_cvref_t<Func>>;
  229|       |               constexpr auto N = glz::tuple_size_v<Tuple>;
  230|       |               static_assert(N == 1, "Only one input is allowed for your function pointer");
  231|       |
  232|       |               using Params = glz::tuple_element_t<0, Tuple>;
  233|       |
  234|       |               impl::template register_param_function_endpoint<Func, Params>(full_key, func, *this);
  235|       |            }
  236|       |            else if constexpr (std::is_pointer_v<std::remove_cvref_t<Func>> &&
  237|       |                               (glaze_object_t<std::remove_pointer_t<std::remove_cvref_t<Func>>> ||
  238|       |                                reflectable<std::remove_pointer_t<std::remove_cvref_t<Func>>>)) {
  239|       |               // Handle pointer members explicitly for RPC traversal
  240|       |               if (func) { // Only traverse if pointer is valid
  241|       |                  on<root, std::remove_pointer_t<std::remove_cvref_t<Func>>, full_key>(*func);
  242|       |                  impl::template register_object_endpoint<std::remove_pointer_t<std::remove_cvref_t<Func>>>(
  243|       |                     full_key, *func, *this);
  244|       |               }
  245|       |               // else: skip registration for null pointers - no endpoints created
  246|       |            }
  247|  61.1k|            else if constexpr (glaze_object_t<std::remove_cvref_t<Func>> || reflectable<std::remove_cvref_t<Func>>) {
  248|  61.1k|               on<root, std::remove_cvref_t<Func>, full_key>(func);
  249|       |
  250|  61.1k|               impl::template register_object_endpoint<std::remove_cvref_t<Func>>(full_key, func, *this);
  251|       |            }
  252|       |            else if constexpr (not std::is_lvalue_reference_v<Func>) {
  253|       |               // For glz::custom, glz::manage, etc.
  254|       |               impl::template register_value_endpoint<std::remove_cvref_t<Func>>(full_key, func, *this);
  255|       |            }
  256|       |            else {
  257|       |               static_assert(std::is_lvalue_reference_v<Func>);
  258|       |
  259|       |               if constexpr (std::is_member_function_pointer_v<std::decay_t<Func>>) {
  260|       |                  using F = std::decay_t<Func>;
  261|       |                  using Ret = typename return_type<F>::type;
  262|       |                  using Tuple = typename inputs_as_tuple<F>::type;
  263|       |                  constexpr auto n_args = glz::tuple_size_v<Tuple>;
  264|       |                  if constexpr (std::is_void_v<Ret>) {
  265|       |                     if constexpr (n_args == 0) {
  266|       |                        impl::template register_member_function_endpoint<T, F, void>(full_key, value, func, *this);
  267|       |                     }
  268|       |                     else if constexpr (n_args == 1) {
  269|       |                        using Input = std::decay_t<glz::tuple_element_t<0, Tuple>>;
  270|       |                        impl::template register_member_function_with_params_endpoint<T, F, Input, void>(full_key, value,
  271|       |                                                                                                        func, *this);
  272|       |                     }
  273|       |                     else {
  274|       |                        static_assert(false_v<Func>, "function cannot have more than one input");
  275|       |                     }
  276|       |                  }
  277|       |                  else {
  278|       |                     // Member function pointers
  279|       |                     if constexpr (n_args == 0) {
  280|       |                        impl::template register_member_function_endpoint<T, F, Ret>(full_key, value, func, *this);
  281|       |                     }
  282|       |                     else if constexpr (n_args == 1) {
  283|       |                        using Input = std::decay_t<glz::tuple_element_t<0, Tuple>>;
  284|       |                        impl::template register_member_function_with_params_endpoint<T, F, Input, Ret>(full_key, value,
  285|       |                                                                                                       func, *this);
  286|       |                     }
  287|       |                     else {
  288|       |                        static_assert(false_v<Func>, "function cannot have more than one input");
  289|       |                     }
  290|       |                  }
  291|       |               }
  292|       |               else {
  293|       |                  // this is a variable and not a function, so we build RPC read/write calls
  294|       |                  // We can't remove const here, because const fields need to be able to be written
  295|       |                  impl::template register_variable_endpoint<std::remove_reference_t<Func>>(full_key, func, *this);
  296|       |               }
  297|       |            }
  298|  61.1k|         });
jsonrpc_registry.cpp:_ZZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm3EEEDavENKUlvE_clEv:
  191|  61.1k|            decltype(auto) func = [&]() -> decltype(auto) {
  192|  61.1k|               if constexpr (reflectable<T>) {
  193|  61.1k|                  return get_member(value, get<I>(t));
  194|       |               }
  195|       |               else {
  196|       |                  return get_member(value, get<I>(reflect<T>::values));
  197|       |               }
  198|  61.1k|            }();
jsonrpc_registry.cpp:_ZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE2onIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz6nestedEL_ZZZNS2_16register_membersIL_ZNS4_L10empty_pathEENS5_8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS9_EEEvRT0_ENKUlTnDavE_clILm3EEEDavE8full_keyEQoo14glaze_object_tIS9_E11reflectableIS9_EEEvSB_:
  306|  61.1k|      {
  307|  61.1k|         using impl = registry_impl<read_opts, Proto>;
  308|       |
  309|       |         if constexpr (parent == root && (glaze_object_t<T> || reflectable<T>)) {
  310|       |            impl::register_endpoint(root, value, *this);
  311|       |         }
  312|       |
  313|  61.1k|         register_members<root, T, parent>(value);
  314|  61.1k|      }
jsonrpc_registry.cpp:_ZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz6nestedEL_ZZZNS3_IL_ZNS4_L10empty_pathEENS5_8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS8_EEEvRT0_ENKUlTnDavE_clILm3EEEDavE8full_keyEQoo14glaze_object_tIS8_E11reflectableIS8_EEEvSA_:
  175|  61.1k|      {
  176|  61.1k|         using namespace glz::detail;
  177|  61.1k|         static constexpr auto N = reflect<T>::size;
  178|       |
  179|  61.1k|         [[maybe_unused]] decltype(auto) t = [&]() -> decltype(auto) {
  180|  61.1k|            if constexpr (reflectable<T> && requires { to_tie(value); }) {
  181|  61.1k|               return to_tie(value);
  182|  61.1k|            }
  183|  61.1k|            else {
  184|  61.1k|               return nullptr;
  185|  61.1k|            }
  186|  61.1k|         }();
  187|       |
  188|  61.1k|         using impl = registry_impl<read_opts, Proto>;
  189|       |
  190|  61.1k|         for_each<N>([&]<auto I>() {
  191|  61.1k|            decltype(auto) func = [&]() -> decltype(auto) {
  192|  61.1k|               if constexpr (reflectable<T>) {
  193|  61.1k|                  return get_member(value, get<I>(t));
  194|  61.1k|               }
  195|  61.1k|               else {
  196|  61.1k|                  return get_member(value, get<I>(reflect<T>::values));
  197|  61.1k|               }
  198|  61.1k|            }();
  199|       |
  200|  61.1k|            static constexpr auto key = reflect<T>::keys[I];
  201|       |
  202|  61.1k|            static constexpr std::string_view full_key = [&] {
  203|  61.1k|               if constexpr (parent == detail::empty_path) {
  204|  61.1k|                  return join_v<chars<"/">, key>;
  205|  61.1k|               }
  206|  61.1k|               else {
  207|  61.1k|                  return join_v<parent, chars<"/">, key>;
  208|  61.1k|               }
  209|  61.1k|            }();
  210|       |
  211|       |            // This logic chain should match glz::cli_menu
  212|  61.1k|            using Func = decltype(func);
  213|  61.1k|            if constexpr (std::is_invocable_v<Func>) {
  214|  61.1k|               using Result = std::decay_t<std::invoke_result_t<Func>>;
  215|  61.1k|               impl::template register_function_endpoint<Func, Result>(full_key, func, *this);
  216|  61.1k|            }
  217|  61.1k|            else if constexpr (is_invocable_concrete<std::remove_cvref_t<Func>>) {
  218|  61.1k|               using Tuple = invocable_args_t<std::remove_cvref_t<Func>>;
  219|  61.1k|               constexpr auto N = glz::tuple_size_v<Tuple>;
  220|  61.1k|               static_assert(N == 1, "Only one input is allowed for your function");
  221|       |
  222|  61.1k|               using Params = glz::tuple_element_t<0, Tuple>;
  223|       |
  224|  61.1k|               impl::template register_param_function_endpoint<Func, Params>(full_key, func, *this);
  225|  61.1k|            }
  226|  61.1k|            else if constexpr (is_function_ptr_invocable<std::remove_cvref_t<Func>>) {
  227|       |               // Handle function pointers with arguments (e.g., void(*)(int))
  228|  61.1k|               using Tuple = function_ptr_args_t<std::remove_cvref_t<Func>>;
  229|  61.1k|               constexpr auto N = glz::tuple_size_v<Tuple>;
  230|  61.1k|               static_assert(N == 1, "Only one input is allowed for your function pointer");
  231|       |
  232|  61.1k|               using Params = glz::tuple_element_t<0, Tuple>;
  233|       |
  234|  61.1k|               impl::template register_param_function_endpoint<Func, Params>(full_key, func, *this);
  235|  61.1k|            }
  236|  61.1k|            else if constexpr (std::is_pointer_v<std::remove_cvref_t<Func>> &&
  237|  61.1k|                               (glaze_object_t<std::remove_pointer_t<std::remove_cvref_t<Func>>> ||
  238|  61.1k|                                reflectable<std::remove_pointer_t<std::remove_cvref_t<Func>>>)) {
  239|       |               // Handle pointer members explicitly for RPC traversal
  240|  61.1k|               if (func) { // Only traverse if pointer is valid
  241|  61.1k|                  on<root, std::remove_pointer_t<std::remove_cvref_t<Func>>, full_key>(*func);
  242|  61.1k|                  impl::template register_object_endpoint<std::remove_pointer_t<std::remove_cvref_t<Func>>>(
  243|  61.1k|                     full_key, *func, *this);
  244|  61.1k|               }
  245|       |               // else: skip registration for null pointers - no endpoints created
  246|  61.1k|            }
  247|  61.1k|            else if constexpr (glaze_object_t<std::remove_cvref_t<Func>> || reflectable<std::remove_cvref_t<Func>>) {
  248|  61.1k|               on<root, std::remove_cvref_t<Func>, full_key>(func);
  249|       |
  250|  61.1k|               impl::template register_object_endpoint<std::remove_cvref_t<Func>>(full_key, func, *this);
  251|  61.1k|            }
  252|  61.1k|            else if constexpr (not std::is_lvalue_reference_v<Func>) {
  253|       |               // For glz::custom, glz::manage, etc.
  254|  61.1k|               impl::template register_value_endpoint<std::remove_cvref_t<Func>>(full_key, func, *this);
  255|  61.1k|            }
  256|  61.1k|            else {
  257|  61.1k|               static_assert(std::is_lvalue_reference_v<Func>);
  258|       |
  259|  61.1k|               if constexpr (std::is_member_function_pointer_v<std::decay_t<Func>>) {
  260|  61.1k|                  using F = std::decay_t<Func>;
  261|  61.1k|                  using Ret = typename return_type<F>::type;
  262|  61.1k|                  using Tuple = typename inputs_as_tuple<F>::type;
  263|  61.1k|                  constexpr auto n_args = glz::tuple_size_v<Tuple>;
  264|  61.1k|                  if constexpr (std::is_void_v<Ret>) {
  265|  61.1k|                     if constexpr (n_args == 0) {
  266|  61.1k|                        impl::template register_member_function_endpoint<T, F, void>(full_key, value, func, *this);
  267|  61.1k|                     }
  268|  61.1k|                     else if constexpr (n_args == 1) {
  269|  61.1k|                        using Input = std::decay_t<glz::tuple_element_t<0, Tuple>>;
  270|  61.1k|                        impl::template register_member_function_with_params_endpoint<T, F, Input, void>(full_key, value,
  271|  61.1k|                                                                                                        func, *this);
  272|  61.1k|                     }
  273|  61.1k|                     else {
  274|  61.1k|                        static_assert(false_v<Func>, "function cannot have more than one input");
  275|  61.1k|                     }
  276|  61.1k|                  }
  277|  61.1k|                  else {
  278|       |                     // Member function pointers
  279|  61.1k|                     if constexpr (n_args == 0) {
  280|  61.1k|                        impl::template register_member_function_endpoint<T, F, Ret>(full_key, value, func, *this);
  281|  61.1k|                     }
  282|  61.1k|                     else if constexpr (n_args == 1) {
  283|  61.1k|                        using Input = std::decay_t<glz::tuple_element_t<0, Tuple>>;
  284|  61.1k|                        impl::template register_member_function_with_params_endpoint<T, F, Input, Ret>(full_key, value,
  285|  61.1k|                                                                                                       func, *this);
  286|  61.1k|                     }
  287|  61.1k|                     else {
  288|  61.1k|                        static_assert(false_v<Func>, "function cannot have more than one input");
  289|  61.1k|                     }
  290|  61.1k|                  }
  291|  61.1k|               }
  292|  61.1k|               else {
  293|       |                  // this is a variable and not a function, so we build RPC read/write calls
  294|       |                  // We can't remove const here, because const fields need to be able to be written
  295|  61.1k|                  impl::template register_variable_endpoint<std::remove_reference_t<Func>>(full_key, func, *this);
  296|  61.1k|               }
  297|  61.1k|            }
  298|  61.1k|         });
  299|  61.1k|      }
jsonrpc_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz6nestedEL_ZZZNS3_IL_ZNS4_L10empty_pathEENS5_8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS8_EEEvRT0_ENKUlTnDavE_clILm3EEEDavE8full_keyEQoo14glaze_object_tIS8_E11reflectableIS8_EEEvSA_ENKUlvE_clEv:
  179|  61.1k|         [[maybe_unused]] decltype(auto) t = [&]() -> decltype(auto) {
  180|  61.1k|            if constexpr (reflectable<T> && requires { to_tie(value); }) {
  181|  61.1k|               return to_tie(value);
  182|       |            }
  183|       |            else {
  184|       |               return nullptr;
  185|       |            }
  186|  61.1k|         }();
jsonrpc_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz6nestedEL_ZZZNS3_IL_ZNS4_L10empty_pathEENS5_8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS8_EEEvRT0_ENKUlTnDavE_clILm3EEEDavE8full_keyEQoo14glaze_object_tIS8_E11reflectableIS8_EEEvSA_ENKUlTnDavE_clILi0EEEDav:
  190|  61.1k|         for_each<N>([&]<auto I>() {
  191|  61.1k|            decltype(auto) func = [&]() -> decltype(auto) {
  192|  61.1k|               if constexpr (reflectable<T>) {
  193|  61.1k|                  return get_member(value, get<I>(t));
  194|  61.1k|               }
  195|  61.1k|               else {
  196|  61.1k|                  return get_member(value, get<I>(reflect<T>::values));
  197|  61.1k|               }
  198|  61.1k|            }();
  199|       |
  200|  61.1k|            static constexpr auto key = reflect<T>::keys[I];
  201|       |
  202|  61.1k|            static constexpr std::string_view full_key = [&] {
  203|  61.1k|               if constexpr (parent == detail::empty_path) {
  204|  61.1k|                  return join_v<chars<"/">, key>;
  205|  61.1k|               }
  206|  61.1k|               else {
  207|  61.1k|                  return join_v<parent, chars<"/">, key>;
  208|  61.1k|               }
  209|  61.1k|            }();
  210|       |
  211|       |            // This logic chain should match glz::cli_menu
  212|  61.1k|            using Func = decltype(func);
  213|       |            if constexpr (std::is_invocable_v<Func>) {
  214|       |               using Result = std::decay_t<std::invoke_result_t<Func>>;
  215|       |               impl::template register_function_endpoint<Func, Result>(full_key, func, *this);
  216|       |            }
  217|       |            else if constexpr (is_invocable_concrete<std::remove_cvref_t<Func>>) {
  218|       |               using Tuple = invocable_args_t<std::remove_cvref_t<Func>>;
  219|       |               constexpr auto N = glz::tuple_size_v<Tuple>;
  220|       |               static_assert(N == 1, "Only one input is allowed for your function");
  221|       |
  222|       |               using Params = glz::tuple_element_t<0, Tuple>;
  223|       |
  224|       |               impl::template register_param_function_endpoint<Func, Params>(full_key, func, *this);
  225|       |            }
  226|       |            else if constexpr (is_function_ptr_invocable<std::remove_cvref_t<Func>>) {
  227|       |               // Handle function pointers with arguments (e.g., void(*)(int))
  228|       |               using Tuple = function_ptr_args_t<std::remove_cvref_t<Func>>;
  229|       |               constexpr auto N = glz::tuple_size_v<Tuple>;
  230|       |               static_assert(N == 1, "Only one input is allowed for your function pointer");
  231|       |
  232|       |               using Params = glz::tuple_element_t<0, Tuple>;
  233|       |
  234|       |               impl::template register_param_function_endpoint<Func, Params>(full_key, func, *this);
  235|       |            }
  236|       |            else if constexpr (std::is_pointer_v<std::remove_cvref_t<Func>> &&
  237|       |                               (glaze_object_t<std::remove_pointer_t<std::remove_cvref_t<Func>>> ||
  238|       |                                reflectable<std::remove_pointer_t<std::remove_cvref_t<Func>>>)) {
  239|       |               // Handle pointer members explicitly for RPC traversal
  240|       |               if (func) { // Only traverse if pointer is valid
  241|       |                  on<root, std::remove_pointer_t<std::remove_cvref_t<Func>>, full_key>(*func);
  242|       |                  impl::template register_object_endpoint<std::remove_pointer_t<std::remove_cvref_t<Func>>>(
  243|       |                     full_key, *func, *this);
  244|       |               }
  245|       |               // else: skip registration for null pointers - no endpoints created
  246|       |            }
  247|       |            else if constexpr (glaze_object_t<std::remove_cvref_t<Func>> || reflectable<std::remove_cvref_t<Func>>) {
  248|       |               on<root, std::remove_cvref_t<Func>, full_key>(func);
  249|       |
  250|       |               impl::template register_object_endpoint<std::remove_cvref_t<Func>>(full_key, func, *this);
  251|       |            }
  252|       |            else if constexpr (not std::is_lvalue_reference_v<Func>) {
  253|       |               // For glz::custom, glz::manage, etc.
  254|       |               impl::template register_value_endpoint<std::remove_cvref_t<Func>>(full_key, func, *this);
  255|       |            }
  256|  61.1k|            else {
  257|  61.1k|               static_assert(std::is_lvalue_reference_v<Func>);
  258|       |
  259|       |               if constexpr (std::is_member_function_pointer_v<std::decay_t<Func>>) {
  260|       |                  using F = std::decay_t<Func>;
  261|       |                  using Ret = typename return_type<F>::type;
  262|       |                  using Tuple = typename inputs_as_tuple<F>::type;
  263|       |                  constexpr auto n_args = glz::tuple_size_v<Tuple>;
  264|       |                  if constexpr (std::is_void_v<Ret>) {
  265|       |                     if constexpr (n_args == 0) {
  266|       |                        impl::template register_member_function_endpoint<T, F, void>(full_key, value, func, *this);
  267|       |                     }
  268|       |                     else if constexpr (n_args == 1) {
  269|       |                        using Input = std::decay_t<glz::tuple_element_t<0, Tuple>>;
  270|       |                        impl::template register_member_function_with_params_endpoint<T, F, Input, void>(full_key, value,
  271|       |                                                                                                        func, *this);
  272|       |                     }
  273|       |                     else {
  274|       |                        static_assert(false_v<Func>, "function cannot have more than one input");
  275|       |                     }
  276|       |                  }
  277|       |                  else {
  278|       |                     // Member function pointers
  279|       |                     if constexpr (n_args == 0) {
  280|       |                        impl::template register_member_function_endpoint<T, F, Ret>(full_key, value, func, *this);
  281|       |                     }
  282|       |                     else if constexpr (n_args == 1) {
  283|       |                        using Input = std::decay_t<glz::tuple_element_t<0, Tuple>>;
  284|       |                        impl::template register_member_function_with_params_endpoint<T, F, Input, Ret>(full_key, value,
  285|       |                                                                                                       func, *this);
  286|       |                     }
  287|       |                     else {
  288|       |                        static_assert(false_v<Func>, "function cannot have more than one input");
  289|       |                     }
  290|       |                  }
  291|       |               }
  292|  61.1k|               else {
  293|       |                  // this is a variable and not a function, so we build RPC read/write calls
  294|       |                  // We can't remove const here, because const fields need to be able to be written
  295|  61.1k|                  impl::template register_variable_endpoint<std::remove_reference_t<Func>>(full_key, func, *this);
  296|  61.1k|               }
  297|  61.1k|            }
  298|  61.1k|         });
jsonrpc_registry.cpp:_ZZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz6nestedEL_ZZZNS3_IL_ZNS4_L10empty_pathEENS5_8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS8_EEEvRT0_ENKUlTnDavE_clILm3EEEDavE8full_keyEQoo14glaze_object_tIS8_E11reflectableIS8_EEEvSA_ENKUlTnDavE_clILi0EEEDavENKUlvE_clEv:
  191|  61.1k|            decltype(auto) func = [&]() -> decltype(auto) {
  192|  61.1k|               if constexpr (reflectable<T>) {
  193|  61.1k|                  return get_member(value, get<I>(t));
  194|       |               }
  195|       |               else {
  196|       |                  return get_member(value, get<I>(reflect<T>::values));
  197|       |               }
  198|  61.1k|            }();
jsonrpc_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz6nestedEL_ZZZNS3_IL_ZNS4_L10empty_pathEENS5_8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS8_EEEvRT0_ENKUlTnDavE_clILm3EEEDavE8full_keyEQoo14glaze_object_tIS8_E11reflectableIS8_EEEvSA_ENKUlTnDavE_clILi1EEEDav:
  190|  61.1k|         for_each<N>([&]<auto I>() {
  191|  61.1k|            decltype(auto) func = [&]() -> decltype(auto) {
  192|  61.1k|               if constexpr (reflectable<T>) {
  193|  61.1k|                  return get_member(value, get<I>(t));
  194|  61.1k|               }
  195|  61.1k|               else {
  196|  61.1k|                  return get_member(value, get<I>(reflect<T>::values));
  197|  61.1k|               }
  198|  61.1k|            }();
  199|       |
  200|  61.1k|            static constexpr auto key = reflect<T>::keys[I];
  201|       |
  202|  61.1k|            static constexpr std::string_view full_key = [&] {
  203|  61.1k|               if constexpr (parent == detail::empty_path) {
  204|  61.1k|                  return join_v<chars<"/">, key>;
  205|  61.1k|               }
  206|  61.1k|               else {
  207|  61.1k|                  return join_v<parent, chars<"/">, key>;
  208|  61.1k|               }
  209|  61.1k|            }();
  210|       |
  211|       |            // This logic chain should match glz::cli_menu
  212|  61.1k|            using Func = decltype(func);
  213|       |            if constexpr (std::is_invocable_v<Func>) {
  214|       |               using Result = std::decay_t<std::invoke_result_t<Func>>;
  215|       |               impl::template register_function_endpoint<Func, Result>(full_key, func, *this);
  216|       |            }
  217|       |            else if constexpr (is_invocable_concrete<std::remove_cvref_t<Func>>) {
  218|       |               using Tuple = invocable_args_t<std::remove_cvref_t<Func>>;
  219|       |               constexpr auto N = glz::tuple_size_v<Tuple>;
  220|       |               static_assert(N == 1, "Only one input is allowed for your function");
  221|       |
  222|       |               using Params = glz::tuple_element_t<0, Tuple>;
  223|       |
  224|       |               impl::template register_param_function_endpoint<Func, Params>(full_key, func, *this);
  225|       |            }
  226|       |            else if constexpr (is_function_ptr_invocable<std::remove_cvref_t<Func>>) {
  227|       |               // Handle function pointers with arguments (e.g., void(*)(int))
  228|       |               using Tuple = function_ptr_args_t<std::remove_cvref_t<Func>>;
  229|       |               constexpr auto N = glz::tuple_size_v<Tuple>;
  230|       |               static_assert(N == 1, "Only one input is allowed for your function pointer");
  231|       |
  232|       |               using Params = glz::tuple_element_t<0, Tuple>;
  233|       |
  234|       |               impl::template register_param_function_endpoint<Func, Params>(full_key, func, *this);
  235|       |            }
  236|       |            else if constexpr (std::is_pointer_v<std::remove_cvref_t<Func>> &&
  237|       |                               (glaze_object_t<std::remove_pointer_t<std::remove_cvref_t<Func>>> ||
  238|       |                                reflectable<std::remove_pointer_t<std::remove_cvref_t<Func>>>)) {
  239|       |               // Handle pointer members explicitly for RPC traversal
  240|       |               if (func) { // Only traverse if pointer is valid
  241|       |                  on<root, std::remove_pointer_t<std::remove_cvref_t<Func>>, full_key>(*func);
  242|       |                  impl::template register_object_endpoint<std::remove_pointer_t<std::remove_cvref_t<Func>>>(
  243|       |                     full_key, *func, *this);
  244|       |               }
  245|       |               // else: skip registration for null pointers - no endpoints created
  246|       |            }
  247|       |            else if constexpr (glaze_object_t<std::remove_cvref_t<Func>> || reflectable<std::remove_cvref_t<Func>>) {
  248|       |               on<root, std::remove_cvref_t<Func>, full_key>(func);
  249|       |
  250|       |               impl::template register_object_endpoint<std::remove_cvref_t<Func>>(full_key, func, *this);
  251|       |            }
  252|       |            else if constexpr (not std::is_lvalue_reference_v<Func>) {
  253|       |               // For glz::custom, glz::manage, etc.
  254|       |               impl::template register_value_endpoint<std::remove_cvref_t<Func>>(full_key, func, *this);
  255|       |            }
  256|  61.1k|            else {
  257|  61.1k|               static_assert(std::is_lvalue_reference_v<Func>);
  258|       |
  259|       |               if constexpr (std::is_member_function_pointer_v<std::decay_t<Func>>) {
  260|       |                  using F = std::decay_t<Func>;
  261|       |                  using Ret = typename return_type<F>::type;
  262|       |                  using Tuple = typename inputs_as_tuple<F>::type;
  263|       |                  constexpr auto n_args = glz::tuple_size_v<Tuple>;
  264|       |                  if constexpr (std::is_void_v<Ret>) {
  265|       |                     if constexpr (n_args == 0) {
  266|       |                        impl::template register_member_function_endpoint<T, F, void>(full_key, value, func, *this);
  267|       |                     }
  268|       |                     else if constexpr (n_args == 1) {
  269|       |                        using Input = std::decay_t<glz::tuple_element_t<0, Tuple>>;
  270|       |                        impl::template register_member_function_with_params_endpoint<T, F, Input, void>(full_key, value,
  271|       |                                                                                                        func, *this);
  272|       |                     }
  273|       |                     else {
  274|       |                        static_assert(false_v<Func>, "function cannot have more than one input");
  275|       |                     }
  276|       |                  }
  277|       |                  else {
  278|       |                     // Member function pointers
  279|       |                     if constexpr (n_args == 0) {
  280|       |                        impl::template register_member_function_endpoint<T, F, Ret>(full_key, value, func, *this);
  281|       |                     }
  282|       |                     else if constexpr (n_args == 1) {
  283|       |                        using Input = std::decay_t<glz::tuple_element_t<0, Tuple>>;
  284|       |                        impl::template register_member_function_with_params_endpoint<T, F, Input, Ret>(full_key, value,
  285|       |                                                                                                       func, *this);
  286|       |                     }
  287|       |                     else {
  288|       |                        static_assert(false_v<Func>, "function cannot have more than one input");
  289|       |                     }
  290|       |                  }
  291|       |               }
  292|  61.1k|               else {
  293|       |                  // this is a variable and not a function, so we build RPC read/write calls
  294|       |                  // We can't remove const here, because const fields need to be able to be written
  295|  61.1k|                  impl::template register_variable_endpoint<std::remove_reference_t<Func>>(full_key, func, *this);
  296|  61.1k|               }
  297|  61.1k|            }
  298|  61.1k|         });
jsonrpc_registry.cpp:_ZZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz6nestedEL_ZZZNS3_IL_ZNS4_L10empty_pathEENS5_8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS8_EEEvRT0_ENKUlTnDavE_clILm3EEEDavE8full_keyEQoo14glaze_object_tIS8_E11reflectableIS8_EEEvSA_ENKUlTnDavE_clILi1EEEDavENKUlvE_clEv:
  191|  61.1k|            decltype(auto) func = [&]() -> decltype(auto) {
  192|  61.1k|               if constexpr (reflectable<T>) {
  193|  61.1k|                  return get_member(value, get<I>(t));
  194|       |               }
  195|       |               else {
  196|       |                  return get_member(value, get<I>(reflect<T>::values));
  197|       |               }
  198|  61.1k|            }();
jsonrpc_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm4EEEDav:
  190|  61.1k|         for_each<N>([&]<auto I>() {
  191|  61.1k|            decltype(auto) func = [&]() -> decltype(auto) {
  192|  61.1k|               if constexpr (reflectable<T>) {
  193|  61.1k|                  return get_member(value, get<I>(t));
  194|  61.1k|               }
  195|  61.1k|               else {
  196|  61.1k|                  return get_member(value, get<I>(reflect<T>::values));
  197|  61.1k|               }
  198|  61.1k|            }();
  199|       |
  200|  61.1k|            static constexpr auto key = reflect<T>::keys[I];
  201|       |
  202|  61.1k|            static constexpr std::string_view full_key = [&] {
  203|  61.1k|               if constexpr (parent == detail::empty_path) {
  204|  61.1k|                  return join_v<chars<"/">, key>;
  205|  61.1k|               }
  206|  61.1k|               else {
  207|  61.1k|                  return join_v<parent, chars<"/">, key>;
  208|  61.1k|               }
  209|  61.1k|            }();
  210|       |
  211|       |            // This logic chain should match glz::cli_menu
  212|  61.1k|            using Func = decltype(func);
  213|       |            if constexpr (std::is_invocable_v<Func>) {
  214|       |               using Result = std::decay_t<std::invoke_result_t<Func>>;
  215|       |               impl::template register_function_endpoint<Func, Result>(full_key, func, *this);
  216|       |            }
  217|       |            else if constexpr (is_invocable_concrete<std::remove_cvref_t<Func>>) {
  218|       |               using Tuple = invocable_args_t<std::remove_cvref_t<Func>>;
  219|       |               constexpr auto N = glz::tuple_size_v<Tuple>;
  220|       |               static_assert(N == 1, "Only one input is allowed for your function");
  221|       |
  222|       |               using Params = glz::tuple_element_t<0, Tuple>;
  223|       |
  224|       |               impl::template register_param_function_endpoint<Func, Params>(full_key, func, *this);
  225|       |            }
  226|       |            else if constexpr (is_function_ptr_invocable<std::remove_cvref_t<Func>>) {
  227|       |               // Handle function pointers with arguments (e.g., void(*)(int))
  228|       |               using Tuple = function_ptr_args_t<std::remove_cvref_t<Func>>;
  229|       |               constexpr auto N = glz::tuple_size_v<Tuple>;
  230|       |               static_assert(N == 1, "Only one input is allowed for your function pointer");
  231|       |
  232|       |               using Params = glz::tuple_element_t<0, Tuple>;
  233|       |
  234|       |               impl::template register_param_function_endpoint<Func, Params>(full_key, func, *this);
  235|       |            }
  236|       |            else if constexpr (std::is_pointer_v<std::remove_cvref_t<Func>> &&
  237|       |                               (glaze_object_t<std::remove_pointer_t<std::remove_cvref_t<Func>>> ||
  238|       |                                reflectable<std::remove_pointer_t<std::remove_cvref_t<Func>>>)) {
  239|       |               // Handle pointer members explicitly for RPC traversal
  240|       |               if (func) { // Only traverse if pointer is valid
  241|       |                  on<root, std::remove_pointer_t<std::remove_cvref_t<Func>>, full_key>(*func);
  242|       |                  impl::template register_object_endpoint<std::remove_pointer_t<std::remove_cvref_t<Func>>>(
  243|       |                     full_key, *func, *this);
  244|       |               }
  245|       |               // else: skip registration for null pointers - no endpoints created
  246|       |            }
  247|       |            else if constexpr (glaze_object_t<std::remove_cvref_t<Func>> || reflectable<std::remove_cvref_t<Func>>) {
  248|       |               on<root, std::remove_cvref_t<Func>, full_key>(func);
  249|       |
  250|       |               impl::template register_object_endpoint<std::remove_cvref_t<Func>>(full_key, func, *this);
  251|       |            }
  252|       |            else if constexpr (not std::is_lvalue_reference_v<Func>) {
  253|       |               // For glz::custom, glz::manage, etc.
  254|       |               impl::template register_value_endpoint<std::remove_cvref_t<Func>>(full_key, func, *this);
  255|       |            }
  256|  61.1k|            else {
  257|  61.1k|               static_assert(std::is_lvalue_reference_v<Func>);
  258|       |
  259|       |               if constexpr (std::is_member_function_pointer_v<std::decay_t<Func>>) {
  260|       |                  using F = std::decay_t<Func>;
  261|       |                  using Ret = typename return_type<F>::type;
  262|       |                  using Tuple = typename inputs_as_tuple<F>::type;
  263|       |                  constexpr auto n_args = glz::tuple_size_v<Tuple>;
  264|       |                  if constexpr (std::is_void_v<Ret>) {
  265|       |                     if constexpr (n_args == 0) {
  266|       |                        impl::template register_member_function_endpoint<T, F, void>(full_key, value, func, *this);
  267|       |                     }
  268|       |                     else if constexpr (n_args == 1) {
  269|       |                        using Input = std::decay_t<glz::tuple_element_t<0, Tuple>>;
  270|       |                        impl::template register_member_function_with_params_endpoint<T, F, Input, void>(full_key, value,
  271|       |                                                                                                        func, *this);
  272|       |                     }
  273|       |                     else {
  274|       |                        static_assert(false_v<Func>, "function cannot have more than one input");
  275|       |                     }
  276|       |                  }
  277|       |                  else {
  278|       |                     // Member function pointers
  279|       |                     if constexpr (n_args == 0) {
  280|       |                        impl::template register_member_function_endpoint<T, F, Ret>(full_key, value, func, *this);
  281|       |                     }
  282|       |                     else if constexpr (n_args == 1) {
  283|       |                        using Input = std::decay_t<glz::tuple_element_t<0, Tuple>>;
  284|       |                        impl::template register_member_function_with_params_endpoint<T, F, Input, Ret>(full_key, value,
  285|       |                                                                                                       func, *this);
  286|       |                     }
  287|       |                     else {
  288|       |                        static_assert(false_v<Func>, "function cannot have more than one input");
  289|       |                     }
  290|       |                  }
  291|       |               }
  292|  61.1k|               else {
  293|       |                  // this is a variable and not a function, so we build RPC read/write calls
  294|       |                  // We can't remove const here, because const fields need to be able to be written
  295|  61.1k|                  impl::template register_variable_endpoint<std::remove_reference_t<Func>>(full_key, func, *this);
  296|  61.1k|               }
  297|  61.1k|            }
  298|  61.1k|         });
jsonrpc_registry.cpp:_ZZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm4EEEDavENKUlvE_clEv:
  191|  61.1k|            decltype(auto) func = [&]() -> decltype(auto) {
  192|  61.1k|               if constexpr (reflectable<T>) {
  193|  61.1k|                  return get_member(value, get<I>(t));
  194|       |               }
  195|       |               else {
  196|       |                  return get_member(value, get<I>(reflect<T>::values));
  197|       |               }
  198|  61.1k|            }();
jsonrpc_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm5EEEDav:
  190|  61.1k|         for_each<N>([&]<auto I>() {
  191|  61.1k|            decltype(auto) func = [&]() -> decltype(auto) {
  192|  61.1k|               if constexpr (reflectable<T>) {
  193|  61.1k|                  return get_member(value, get<I>(t));
  194|  61.1k|               }
  195|  61.1k|               else {
  196|  61.1k|                  return get_member(value, get<I>(reflect<T>::values));
  197|  61.1k|               }
  198|  61.1k|            }();
  199|       |
  200|  61.1k|            static constexpr auto key = reflect<T>::keys[I];
  201|       |
  202|  61.1k|            static constexpr std::string_view full_key = [&] {
  203|  61.1k|               if constexpr (parent == detail::empty_path) {
  204|  61.1k|                  return join_v<chars<"/">, key>;
  205|  61.1k|               }
  206|  61.1k|               else {
  207|  61.1k|                  return join_v<parent, chars<"/">, key>;
  208|  61.1k|               }
  209|  61.1k|            }();
  210|       |
  211|       |            // This logic chain should match glz::cli_menu
  212|  61.1k|            using Func = decltype(func);
  213|       |            if constexpr (std::is_invocable_v<Func>) {
  214|       |               using Result = std::decay_t<std::invoke_result_t<Func>>;
  215|       |               impl::template register_function_endpoint<Func, Result>(full_key, func, *this);
  216|       |            }
  217|       |            else if constexpr (is_invocable_concrete<std::remove_cvref_t<Func>>) {
  218|       |               using Tuple = invocable_args_t<std::remove_cvref_t<Func>>;
  219|       |               constexpr auto N = glz::tuple_size_v<Tuple>;
  220|       |               static_assert(N == 1, "Only one input is allowed for your function");
  221|       |
  222|       |               using Params = glz::tuple_element_t<0, Tuple>;
  223|       |
  224|       |               impl::template register_param_function_endpoint<Func, Params>(full_key, func, *this);
  225|       |            }
  226|       |            else if constexpr (is_function_ptr_invocable<std::remove_cvref_t<Func>>) {
  227|       |               // Handle function pointers with arguments (e.g., void(*)(int))
  228|       |               using Tuple = function_ptr_args_t<std::remove_cvref_t<Func>>;
  229|       |               constexpr auto N = glz::tuple_size_v<Tuple>;
  230|       |               static_assert(N == 1, "Only one input is allowed for your function pointer");
  231|       |
  232|       |               using Params = glz::tuple_element_t<0, Tuple>;
  233|       |
  234|       |               impl::template register_param_function_endpoint<Func, Params>(full_key, func, *this);
  235|       |            }
  236|       |            else if constexpr (std::is_pointer_v<std::remove_cvref_t<Func>> &&
  237|       |                               (glaze_object_t<std::remove_pointer_t<std::remove_cvref_t<Func>>> ||
  238|       |                                reflectable<std::remove_pointer_t<std::remove_cvref_t<Func>>>)) {
  239|       |               // Handle pointer members explicitly for RPC traversal
  240|       |               if (func) { // Only traverse if pointer is valid
  241|       |                  on<root, std::remove_pointer_t<std::remove_cvref_t<Func>>, full_key>(*func);
  242|       |                  impl::template register_object_endpoint<std::remove_pointer_t<std::remove_cvref_t<Func>>>(
  243|       |                     full_key, *func, *this);
  244|       |               }
  245|       |               // else: skip registration for null pointers - no endpoints created
  246|       |            }
  247|       |            else if constexpr (glaze_object_t<std::remove_cvref_t<Func>> || reflectable<std::remove_cvref_t<Func>>) {
  248|       |               on<root, std::remove_cvref_t<Func>, full_key>(func);
  249|       |
  250|       |               impl::template register_object_endpoint<std::remove_cvref_t<Func>>(full_key, func, *this);
  251|       |            }
  252|       |            else if constexpr (not std::is_lvalue_reference_v<Func>) {
  253|       |               // For glz::custom, glz::manage, etc.
  254|       |               impl::template register_value_endpoint<std::remove_cvref_t<Func>>(full_key, func, *this);
  255|       |            }
  256|  61.1k|            else {
  257|  61.1k|               static_assert(std::is_lvalue_reference_v<Func>);
  258|       |
  259|       |               if constexpr (std::is_member_function_pointer_v<std::decay_t<Func>>) {
  260|       |                  using F = std::decay_t<Func>;
  261|       |                  using Ret = typename return_type<F>::type;
  262|       |                  using Tuple = typename inputs_as_tuple<F>::type;
  263|       |                  constexpr auto n_args = glz::tuple_size_v<Tuple>;
  264|       |                  if constexpr (std::is_void_v<Ret>) {
  265|       |                     if constexpr (n_args == 0) {
  266|       |                        impl::template register_member_function_endpoint<T, F, void>(full_key, value, func, *this);
  267|       |                     }
  268|       |                     else if constexpr (n_args == 1) {
  269|       |                        using Input = std::decay_t<glz::tuple_element_t<0, Tuple>>;
  270|       |                        impl::template register_member_function_with_params_endpoint<T, F, Input, void>(full_key, value,
  271|       |                                                                                                        func, *this);
  272|       |                     }
  273|       |                     else {
  274|       |                        static_assert(false_v<Func>, "function cannot have more than one input");
  275|       |                     }
  276|       |                  }
  277|       |                  else {
  278|       |                     // Member function pointers
  279|       |                     if constexpr (n_args == 0) {
  280|       |                        impl::template register_member_function_endpoint<T, F, Ret>(full_key, value, func, *this);
  281|       |                     }
  282|       |                     else if constexpr (n_args == 1) {
  283|       |                        using Input = std::decay_t<glz::tuple_element_t<0, Tuple>>;
  284|       |                        impl::template register_member_function_with_params_endpoint<T, F, Input, Ret>(full_key, value,
  285|       |                                                                                                       func, *this);
  286|       |                     }
  287|       |                     else {
  288|       |                        static_assert(false_v<Func>, "function cannot have more than one input");
  289|       |                     }
  290|       |                  }
  291|       |               }
  292|  61.1k|               else {
  293|       |                  // this is a variable and not a function, so we build RPC read/write calls
  294|       |                  // We can't remove const here, because const fields need to be able to be written
  295|  61.1k|                  impl::template register_variable_endpoint<std::remove_reference_t<Func>>(full_key, func, *this);
  296|  61.1k|               }
  297|  61.1k|            }
  298|  61.1k|         });
jsonrpc_registry.cpp:_ZZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm5EEEDavENKUlvE_clEv:
  191|  61.1k|            decltype(auto) func = [&]() -> decltype(auto) {
  192|  61.1k|               if constexpr (reflectable<T>) {
  193|  61.1k|                  return get_member(value, get<I>(t));
  194|       |               }
  195|       |               else {
  196|       |                  return get_member(value, get<I>(reflect<T>::values));
  197|       |               }
  198|  61.1k|            }();
jsonrpc_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm6EEEDav:
  190|  61.1k|         for_each<N>([&]<auto I>() {
  191|  61.1k|            decltype(auto) func = [&]() -> decltype(auto) {
  192|  61.1k|               if constexpr (reflectable<T>) {
  193|  61.1k|                  return get_member(value, get<I>(t));
  194|  61.1k|               }
  195|  61.1k|               else {
  196|  61.1k|                  return get_member(value, get<I>(reflect<T>::values));
  197|  61.1k|               }
  198|  61.1k|            }();
  199|       |
  200|  61.1k|            static constexpr auto key = reflect<T>::keys[I];
  201|       |
  202|  61.1k|            static constexpr std::string_view full_key = [&] {
  203|  61.1k|               if constexpr (parent == detail::empty_path) {
  204|  61.1k|                  return join_v<chars<"/">, key>;
  205|  61.1k|               }
  206|  61.1k|               else {
  207|  61.1k|                  return join_v<parent, chars<"/">, key>;
  208|  61.1k|               }
  209|  61.1k|            }();
  210|       |
  211|       |            // This logic chain should match glz::cli_menu
  212|  61.1k|            using Func = decltype(func);
  213|       |            if constexpr (std::is_invocable_v<Func>) {
  214|       |               using Result = std::decay_t<std::invoke_result_t<Func>>;
  215|       |               impl::template register_function_endpoint<Func, Result>(full_key, func, *this);
  216|       |            }
  217|       |            else if constexpr (is_invocable_concrete<std::remove_cvref_t<Func>>) {
  218|       |               using Tuple = invocable_args_t<std::remove_cvref_t<Func>>;
  219|       |               constexpr auto N = glz::tuple_size_v<Tuple>;
  220|       |               static_assert(N == 1, "Only one input is allowed for your function");
  221|       |
  222|       |               using Params = glz::tuple_element_t<0, Tuple>;
  223|       |
  224|       |               impl::template register_param_function_endpoint<Func, Params>(full_key, func, *this);
  225|       |            }
  226|       |            else if constexpr (is_function_ptr_invocable<std::remove_cvref_t<Func>>) {
  227|       |               // Handle function pointers with arguments (e.g., void(*)(int))
  228|       |               using Tuple = function_ptr_args_t<std::remove_cvref_t<Func>>;
  229|       |               constexpr auto N = glz::tuple_size_v<Tuple>;
  230|       |               static_assert(N == 1, "Only one input is allowed for your function pointer");
  231|       |
  232|       |               using Params = glz::tuple_element_t<0, Tuple>;
  233|       |
  234|       |               impl::template register_param_function_endpoint<Func, Params>(full_key, func, *this);
  235|       |            }
  236|       |            else if constexpr (std::is_pointer_v<std::remove_cvref_t<Func>> &&
  237|       |                               (glaze_object_t<std::remove_pointer_t<std::remove_cvref_t<Func>>> ||
  238|       |                                reflectable<std::remove_pointer_t<std::remove_cvref_t<Func>>>)) {
  239|       |               // Handle pointer members explicitly for RPC traversal
  240|       |               if (func) { // Only traverse if pointer is valid
  241|       |                  on<root, std::remove_pointer_t<std::remove_cvref_t<Func>>, full_key>(*func);
  242|       |                  impl::template register_object_endpoint<std::remove_pointer_t<std::remove_cvref_t<Func>>>(
  243|       |                     full_key, *func, *this);
  244|       |               }
  245|       |               // else: skip registration for null pointers - no endpoints created
  246|       |            }
  247|       |            else if constexpr (glaze_object_t<std::remove_cvref_t<Func>> || reflectable<std::remove_cvref_t<Func>>) {
  248|       |               on<root, std::remove_cvref_t<Func>, full_key>(func);
  249|       |
  250|       |               impl::template register_object_endpoint<std::remove_cvref_t<Func>>(full_key, func, *this);
  251|       |            }
  252|       |            else if constexpr (not std::is_lvalue_reference_v<Func>) {
  253|       |               // For glz::custom, glz::manage, etc.
  254|       |               impl::template register_value_endpoint<std::remove_cvref_t<Func>>(full_key, func, *this);
  255|       |            }
  256|  61.1k|            else {
  257|  61.1k|               static_assert(std::is_lvalue_reference_v<Func>);
  258|       |
  259|       |               if constexpr (std::is_member_function_pointer_v<std::decay_t<Func>>) {
  260|       |                  using F = std::decay_t<Func>;
  261|       |                  using Ret = typename return_type<F>::type;
  262|       |                  using Tuple = typename inputs_as_tuple<F>::type;
  263|       |                  constexpr auto n_args = glz::tuple_size_v<Tuple>;
  264|       |                  if constexpr (std::is_void_v<Ret>) {
  265|       |                     if constexpr (n_args == 0) {
  266|       |                        impl::template register_member_function_endpoint<T, F, void>(full_key, value, func, *this);
  267|       |                     }
  268|       |                     else if constexpr (n_args == 1) {
  269|       |                        using Input = std::decay_t<glz::tuple_element_t<0, Tuple>>;
  270|       |                        impl::template register_member_function_with_params_endpoint<T, F, Input, void>(full_key, value,
  271|       |                                                                                                        func, *this);
  272|       |                     }
  273|       |                     else {
  274|       |                        static_assert(false_v<Func>, "function cannot have more than one input");
  275|       |                     }
  276|       |                  }
  277|       |                  else {
  278|       |                     // Member function pointers
  279|       |                     if constexpr (n_args == 0) {
  280|       |                        impl::template register_member_function_endpoint<T, F, Ret>(full_key, value, func, *this);
  281|       |                     }
  282|       |                     else if constexpr (n_args == 1) {
  283|       |                        using Input = std::decay_t<glz::tuple_element_t<0, Tuple>>;
  284|       |                        impl::template register_member_function_with_params_endpoint<T, F, Input, Ret>(full_key, value,
  285|       |                                                                                                       func, *this);
  286|       |                     }
  287|       |                     else {
  288|       |                        static_assert(false_v<Func>, "function cannot have more than one input");
  289|       |                     }
  290|       |                  }
  291|       |               }
  292|  61.1k|               else {
  293|       |                  // this is a variable and not a function, so we build RPC read/write calls
  294|       |                  // We can't remove const here, because const fields need to be able to be written
  295|  61.1k|                  impl::template register_variable_endpoint<std::remove_reference_t<Func>>(full_key, func, *this);
  296|  61.1k|               }
  297|  61.1k|            }
  298|  61.1k|         });
jsonrpc_registry.cpp:_ZZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm6EEEDavENKUlvE_clEv:
  191|  61.1k|            decltype(auto) func = [&]() -> decltype(auto) {
  192|  61.1k|               if constexpr (reflectable<T>) {
  193|  61.1k|                  return get_member(value, get<I>(t));
  194|       |               }
  195|       |               else {
  196|       |                  return get_member(value, get<I>(reflect<T>::values));
  197|       |               }
  198|  61.1k|            }();
jsonrpc_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm7EEEDav:
  190|  61.1k|         for_each<N>([&]<auto I>() {
  191|  61.1k|            decltype(auto) func = [&]() -> decltype(auto) {
  192|  61.1k|               if constexpr (reflectable<T>) {
  193|  61.1k|                  return get_member(value, get<I>(t));
  194|  61.1k|               }
  195|  61.1k|               else {
  196|  61.1k|                  return get_member(value, get<I>(reflect<T>::values));
  197|  61.1k|               }
  198|  61.1k|            }();
  199|       |
  200|  61.1k|            static constexpr auto key = reflect<T>::keys[I];
  201|       |
  202|  61.1k|            static constexpr std::string_view full_key = [&] {
  203|  61.1k|               if constexpr (parent == detail::empty_path) {
  204|  61.1k|                  return join_v<chars<"/">, key>;
  205|  61.1k|               }
  206|  61.1k|               else {
  207|  61.1k|                  return join_v<parent, chars<"/">, key>;
  208|  61.1k|               }
  209|  61.1k|            }();
  210|       |
  211|       |            // This logic chain should match glz::cli_menu
  212|  61.1k|            using Func = decltype(func);
  213|       |            if constexpr (std::is_invocable_v<Func>) {
  214|       |               using Result = std::decay_t<std::invoke_result_t<Func>>;
  215|       |               impl::template register_function_endpoint<Func, Result>(full_key, func, *this);
  216|       |            }
  217|       |            else if constexpr (is_invocable_concrete<std::remove_cvref_t<Func>>) {
  218|       |               using Tuple = invocable_args_t<std::remove_cvref_t<Func>>;
  219|       |               constexpr auto N = glz::tuple_size_v<Tuple>;
  220|       |               static_assert(N == 1, "Only one input is allowed for your function");
  221|       |
  222|       |               using Params = glz::tuple_element_t<0, Tuple>;
  223|       |
  224|       |               impl::template register_param_function_endpoint<Func, Params>(full_key, func, *this);
  225|       |            }
  226|       |            else if constexpr (is_function_ptr_invocable<std::remove_cvref_t<Func>>) {
  227|       |               // Handle function pointers with arguments (e.g., void(*)(int))
  228|       |               using Tuple = function_ptr_args_t<std::remove_cvref_t<Func>>;
  229|       |               constexpr auto N = glz::tuple_size_v<Tuple>;
  230|       |               static_assert(N == 1, "Only one input is allowed for your function pointer");
  231|       |
  232|       |               using Params = glz::tuple_element_t<0, Tuple>;
  233|       |
  234|       |               impl::template register_param_function_endpoint<Func, Params>(full_key, func, *this);
  235|       |            }
  236|       |            else if constexpr (std::is_pointer_v<std::remove_cvref_t<Func>> &&
  237|       |                               (glaze_object_t<std::remove_pointer_t<std::remove_cvref_t<Func>>> ||
  238|       |                                reflectable<std::remove_pointer_t<std::remove_cvref_t<Func>>>)) {
  239|       |               // Handle pointer members explicitly for RPC traversal
  240|       |               if (func) { // Only traverse if pointer is valid
  241|       |                  on<root, std::remove_pointer_t<std::remove_cvref_t<Func>>, full_key>(*func);
  242|       |                  impl::template register_object_endpoint<std::remove_pointer_t<std::remove_cvref_t<Func>>>(
  243|       |                     full_key, *func, *this);
  244|       |               }
  245|       |               // else: skip registration for null pointers - no endpoints created
  246|       |            }
  247|       |            else if constexpr (glaze_object_t<std::remove_cvref_t<Func>> || reflectable<std::remove_cvref_t<Func>>) {
  248|       |               on<root, std::remove_cvref_t<Func>, full_key>(func);
  249|       |
  250|       |               impl::template register_object_endpoint<std::remove_cvref_t<Func>>(full_key, func, *this);
  251|       |            }
  252|       |            else if constexpr (not std::is_lvalue_reference_v<Func>) {
  253|       |               // For glz::custom, glz::manage, etc.
  254|       |               impl::template register_value_endpoint<std::remove_cvref_t<Func>>(full_key, func, *this);
  255|       |            }
  256|  61.1k|            else {
  257|  61.1k|               static_assert(std::is_lvalue_reference_v<Func>);
  258|       |
  259|       |               if constexpr (std::is_member_function_pointer_v<std::decay_t<Func>>) {
  260|       |                  using F = std::decay_t<Func>;
  261|       |                  using Ret = typename return_type<F>::type;
  262|       |                  using Tuple = typename inputs_as_tuple<F>::type;
  263|       |                  constexpr auto n_args = glz::tuple_size_v<Tuple>;
  264|       |                  if constexpr (std::is_void_v<Ret>) {
  265|       |                     if constexpr (n_args == 0) {
  266|       |                        impl::template register_member_function_endpoint<T, F, void>(full_key, value, func, *this);
  267|       |                     }
  268|       |                     else if constexpr (n_args == 1) {
  269|       |                        using Input = std::decay_t<glz::tuple_element_t<0, Tuple>>;
  270|       |                        impl::template register_member_function_with_params_endpoint<T, F, Input, void>(full_key, value,
  271|       |                                                                                                        func, *this);
  272|       |                     }
  273|       |                     else {
  274|       |                        static_assert(false_v<Func>, "function cannot have more than one input");
  275|       |                     }
  276|       |                  }
  277|       |                  else {
  278|       |                     // Member function pointers
  279|       |                     if constexpr (n_args == 0) {
  280|       |                        impl::template register_member_function_endpoint<T, F, Ret>(full_key, value, func, *this);
  281|       |                     }
  282|       |                     else if constexpr (n_args == 1) {
  283|       |                        using Input = std::decay_t<glz::tuple_element_t<0, Tuple>>;
  284|       |                        impl::template register_member_function_with_params_endpoint<T, F, Input, Ret>(full_key, value,
  285|       |                                                                                                       func, *this);
  286|       |                     }
  287|       |                     else {
  288|       |                        static_assert(false_v<Func>, "function cannot have more than one input");
  289|       |                     }
  290|       |                  }
  291|       |               }
  292|  61.1k|               else {
  293|       |                  // this is a variable and not a function, so we build RPC read/write calls
  294|       |                  // We can't remove const here, because const fields need to be able to be written
  295|  61.1k|                  impl::template register_variable_endpoint<std::remove_reference_t<Func>>(full_key, func, *this);
  296|  61.1k|               }
  297|  61.1k|            }
  298|  61.1k|         });
jsonrpc_registry.cpp:_ZZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm7EEEDavENKUlvE_clEv:
  191|  61.1k|            decltype(auto) func = [&]() -> decltype(auto) {
  192|  61.1k|               if constexpr (reflectable<T>) {
  193|  61.1k|                  return get_member(value, get<I>(t));
  194|       |               }
  195|       |               else {
  196|       |                  return get_member(value, get<I>(reflect<T>::values));
  197|       |               }
  198|  61.1k|            }();
jsonrpc_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm8EEEDav:
  190|  61.1k|         for_each<N>([&]<auto I>() {
  191|  61.1k|            decltype(auto) func = [&]() -> decltype(auto) {
  192|  61.1k|               if constexpr (reflectable<T>) {
  193|  61.1k|                  return get_member(value, get<I>(t));
  194|  61.1k|               }
  195|  61.1k|               else {
  196|  61.1k|                  return get_member(value, get<I>(reflect<T>::values));
  197|  61.1k|               }
  198|  61.1k|            }();
  199|       |
  200|  61.1k|            static constexpr auto key = reflect<T>::keys[I];
  201|       |
  202|  61.1k|            static constexpr std::string_view full_key = [&] {
  203|  61.1k|               if constexpr (parent == detail::empty_path) {
  204|  61.1k|                  return join_v<chars<"/">, key>;
  205|  61.1k|               }
  206|  61.1k|               else {
  207|  61.1k|                  return join_v<parent, chars<"/">, key>;
  208|  61.1k|               }
  209|  61.1k|            }();
  210|       |
  211|       |            // This logic chain should match glz::cli_menu
  212|  61.1k|            using Func = decltype(func);
  213|       |            if constexpr (std::is_invocable_v<Func>) {
  214|       |               using Result = std::decay_t<std::invoke_result_t<Func>>;
  215|       |               impl::template register_function_endpoint<Func, Result>(full_key, func, *this);
  216|       |            }
  217|  61.1k|            else if constexpr (is_invocable_concrete<std::remove_cvref_t<Func>>) {
  218|  61.1k|               using Tuple = invocable_args_t<std::remove_cvref_t<Func>>;
  219|  61.1k|               constexpr auto N = glz::tuple_size_v<Tuple>;
  220|  61.1k|               static_assert(N == 1, "Only one input is allowed for your function");
  221|       |
  222|  61.1k|               using Params = glz::tuple_element_t<0, Tuple>;
  223|       |
  224|  61.1k|               impl::template register_param_function_endpoint<Func, Params>(full_key, func, *this);
  225|       |            }
  226|       |            else if constexpr (is_function_ptr_invocable<std::remove_cvref_t<Func>>) {
  227|       |               // Handle function pointers with arguments (e.g., void(*)(int))
  228|       |               using Tuple = function_ptr_args_t<std::remove_cvref_t<Func>>;
  229|       |               constexpr auto N = glz::tuple_size_v<Tuple>;
  230|       |               static_assert(N == 1, "Only one input is allowed for your function pointer");
  231|       |
  232|       |               using Params = glz::tuple_element_t<0, Tuple>;
  233|       |
  234|       |               impl::template register_param_function_endpoint<Func, Params>(full_key, func, *this);
  235|       |            }
  236|       |            else if constexpr (std::is_pointer_v<std::remove_cvref_t<Func>> &&
  237|       |                               (glaze_object_t<std::remove_pointer_t<std::remove_cvref_t<Func>>> ||
  238|       |                                reflectable<std::remove_pointer_t<std::remove_cvref_t<Func>>>)) {
  239|       |               // Handle pointer members explicitly for RPC traversal
  240|       |               if (func) { // Only traverse if pointer is valid
  241|       |                  on<root, std::remove_pointer_t<std::remove_cvref_t<Func>>, full_key>(*func);
  242|       |                  impl::template register_object_endpoint<std::remove_pointer_t<std::remove_cvref_t<Func>>>(
  243|       |                     full_key, *func, *this);
  244|       |               }
  245|       |               // else: skip registration for null pointers - no endpoints created
  246|       |            }
  247|       |            else if constexpr (glaze_object_t<std::remove_cvref_t<Func>> || reflectable<std::remove_cvref_t<Func>>) {
  248|       |               on<root, std::remove_cvref_t<Func>, full_key>(func);
  249|       |
  250|       |               impl::template register_object_endpoint<std::remove_cvref_t<Func>>(full_key, func, *this);
  251|       |            }
  252|       |            else if constexpr (not std::is_lvalue_reference_v<Func>) {
  253|       |               // For glz::custom, glz::manage, etc.
  254|       |               impl::template register_value_endpoint<std::remove_cvref_t<Func>>(full_key, func, *this);
  255|       |            }
  256|       |            else {
  257|       |               static_assert(std::is_lvalue_reference_v<Func>);
  258|       |
  259|       |               if constexpr (std::is_member_function_pointer_v<std::decay_t<Func>>) {
  260|       |                  using F = std::decay_t<Func>;
  261|       |                  using Ret = typename return_type<F>::type;
  262|       |                  using Tuple = typename inputs_as_tuple<F>::type;
  263|       |                  constexpr auto n_args = glz::tuple_size_v<Tuple>;
  264|       |                  if constexpr (std::is_void_v<Ret>) {
  265|       |                     if constexpr (n_args == 0) {
  266|       |                        impl::template register_member_function_endpoint<T, F, void>(full_key, value, func, *this);
  267|       |                     }
  268|       |                     else if constexpr (n_args == 1) {
  269|       |                        using Input = std::decay_t<glz::tuple_element_t<0, Tuple>>;
  270|       |                        impl::template register_member_function_with_params_endpoint<T, F, Input, void>(full_key, value,
  271|       |                                                                                                        func, *this);
  272|       |                     }
  273|       |                     else {
  274|       |                        static_assert(false_v<Func>, "function cannot have more than one input");
  275|       |                     }
  276|       |                  }
  277|       |                  else {
  278|       |                     // Member function pointers
  279|       |                     if constexpr (n_args == 0) {
  280|       |                        impl::template register_member_function_endpoint<T, F, Ret>(full_key, value, func, *this);
  281|       |                     }
  282|       |                     else if constexpr (n_args == 1) {
  283|       |                        using Input = std::decay_t<glz::tuple_element_t<0, Tuple>>;
  284|       |                        impl::template register_member_function_with_params_endpoint<T, F, Input, Ret>(full_key, value,
  285|       |                                                                                                       func, *this);
  286|       |                     }
  287|       |                     else {
  288|       |                        static_assert(false_v<Func>, "function cannot have more than one input");
  289|       |                     }
  290|       |                  }
  291|       |               }
  292|       |               else {
  293|       |                  // this is a variable and not a function, so we build RPC read/write calls
  294|       |                  // We can't remove const here, because const fields need to be able to be written
  295|       |                  impl::template register_variable_endpoint<std::remove_reference_t<Func>>(full_key, func, *this);
  296|       |               }
  297|       |            }
  298|  61.1k|         });
jsonrpc_registry.cpp:_ZZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm8EEEDavENKUlvE_clEv:
  191|  61.1k|            decltype(auto) func = [&]() -> decltype(auto) {
  192|  61.1k|               if constexpr (reflectable<T>) {
  193|  61.1k|                  return get_member(value, get<I>(t));
  194|       |               }
  195|       |               else {
  196|       |                  return get_member(value, get<I>(reflect<T>::values));
  197|       |               }
  198|  61.1k|            }();
jsonrpc_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm9EEEDav:
  190|  61.1k|         for_each<N>([&]<auto I>() {
  191|  61.1k|            decltype(auto) func = [&]() -> decltype(auto) {
  192|  61.1k|               if constexpr (reflectable<T>) {
  193|  61.1k|                  return get_member(value, get<I>(t));
  194|  61.1k|               }
  195|  61.1k|               else {
  196|  61.1k|                  return get_member(value, get<I>(reflect<T>::values));
  197|  61.1k|               }
  198|  61.1k|            }();
  199|       |
  200|  61.1k|            static constexpr auto key = reflect<T>::keys[I];
  201|       |
  202|  61.1k|            static constexpr std::string_view full_key = [&] {
  203|  61.1k|               if constexpr (parent == detail::empty_path) {
  204|  61.1k|                  return join_v<chars<"/">, key>;
  205|  61.1k|               }
  206|  61.1k|               else {
  207|  61.1k|                  return join_v<parent, chars<"/">, key>;
  208|  61.1k|               }
  209|  61.1k|            }();
  210|       |
  211|       |            // This logic chain should match glz::cli_menu
  212|  61.1k|            using Func = decltype(func);
  213|       |            if constexpr (std::is_invocable_v<Func>) {
  214|       |               using Result = std::decay_t<std::invoke_result_t<Func>>;
  215|       |               impl::template register_function_endpoint<Func, Result>(full_key, func, *this);
  216|       |            }
  217|  61.1k|            else if constexpr (is_invocable_concrete<std::remove_cvref_t<Func>>) {
  218|  61.1k|               using Tuple = invocable_args_t<std::remove_cvref_t<Func>>;
  219|  61.1k|               constexpr auto N = glz::tuple_size_v<Tuple>;
  220|  61.1k|               static_assert(N == 1, "Only one input is allowed for your function");
  221|       |
  222|  61.1k|               using Params = glz::tuple_element_t<0, Tuple>;
  223|       |
  224|  61.1k|               impl::template register_param_function_endpoint<Func, Params>(full_key, func, *this);
  225|       |            }
  226|       |            else if constexpr (is_function_ptr_invocable<std::remove_cvref_t<Func>>) {
  227|       |               // Handle function pointers with arguments (e.g., void(*)(int))
  228|       |               using Tuple = function_ptr_args_t<std::remove_cvref_t<Func>>;
  229|       |               constexpr auto N = glz::tuple_size_v<Tuple>;
  230|       |               static_assert(N == 1, "Only one input is allowed for your function pointer");
  231|       |
  232|       |               using Params = glz::tuple_element_t<0, Tuple>;
  233|       |
  234|       |               impl::template register_param_function_endpoint<Func, Params>(full_key, func, *this);
  235|       |            }
  236|       |            else if constexpr (std::is_pointer_v<std::remove_cvref_t<Func>> &&
  237|       |                               (glaze_object_t<std::remove_pointer_t<std::remove_cvref_t<Func>>> ||
  238|       |                                reflectable<std::remove_pointer_t<std::remove_cvref_t<Func>>>)) {
  239|       |               // Handle pointer members explicitly for RPC traversal
  240|       |               if (func) { // Only traverse if pointer is valid
  241|       |                  on<root, std::remove_pointer_t<std::remove_cvref_t<Func>>, full_key>(*func);
  242|       |                  impl::template register_object_endpoint<std::remove_pointer_t<std::remove_cvref_t<Func>>>(
  243|       |                     full_key, *func, *this);
  244|       |               }
  245|       |               // else: skip registration for null pointers - no endpoints created
  246|       |            }
  247|       |            else if constexpr (glaze_object_t<std::remove_cvref_t<Func>> || reflectable<std::remove_cvref_t<Func>>) {
  248|       |               on<root, std::remove_cvref_t<Func>, full_key>(func);
  249|       |
  250|       |               impl::template register_object_endpoint<std::remove_cvref_t<Func>>(full_key, func, *this);
  251|       |            }
  252|       |            else if constexpr (not std::is_lvalue_reference_v<Func>) {
  253|       |               // For glz::custom, glz::manage, etc.
  254|       |               impl::template register_value_endpoint<std::remove_cvref_t<Func>>(full_key, func, *this);
  255|       |            }
  256|       |            else {
  257|       |               static_assert(std::is_lvalue_reference_v<Func>);
  258|       |
  259|       |               if constexpr (std::is_member_function_pointer_v<std::decay_t<Func>>) {
  260|       |                  using F = std::decay_t<Func>;
  261|       |                  using Ret = typename return_type<F>::type;
  262|       |                  using Tuple = typename inputs_as_tuple<F>::type;
  263|       |                  constexpr auto n_args = glz::tuple_size_v<Tuple>;
  264|       |                  if constexpr (std::is_void_v<Ret>) {
  265|       |                     if constexpr (n_args == 0) {
  266|       |                        impl::template register_member_function_endpoint<T, F, void>(full_key, value, func, *this);
  267|       |                     }
  268|       |                     else if constexpr (n_args == 1) {
  269|       |                        using Input = std::decay_t<glz::tuple_element_t<0, Tuple>>;
  270|       |                        impl::template register_member_function_with_params_endpoint<T, F, Input, void>(full_key, value,
  271|       |                                                                                                        func, *this);
  272|       |                     }
  273|       |                     else {
  274|       |                        static_assert(false_v<Func>, "function cannot have more than one input");
  275|       |                     }
  276|       |                  }
  277|       |                  else {
  278|       |                     // Member function pointers
  279|       |                     if constexpr (n_args == 0) {
  280|       |                        impl::template register_member_function_endpoint<T, F, Ret>(full_key, value, func, *this);
  281|       |                     }
  282|       |                     else if constexpr (n_args == 1) {
  283|       |                        using Input = std::decay_t<glz::tuple_element_t<0, Tuple>>;
  284|       |                        impl::template register_member_function_with_params_endpoint<T, F, Input, Ret>(full_key, value,
  285|       |                                                                                                       func, *this);
  286|       |                     }
  287|       |                     else {
  288|       |                        static_assert(false_v<Func>, "function cannot have more than one input");
  289|       |                     }
  290|       |                  }
  291|       |               }
  292|       |               else {
  293|       |                  // this is a variable and not a function, so we build RPC read/write calls
  294|       |                  // We can't remove const here, because const fields need to be able to be written
  295|       |                  impl::template register_variable_endpoint<std::remove_reference_t<Func>>(full_key, func, *this);
  296|       |               }
  297|       |            }
  298|  61.1k|         });
jsonrpc_registry.cpp:_ZZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm9EEEDavENKUlvE_clEv:
  191|  61.1k|            decltype(auto) func = [&]() -> decltype(auto) {
  192|  61.1k|               if constexpr (reflectable<T>) {
  193|  61.1k|                  return get_member(value, get<I>(t));
  194|       |               }
  195|       |               else {
  196|       |                  return get_member(value, get<I>(reflect<T>::values));
  197|       |               }
  198|  61.1k|            }();
jsonrpc_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm10EEEDav:
  190|  61.1k|         for_each<N>([&]<auto I>() {
  191|  61.1k|            decltype(auto) func = [&]() -> decltype(auto) {
  192|  61.1k|               if constexpr (reflectable<T>) {
  193|  61.1k|                  return get_member(value, get<I>(t));
  194|  61.1k|               }
  195|  61.1k|               else {
  196|  61.1k|                  return get_member(value, get<I>(reflect<T>::values));
  197|  61.1k|               }
  198|  61.1k|            }();
  199|       |
  200|  61.1k|            static constexpr auto key = reflect<T>::keys[I];
  201|       |
  202|  61.1k|            static constexpr std::string_view full_key = [&] {
  203|  61.1k|               if constexpr (parent == detail::empty_path) {
  204|  61.1k|                  return join_v<chars<"/">, key>;
  205|  61.1k|               }
  206|  61.1k|               else {
  207|  61.1k|                  return join_v<parent, chars<"/">, key>;
  208|  61.1k|               }
  209|  61.1k|            }();
  210|       |
  211|       |            // This logic chain should match glz::cli_menu
  212|  61.1k|            using Func = decltype(func);
  213|       |            if constexpr (std::is_invocable_v<Func>) {
  214|       |               using Result = std::decay_t<std::invoke_result_t<Func>>;
  215|       |               impl::template register_function_endpoint<Func, Result>(full_key, func, *this);
  216|       |            }
  217|  61.1k|            else if constexpr (is_invocable_concrete<std::remove_cvref_t<Func>>) {
  218|  61.1k|               using Tuple = invocable_args_t<std::remove_cvref_t<Func>>;
  219|  61.1k|               constexpr auto N = glz::tuple_size_v<Tuple>;
  220|  61.1k|               static_assert(N == 1, "Only one input is allowed for your function");
  221|       |
  222|  61.1k|               using Params = glz::tuple_element_t<0, Tuple>;
  223|       |
  224|  61.1k|               impl::template register_param_function_endpoint<Func, Params>(full_key, func, *this);
  225|       |            }
  226|       |            else if constexpr (is_function_ptr_invocable<std::remove_cvref_t<Func>>) {
  227|       |               // Handle function pointers with arguments (e.g., void(*)(int))
  228|       |               using Tuple = function_ptr_args_t<std::remove_cvref_t<Func>>;
  229|       |               constexpr auto N = glz::tuple_size_v<Tuple>;
  230|       |               static_assert(N == 1, "Only one input is allowed for your function pointer");
  231|       |
  232|       |               using Params = glz::tuple_element_t<0, Tuple>;
  233|       |
  234|       |               impl::template register_param_function_endpoint<Func, Params>(full_key, func, *this);
  235|       |            }
  236|       |            else if constexpr (std::is_pointer_v<std::remove_cvref_t<Func>> &&
  237|       |                               (glaze_object_t<std::remove_pointer_t<std::remove_cvref_t<Func>>> ||
  238|       |                                reflectable<std::remove_pointer_t<std::remove_cvref_t<Func>>>)) {
  239|       |               // Handle pointer members explicitly for RPC traversal
  240|       |               if (func) { // Only traverse if pointer is valid
  241|       |                  on<root, std::remove_pointer_t<std::remove_cvref_t<Func>>, full_key>(*func);
  242|       |                  impl::template register_object_endpoint<std::remove_pointer_t<std::remove_cvref_t<Func>>>(
  243|       |                     full_key, *func, *this);
  244|       |               }
  245|       |               // else: skip registration for null pointers - no endpoints created
  246|       |            }
  247|       |            else if constexpr (glaze_object_t<std::remove_cvref_t<Func>> || reflectable<std::remove_cvref_t<Func>>) {
  248|       |               on<root, std::remove_cvref_t<Func>, full_key>(func);
  249|       |
  250|       |               impl::template register_object_endpoint<std::remove_cvref_t<Func>>(full_key, func, *this);
  251|       |            }
  252|       |            else if constexpr (not std::is_lvalue_reference_v<Func>) {
  253|       |               // For glz::custom, glz::manage, etc.
  254|       |               impl::template register_value_endpoint<std::remove_cvref_t<Func>>(full_key, func, *this);
  255|       |            }
  256|       |            else {
  257|       |               static_assert(std::is_lvalue_reference_v<Func>);
  258|       |
  259|       |               if constexpr (std::is_member_function_pointer_v<std::decay_t<Func>>) {
  260|       |                  using F = std::decay_t<Func>;
  261|       |                  using Ret = typename return_type<F>::type;
  262|       |                  using Tuple = typename inputs_as_tuple<F>::type;
  263|       |                  constexpr auto n_args = glz::tuple_size_v<Tuple>;
  264|       |                  if constexpr (std::is_void_v<Ret>) {
  265|       |                     if constexpr (n_args == 0) {
  266|       |                        impl::template register_member_function_endpoint<T, F, void>(full_key, value, func, *this);
  267|       |                     }
  268|       |                     else if constexpr (n_args == 1) {
  269|       |                        using Input = std::decay_t<glz::tuple_element_t<0, Tuple>>;
  270|       |                        impl::template register_member_function_with_params_endpoint<T, F, Input, void>(full_key, value,
  271|       |                                                                                                        func, *this);
  272|       |                     }
  273|       |                     else {
  274|       |                        static_assert(false_v<Func>, "function cannot have more than one input");
  275|       |                     }
  276|       |                  }
  277|       |                  else {
  278|       |                     // Member function pointers
  279|       |                     if constexpr (n_args == 0) {
  280|       |                        impl::template register_member_function_endpoint<T, F, Ret>(full_key, value, func, *this);
  281|       |                     }
  282|       |                     else if constexpr (n_args == 1) {
  283|       |                        using Input = std::decay_t<glz::tuple_element_t<0, Tuple>>;
  284|       |                        impl::template register_member_function_with_params_endpoint<T, F, Input, Ret>(full_key, value,
  285|       |                                                                                                       func, *this);
  286|       |                     }
  287|       |                     else {
  288|       |                        static_assert(false_v<Func>, "function cannot have more than one input");
  289|       |                     }
  290|       |                  }
  291|       |               }
  292|       |               else {
  293|       |                  // this is a variable and not a function, so we build RPC read/write calls
  294|       |                  // We can't remove const here, because const fields need to be able to be written
  295|       |                  impl::template register_variable_endpoint<std::remove_reference_t<Func>>(full_key, func, *this);
  296|       |               }
  297|       |            }
  298|  61.1k|         });
jsonrpc_registry.cpp:_ZZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm10EEEDavENKUlvE_clEv:
  191|  61.1k|            decltype(auto) func = [&]() -> decltype(auto) {
  192|  61.1k|               if constexpr (reflectable<T>) {
  193|  61.1k|                  return get_member(value, get<I>(t));
  194|       |               }
  195|       |               else {
  196|       |                  return get_member(value, get<I>(reflect<T>::values));
  197|       |               }
  198|  61.1k|            }();
jsonrpc_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm11EEEDav:
  190|  61.1k|         for_each<N>([&]<auto I>() {
  191|  61.1k|            decltype(auto) func = [&]() -> decltype(auto) {
  192|  61.1k|               if constexpr (reflectable<T>) {
  193|  61.1k|                  return get_member(value, get<I>(t));
  194|  61.1k|               }
  195|  61.1k|               else {
  196|  61.1k|                  return get_member(value, get<I>(reflect<T>::values));
  197|  61.1k|               }
  198|  61.1k|            }();
  199|       |
  200|  61.1k|            static constexpr auto key = reflect<T>::keys[I];
  201|       |
  202|  61.1k|            static constexpr std::string_view full_key = [&] {
  203|  61.1k|               if constexpr (parent == detail::empty_path) {
  204|  61.1k|                  return join_v<chars<"/">, key>;
  205|  61.1k|               }
  206|  61.1k|               else {
  207|  61.1k|                  return join_v<parent, chars<"/">, key>;
  208|  61.1k|               }
  209|  61.1k|            }();
  210|       |
  211|       |            // This logic chain should match glz::cli_menu
  212|  61.1k|            using Func = decltype(func);
  213|       |            if constexpr (std::is_invocable_v<Func>) {
  214|       |               using Result = std::decay_t<std::invoke_result_t<Func>>;
  215|       |               impl::template register_function_endpoint<Func, Result>(full_key, func, *this);
  216|       |            }
  217|  61.1k|            else if constexpr (is_invocable_concrete<std::remove_cvref_t<Func>>) {
  218|  61.1k|               using Tuple = invocable_args_t<std::remove_cvref_t<Func>>;
  219|  61.1k|               constexpr auto N = glz::tuple_size_v<Tuple>;
  220|  61.1k|               static_assert(N == 1, "Only one input is allowed for your function");
  221|       |
  222|  61.1k|               using Params = glz::tuple_element_t<0, Tuple>;
  223|       |
  224|  61.1k|               impl::template register_param_function_endpoint<Func, Params>(full_key, func, *this);
  225|       |            }
  226|       |            else if constexpr (is_function_ptr_invocable<std::remove_cvref_t<Func>>) {
  227|       |               // Handle function pointers with arguments (e.g., void(*)(int))
  228|       |               using Tuple = function_ptr_args_t<std::remove_cvref_t<Func>>;
  229|       |               constexpr auto N = glz::tuple_size_v<Tuple>;
  230|       |               static_assert(N == 1, "Only one input is allowed for your function pointer");
  231|       |
  232|       |               using Params = glz::tuple_element_t<0, Tuple>;
  233|       |
  234|       |               impl::template register_param_function_endpoint<Func, Params>(full_key, func, *this);
  235|       |            }
  236|       |            else if constexpr (std::is_pointer_v<std::remove_cvref_t<Func>> &&
  237|       |                               (glaze_object_t<std::remove_pointer_t<std::remove_cvref_t<Func>>> ||
  238|       |                                reflectable<std::remove_pointer_t<std::remove_cvref_t<Func>>>)) {
  239|       |               // Handle pointer members explicitly for RPC traversal
  240|       |               if (func) { // Only traverse if pointer is valid
  241|       |                  on<root, std::remove_pointer_t<std::remove_cvref_t<Func>>, full_key>(*func);
  242|       |                  impl::template register_object_endpoint<std::remove_pointer_t<std::remove_cvref_t<Func>>>(
  243|       |                     full_key, *func, *this);
  244|       |               }
  245|       |               // else: skip registration for null pointers - no endpoints created
  246|       |            }
  247|       |            else if constexpr (glaze_object_t<std::remove_cvref_t<Func>> || reflectable<std::remove_cvref_t<Func>>) {
  248|       |               on<root, std::remove_cvref_t<Func>, full_key>(func);
  249|       |
  250|       |               impl::template register_object_endpoint<std::remove_cvref_t<Func>>(full_key, func, *this);
  251|       |            }
  252|       |            else if constexpr (not std::is_lvalue_reference_v<Func>) {
  253|       |               // For glz::custom, glz::manage, etc.
  254|       |               impl::template register_value_endpoint<std::remove_cvref_t<Func>>(full_key, func, *this);
  255|       |            }
  256|       |            else {
  257|       |               static_assert(std::is_lvalue_reference_v<Func>);
  258|       |
  259|       |               if constexpr (std::is_member_function_pointer_v<std::decay_t<Func>>) {
  260|       |                  using F = std::decay_t<Func>;
  261|       |                  using Ret = typename return_type<F>::type;
  262|       |                  using Tuple = typename inputs_as_tuple<F>::type;
  263|       |                  constexpr auto n_args = glz::tuple_size_v<Tuple>;
  264|       |                  if constexpr (std::is_void_v<Ret>) {
  265|       |                     if constexpr (n_args == 0) {
  266|       |                        impl::template register_member_function_endpoint<T, F, void>(full_key, value, func, *this);
  267|       |                     }
  268|       |                     else if constexpr (n_args == 1) {
  269|       |                        using Input = std::decay_t<glz::tuple_element_t<0, Tuple>>;
  270|       |                        impl::template register_member_function_with_params_endpoint<T, F, Input, void>(full_key, value,
  271|       |                                                                                                        func, *this);
  272|       |                     }
  273|       |                     else {
  274|       |                        static_assert(false_v<Func>, "function cannot have more than one input");
  275|       |                     }
  276|       |                  }
  277|       |                  else {
  278|       |                     // Member function pointers
  279|       |                     if constexpr (n_args == 0) {
  280|       |                        impl::template register_member_function_endpoint<T, F, Ret>(full_key, value, func, *this);
  281|       |                     }
  282|       |                     else if constexpr (n_args == 1) {
  283|       |                        using Input = std::decay_t<glz::tuple_element_t<0, Tuple>>;
  284|       |                        impl::template register_member_function_with_params_endpoint<T, F, Input, Ret>(full_key, value,
  285|       |                                                                                                       func, *this);
  286|       |                     }
  287|       |                     else {
  288|       |                        static_assert(false_v<Func>, "function cannot have more than one input");
  289|       |                     }
  290|       |                  }
  291|       |               }
  292|       |               else {
  293|       |                  // this is a variable and not a function, so we build RPC read/write calls
  294|       |                  // We can't remove const here, because const fields need to be able to be written
  295|       |                  impl::template register_variable_endpoint<std::remove_reference_t<Func>>(full_key, func, *this);
  296|       |               }
  297|       |            }
  298|  61.1k|         });
jsonrpc_registry.cpp:_ZZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm11EEEDavENKUlvE_clEv:
  191|  61.1k|            decltype(auto) func = [&]() -> decltype(auto) {
  192|  61.1k|               if constexpr (reflectable<T>) {
  193|  61.1k|                  return get_member(value, get<I>(t));
  194|       |               }
  195|       |               else {
  196|       |                  return get_member(value, get<I>(reflect<T>::values));
  197|       |               }
  198|  61.1k|            }();
jsonrpc_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm12EEEDav:
  190|  61.1k|         for_each<N>([&]<auto I>() {
  191|  61.1k|            decltype(auto) func = [&]() -> decltype(auto) {
  192|  61.1k|               if constexpr (reflectable<T>) {
  193|  61.1k|                  return get_member(value, get<I>(t));
  194|  61.1k|               }
  195|  61.1k|               else {
  196|  61.1k|                  return get_member(value, get<I>(reflect<T>::values));
  197|  61.1k|               }
  198|  61.1k|            }();
  199|       |
  200|  61.1k|            static constexpr auto key = reflect<T>::keys[I];
  201|       |
  202|  61.1k|            static constexpr std::string_view full_key = [&] {
  203|  61.1k|               if constexpr (parent == detail::empty_path) {
  204|  61.1k|                  return join_v<chars<"/">, key>;
  205|  61.1k|               }
  206|  61.1k|               else {
  207|  61.1k|                  return join_v<parent, chars<"/">, key>;
  208|  61.1k|               }
  209|  61.1k|            }();
  210|       |
  211|       |            // This logic chain should match glz::cli_menu
  212|  61.1k|            using Func = decltype(func);
  213|  61.1k|            if constexpr (std::is_invocable_v<Func>) {
  214|  61.1k|               using Result = std::decay_t<std::invoke_result_t<Func>>;
  215|  61.1k|               impl::template register_function_endpoint<Func, Result>(full_key, func, *this);
  216|       |            }
  217|       |            else if constexpr (is_invocable_concrete<std::remove_cvref_t<Func>>) {
  218|       |               using Tuple = invocable_args_t<std::remove_cvref_t<Func>>;
  219|       |               constexpr auto N = glz::tuple_size_v<Tuple>;
  220|       |               static_assert(N == 1, "Only one input is allowed for your function");
  221|       |
  222|       |               using Params = glz::tuple_element_t<0, Tuple>;
  223|       |
  224|       |               impl::template register_param_function_endpoint<Func, Params>(full_key, func, *this);
  225|       |            }
  226|       |            else if constexpr (is_function_ptr_invocable<std::remove_cvref_t<Func>>) {
  227|       |               // Handle function pointers with arguments (e.g., void(*)(int))
  228|       |               using Tuple = function_ptr_args_t<std::remove_cvref_t<Func>>;
  229|       |               constexpr auto N = glz::tuple_size_v<Tuple>;
  230|       |               static_assert(N == 1, "Only one input is allowed for your function pointer");
  231|       |
  232|       |               using Params = glz::tuple_element_t<0, Tuple>;
  233|       |
  234|       |               impl::template register_param_function_endpoint<Func, Params>(full_key, func, *this);
  235|       |            }
  236|       |            else if constexpr (std::is_pointer_v<std::remove_cvref_t<Func>> &&
  237|       |                               (glaze_object_t<std::remove_pointer_t<std::remove_cvref_t<Func>>> ||
  238|       |                                reflectable<std::remove_pointer_t<std::remove_cvref_t<Func>>>)) {
  239|       |               // Handle pointer members explicitly for RPC traversal
  240|       |               if (func) { // Only traverse if pointer is valid
  241|       |                  on<root, std::remove_pointer_t<std::remove_cvref_t<Func>>, full_key>(*func);
  242|       |                  impl::template register_object_endpoint<std::remove_pointer_t<std::remove_cvref_t<Func>>>(
  243|       |                     full_key, *func, *this);
  244|       |               }
  245|       |               // else: skip registration for null pointers - no endpoints created
  246|       |            }
  247|       |            else if constexpr (glaze_object_t<std::remove_cvref_t<Func>> || reflectable<std::remove_cvref_t<Func>>) {
  248|       |               on<root, std::remove_cvref_t<Func>, full_key>(func);
  249|       |
  250|       |               impl::template register_object_endpoint<std::remove_cvref_t<Func>>(full_key, func, *this);
  251|       |            }
  252|       |            else if constexpr (not std::is_lvalue_reference_v<Func>) {
  253|       |               // For glz::custom, glz::manage, etc.
  254|       |               impl::template register_value_endpoint<std::remove_cvref_t<Func>>(full_key, func, *this);
  255|       |            }
  256|       |            else {
  257|       |               static_assert(std::is_lvalue_reference_v<Func>);
  258|       |
  259|       |               if constexpr (std::is_member_function_pointer_v<std::decay_t<Func>>) {
  260|       |                  using F = std::decay_t<Func>;
  261|       |                  using Ret = typename return_type<F>::type;
  262|       |                  using Tuple = typename inputs_as_tuple<F>::type;
  263|       |                  constexpr auto n_args = glz::tuple_size_v<Tuple>;
  264|       |                  if constexpr (std::is_void_v<Ret>) {
  265|       |                     if constexpr (n_args == 0) {
  266|       |                        impl::template register_member_function_endpoint<T, F, void>(full_key, value, func, *this);
  267|       |                     }
  268|       |                     else if constexpr (n_args == 1) {
  269|       |                        using Input = std::decay_t<glz::tuple_element_t<0, Tuple>>;
  270|       |                        impl::template register_member_function_with_params_endpoint<T, F, Input, void>(full_key, value,
  271|       |                                                                                                        func, *this);
  272|       |                     }
  273|       |                     else {
  274|       |                        static_assert(false_v<Func>, "function cannot have more than one input");
  275|       |                     }
  276|       |                  }
  277|       |                  else {
  278|       |                     // Member function pointers
  279|       |                     if constexpr (n_args == 0) {
  280|       |                        impl::template register_member_function_endpoint<T, F, Ret>(full_key, value, func, *this);
  281|       |                     }
  282|       |                     else if constexpr (n_args == 1) {
  283|       |                        using Input = std::decay_t<glz::tuple_element_t<0, Tuple>>;
  284|       |                        impl::template register_member_function_with_params_endpoint<T, F, Input, Ret>(full_key, value,
  285|       |                                                                                                       func, *this);
  286|       |                     }
  287|       |                     else {
  288|       |                        static_assert(false_v<Func>, "function cannot have more than one input");
  289|       |                     }
  290|       |                  }
  291|       |               }
  292|       |               else {
  293|       |                  // this is a variable and not a function, so we build RPC read/write calls
  294|       |                  // We can't remove const here, because const fields need to be able to be written
  295|       |                  impl::template register_variable_endpoint<std::remove_reference_t<Func>>(full_key, func, *this);
  296|       |               }
  297|       |            }
  298|  61.1k|         });
jsonrpc_registry.cpp:_ZZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm12EEEDavENKUlvE_clEv:
  191|  61.1k|            decltype(auto) func = [&]() -> decltype(auto) {
  192|  61.1k|               if constexpr (reflectable<T>) {
  193|  61.1k|                  return get_member(value, get<I>(t));
  194|       |               }
  195|       |               else {
  196|       |                  return get_member(value, get<I>(reflect<T>::values));
  197|       |               }
  198|  61.1k|            }();
_ZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE4callENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEQeqT0_L_ZNS_7JSONRPCEE:
  513|  61.1k|      {
  514|       |         // Find first non-whitespace to determine batch vs single request
  515|  61.1k|         auto it = std::find_if(json_request.begin(), json_request.end(),
  516|  61.1k|                                [](char c) { return !std::isspace(static_cast<unsigned char>(c)); });
  517|       |
  518|  61.1k|         if (it != json_request.end() && *it == '[') {
  ------------------
  |  Branch (518:14): [True: 61.0k, False: 17]
  |  Branch (518:42): [True: 23.4k, False: 37.6k]
  ------------------
  519|       |            // Batch request
  520|  23.4k|            std::vector<glz::raw_json_view> batch_requests{};
  521|  23.4k|            if (const auto ec = glz::read<read_opts>(batch_requests, json_request); ec) {
  ------------------
  |  Branch (521:85): [True: 6.75k, False: 16.6k]
  ------------------
  522|  6.75k|               return R"({"jsonrpc":"2.0","error":{"code":-32700,"message":"Parse error","data":)" +
  523|  6.75k|                      write_json(format_error(ec, json_request)).value_or("null") + R"(},"id":null})";
  524|  6.75k|            }
  525|  16.6k|            if (batch_requests.empty()) {
  ------------------
  |  Branch (525:17): [True: 11, False: 16.6k]
  ------------------
  526|     11|               return R"({"jsonrpc":"2.0","error":{"code":-32600,"message":"Invalid Request","data":"Empty batch"},"id":null})";
  527|     11|            }
  528|  16.6k|            return process_batch(batch_requests);
  529|  16.6k|         }
  530|       |
  531|       |         // Single request
  532|  37.6k|         auto response = process_single_request(json_request);
  533|  37.6k|         return response.value_or("");
  534|  61.1k|      }
_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE4callENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEQeqT0_L_ZNS_7JSONRPCEEENKUlcE_clEc:
  516|  66.0k|                                [](char c) { return !std::isspace(static_cast<unsigned char>(c)); });
_ZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE13process_batchERKNSt3__16vectorINS_14basic_raw_jsonINS3_17basic_string_viewIcNS3_11char_traitsIcEEEEEENS3_9allocatorISA_EEEEQeqT0_L_ZNS_7JSONRPCEE:
  644|  16.6k|      {
  645|  16.6k|         std::vector<std::string> responses;
  646|  16.6k|         responses.reserve(batch.size());
  647|       |
  648|  16.6k|         size_t total_size = 2; // []
  649|  4.11M|         for (const auto& req : batch) {
  ------------------
  |  Branch (649:31): [True: 4.11M, False: 16.6k]
  ------------------
  650|  4.11M|            auto response = process_single_request(req.str);
  651|  4.11M|            if (response.has_value()) {
  ------------------
  |  Branch (651:17): [True: 4.10M, False: 16.0k]
  ------------------
  652|  4.10M|               total_size += response->size() + 1; // +1 for comma
  653|       |               // Checked as the batch is walked rather than after it, so the elements past the
  654|       |               // limit are never run and what they would have answered with is never built. The
  655|       |               // element that trips it has already been built, so the peak is the limit plus one
  656|       |               // response rather than the limit exactly. The elements already run keep their
  657|       |               // effects -- a JSON RPC batch is not a transaction -- but the caller is told the
  658|       |               // batch failed rather than handed a partial array it cannot distinguish from a
  659|       |               // complete one.
  660|  4.10M|               if (total_size > max_batch_response_size) {
  ------------------
  |  Branch (660:20): [True: 5, False: 4.10M]
  ------------------
  661|      5|                  return R"({"jsonrpc":"2.0","error":{"code":-32000,"message":"Server error","data":"Batch response exceeds max_batch_response_size"},"id":null})";
  662|      5|               }
  663|  4.10M|               responses.push_back(std::move(*response));
  664|  4.10M|            }
  665|  4.11M|         }
  666|       |
  667|       |         // If all were notifications, return empty string
  668|  16.6k|         if (responses.empty()) {
  ------------------
  |  Branch (668:14): [True: 118, False: 16.5k]
  ------------------
  669|    118|            return "";
  670|    118|         }
  671|       |
  672|       |         // Build batch response array with pre-reserved capacity
  673|  16.5k|         std::string result;
  674|  16.5k|         result.reserve(total_size);
  675|  16.5k|         result = "[";
  676|  3.34M|         for (size_t i = 0; i < responses.size(); ++i) {
  ------------------
  |  Branch (676:29): [True: 3.32M, False: 16.5k]
  ------------------
  677|  3.32M|            if (i > 0) {
  ------------------
  |  Branch (677:17): [True: 3.31M, False: 16.5k]
  ------------------
  678|  3.31M|               result += ",";
  679|  3.31M|            }
  680|  3.32M|            result += responses[i];
  681|  3.32M|         }
  682|  16.5k|         result += "]";
  683|  16.5k|         return result;
  684|  16.6k|      }
_ZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE22process_single_requestENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEQeqT0_L_ZNS_7JSONRPCEE:
  540|  4.15M|      {
  541|  4.15M|         rpc::request_envelope_t request{};
  542|  4.15M|         if (const auto read_ec = glz::read<read_opts>(request, json_request); read_ec) {
  ------------------
  |  Branch (542:80): [True: 4.09M, False: 63.8k]
  ------------------
  543|       |            // Check if it's a JSON syntax error vs schema error
  544|  4.09M|            static constexpr registry_validate_opts<read_opts> validate_opts{{read_opts}};
  545|  4.09M|            glz::skip skip_value{};
  546|  4.09M|            context validate_ctx{};
  547|  4.09M|            if (glz::read<validate_opts>(skip_value, json_request, validate_ctx)) {
  ------------------
  |  Branch (547:17): [True: 3.96M, False: 122k]
  ------------------
  548|       |               // JSON is syntactically invalid - return Parse error (-32700)
  549|  3.96M|               return R"({"jsonrpc":"2.0","error":{"code":-32700,"message":"Parse error","data":)" +
  550|  3.96M|                      write_json(format_error(read_ec, json_request)).value_or("null") + R"(},"id":null})";
  551|  3.96M|            }
  552|       |            // Valid JSON but invalid request structure - return Invalid Request (-32600)
  553|   122k|            auto id = glz::get_as_json<rpc::id_t, "/id", read_opts>(json_request);
  554|   122k|            std::string id_json = id.has_value() ? glz::write_json(id.value()).value_or("null") : "null";
  ------------------
  |  Branch (554:35): [True: 3.00k, False: 119k]
  ------------------
  555|   122k|            return R"({"jsonrpc":"2.0","error":{"code":-32600,"message":"Invalid Request","data":)" +
  556|   122k|                   write_json(format_error(read_ec, json_request)).value_or("null") + R"(},"id":)" + id_json + "}";
  557|  4.09M|         }
  558|       |
  559|  63.8k|         auto& req = request;
  560|       |
  561|  63.8k|         const auto invalid_request = [&req](const std::string& data) {
  562|  63.8k|            std::string id_json = glz::write_json(req.id).value_or("null");
  563|  63.8k|            return R"({"jsonrpc":"2.0","error":{"code":-32600,"message":"Invalid Request","data":)" +
  564|  63.8k|                   write_json(data).value_or("null") + R"(},"id":)" + id_json + "}";
  565|  63.8k|         };
  566|       |
  567|       |         // `jsonrpc` and `method` are both required members, and an absent one cannot be allowed to
  568|       |         // fall through to a default: an absent version would pass for 2.0, and an absent method
  569|       |         // names "", which is the root endpoint -- so `{"id":1}` would answer with the whole
  570|       |         // registered object rather than being rejected.
  571|  63.8k|         if (!req.version) {
  ------------------
  |  Branch (571:14): [True: 19.2k, False: 44.5k]
  ------------------
  572|  19.2k|            return invalid_request("Missing 'jsonrpc' member");
  573|  19.2k|         }
  574|  44.5k|         if (*req.version != rpc::supported_version) {
  ------------------
  |  Branch (574:14): [True: 4.98k, False: 39.5k]
  ------------------
  575|  4.98k|            return invalid_request("Invalid version: " + std::string(*req.version));
  576|  4.98k|         }
  577|  39.5k|         if (!req.method) {
  ------------------
  |  Branch (577:14): [True: 275, False: 39.3k]
  ------------------
  578|    275|            return invalid_request("Missing 'method' member");
  579|    275|         }
  580|  39.3k|         const std::string_view method_name = *req.method;
  581|       |
  582|       |         // Check if this is a notification (id is null)
  583|  39.3k|         bool is_notification = std::holds_alternative<glz::generic::null_t>(req.id);
  584|       |
  585|       |         // Look up the endpoint - try direct lookup first (handles methods that already start with /)
  586|  39.3k|         auto it = endpoints.find(method_name);
  587|  39.3k|         if (it == endpoints.end()) {
  ------------------
  |  Branch (587:14): [True: 31.5k, False: 7.70k]
  ------------------
  588|  31.5k|            if (!method_name.empty()) {
  ------------------
  |  Branch (588:17): [True: 31.5k, False: 0]
  ------------------
  589|       |               // Try with leading slash using stack buffer for common case
  590|  31.5k|               char buf[256];
  591|  31.5k|               if (method_name.size() < sizeof(buf) - 1) {
  ------------------
  |  Branch (591:20): [True: 31.5k, False: 0]
  ------------------
  592|  31.5k|                  buf[0] = '/';
  593|  31.5k|                  std::memcpy(buf + 1, method_name.data(), method_name.size());
  594|  31.5k|                  it = endpoints.find(std::string_view{buf, method_name.size() + 1});
  595|  31.5k|               }
  596|      0|               else {
  597|       |                  // Fallback for very long method names
  598|      0|                  std::string method_path = "/";
  599|      0|                  method_path += method_name;
  600|      0|                  it = endpoints.find(method_path);
  601|      0|               }
  602|  31.5k|            }
  603|      0|            else {
  604|       |               // Empty method - try root endpoint
  605|      0|               it = endpoints.find("");
  606|      0|            }
  607|  31.5k|            if (it == endpoints.end()) {
  ------------------
  |  Branch (607:17): [True: 111, False: 31.4k]
  ------------------
  608|    111|               if (is_notification) {
  ------------------
  |  Branch (608:20): [True: 71, False: 40]
  ------------------
  609|     71|                  return std::nullopt; // No response for notifications
  610|     71|               }
  611|     40|               std::string id_json = glz::write_json(req.id).value_or("null");
  612|     40|               return R"({"jsonrpc":"2.0","error":{"code":-32601,"message":"Method not found","data":)" +
  613|     40|                      write_json(method_name).value_or("null") + R"(},"id":)" + id_json + "}";
  614|    111|            }
  615|  31.5k|         }
  616|       |
  617|       |         // Prepare state
  618|  39.1k|         std::string response;
  619|  39.1k|         bool has_params = !req.params.str.empty() && req.params.str != "null";
  ------------------
  |  Branch (619:28): [True: 22.1k, False: 16.9k]
  |  Branch (619:55): [True: 22.1k, False: 6]
  ------------------
  620|  39.1k|         jsonrpc::state state{req.id, response, is_notification, has_params, req.params.str};
  621|       |
  622|  39.1k|         try {
  623|  39.1k|            it->second(std::move(state));
  624|  39.1k|         }
  625|  39.1k|         catch (const std::exception& e) {
  626|      0|            if (is_notification) {
  ------------------
  |  Branch (626:17): [True: 0, False: 0]
  ------------------
  627|      0|               return std::nullopt;
  628|      0|            }
  629|      0|            std::string id_json = glz::write_json(req.id).value_or("null");
  630|      0|            return R"({"jsonrpc":"2.0","error":{"code":-32603,"message":"Internal error","data":)" +
  631|      0|                   write_json(std::string_view{e.what()}).value_or("null") + R"(},"id":)" + id_json + "}";
  632|      0|         }
  633|       |
  634|  39.1k|         if (is_notification) {
  ------------------
  |  Branch (634:14): [True: 18.9k, False: 20.2k]
  ------------------
  635|  18.9k|            return std::nullopt;
  636|  18.9k|         }
  637|       |
  638|  20.2k|         return response;
  639|  39.1k|      }
_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE22process_single_requestENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEQeqT0_L_ZNS_7JSONRPCEEENKUlRKNS3_12basic_stringIcS6_NS3_9allocatorIcEEEEE_clESD_:
  561|  24.5k|         const auto invalid_request = [&req](const std::string& data) {
  562|  24.5k|            std::string id_json = glz::write_json(req.id).value_or("null");
  563|  24.5k|            return R"({"jsonrpc":"2.0","error":{"code":-32600,"message":"Invalid Request","data":)" +
  564|  24.5k|                   write_json(data).value_or("null") + R"(},"id":)" + id_json + "}";
  565|  24.5k|         };

_ZNK3glz6detail11string_hashclENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE:
   27|  1.47M|      [[nodiscard]] size_t operator()(std::string_view txt) const { return std::hash<std::string_view>{}(txt); }

_ZN3glz6detail18sse2_string_escapeIcRZNS_2toILj10ENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEE2opITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERS9_RKS9_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_EUlvE0_EEvRPKcST_RPT_mSN_:
   17|  49.3k|   {
   18|       |      // SSE2: 16 bytes at a time with direct comparison instructions
   19|  49.3k|      if (n > 15) {
  ------------------
  |  Branch (19:11): [True: 36.9k, False: 12.4k]
  ------------------
   20|  36.9k|         const __m128i quote_vec = _mm_set1_epi8('"');
   21|  36.9k|         const __m128i bs_vec = _mm_set1_epi8('\\');
   22|  36.9k|         const __m128i ctrl_mask = _mm_set1_epi8(static_cast<int8_t>(0xE0));
   23|  36.9k|         const __m128i zero = _mm_setzero_si128();
   24|       |
   25|  13.4M|         for (const char* end_m15 = e - 15; c < end_m15;) {
  ------------------
  |  Branch (25:45): [True: 13.3M, False: 36.9k]
  ------------------
   26|  13.3M|            __m128i v = _mm_loadu_si128(reinterpret_cast<const __m128i*>(c));
   27|  13.3M|            _mm_storeu_si128(reinterpret_cast<__m128i*>(data), v);
   28|       |
   29|  13.3M|            const uint32_t mask = static_cast<uint32_t>(
   30|  13.3M|               _mm_movemask_epi8(_mm_or_si128(_mm_or_si128(_mm_cmpeq_epi8(v, quote_vec), _mm_cmpeq_epi8(v, bs_vec)),
   31|  13.3M|                                              _mm_cmpeq_epi8(_mm_and_si128(v, ctrl_mask), zero))));
   32|       |
   33|  13.3M|            if (mask == 0) {
  ------------------
  |  Branch (33:17): [True: 121k, False: 13.2M]
  ------------------
   34|   121k|               data += 16;
   35|   121k|               c += 16;
   36|   121k|               continue;
   37|   121k|            }
   38|       |
   39|  13.2M|            const uint32_t length = countr_zero(mask);
   40|  13.2M|            c += length;
   41|  13.2M|            data += length;
   42|  13.2M|            write_escape();
   43|  13.2M|         }
   44|  36.9k|      }
   45|  49.3k|   }
_ZN3glz6detail18sse2_string_escapeIcRZNS_2toILj10ENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEE2opITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERNS3_12basic_stringIcS6_NS3_9allocatorIcEEEERS7_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_EUlvE0_EEvRPKcSU_RPT_mSO_:
   17|  5.77k|   {
   18|       |      // SSE2: 16 bytes at a time with direct comparison instructions
   19|  5.77k|      if (n > 15) {
  ------------------
  |  Branch (19:11): [True: 2.93k, False: 2.84k]
  ------------------
   20|  2.93k|         const __m128i quote_vec = _mm_set1_epi8('"');
   21|  2.93k|         const __m128i bs_vec = _mm_set1_epi8('\\');
   22|  2.93k|         const __m128i ctrl_mask = _mm_set1_epi8(static_cast<int8_t>(0xE0));
   23|  2.93k|         const __m128i zero = _mm_setzero_si128();
   24|       |
   25|  28.3M|         for (const char* end_m15 = e - 15; c < end_m15;) {
  ------------------
  |  Branch (25:45): [True: 28.3M, False: 2.93k]
  ------------------
   26|  28.3M|            __m128i v = _mm_loadu_si128(reinterpret_cast<const __m128i*>(c));
   27|  28.3M|            _mm_storeu_si128(reinterpret_cast<__m128i*>(data), v);
   28|       |
   29|  28.3M|            const uint32_t mask = static_cast<uint32_t>(
   30|  28.3M|               _mm_movemask_epi8(_mm_or_si128(_mm_or_si128(_mm_cmpeq_epi8(v, quote_vec), _mm_cmpeq_epi8(v, bs_vec)),
   31|  28.3M|                                              _mm_cmpeq_epi8(_mm_and_si128(v, ctrl_mask), zero))));
   32|       |
   33|  28.3M|            if (mask == 0) {
  ------------------
  |  Branch (33:17): [True: 406k, False: 27.9M]
  ------------------
   34|   406k|               data += 16;
   35|   406k|               c += 16;
   36|   406k|               continue;
   37|   406k|            }
   38|       |
   39|  27.9M|            const uint32_t length = countr_zero(mask);
   40|  27.9M|            c += length;
   41|  27.9M|            data += length;
   42|  27.9M|            write_escape();
   43|  27.9M|         }
   44|  2.93k|      }
   45|  5.77k|   }
_ZN3glz6detail18sse2_string_escapeIcRZNS_2toILj10ENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS9_SD_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_EUlvE0_EEvRPKcSR_RPT_mSL_:
   17|    859|   {
   18|       |      // SSE2: 16 bytes at a time with direct comparison instructions
   19|    859|      if (n > 15) {
  ------------------
  |  Branch (19:11): [True: 226, False: 633]
  ------------------
   20|    226|         const __m128i quote_vec = _mm_set1_epi8('"');
   21|    226|         const __m128i bs_vec = _mm_set1_epi8('\\');
   22|    226|         const __m128i ctrl_mask = _mm_set1_epi8(static_cast<int8_t>(0xE0));
   23|    226|         const __m128i zero = _mm_setzero_si128();
   24|       |
   25|   727k|         for (const char* end_m15 = e - 15; c < end_m15;) {
  ------------------
  |  Branch (25:45): [True: 727k, False: 226]
  ------------------
   26|   727k|            __m128i v = _mm_loadu_si128(reinterpret_cast<const __m128i*>(c));
   27|   727k|            _mm_storeu_si128(reinterpret_cast<__m128i*>(data), v);
   28|       |
   29|   727k|            const uint32_t mask = static_cast<uint32_t>(
   30|   727k|               _mm_movemask_epi8(_mm_or_si128(_mm_or_si128(_mm_cmpeq_epi8(v, quote_vec), _mm_cmpeq_epi8(v, bs_vec)),
   31|   727k|                                              _mm_cmpeq_epi8(_mm_and_si128(v, ctrl_mask), zero))));
   32|       |
   33|   727k|            if (mask == 0) {
  ------------------
  |  Branch (33:17): [True: 718k, False: 8.79k]
  ------------------
   34|   718k|               data += 16;
   35|   718k|               c += 16;
   36|   718k|               continue;
   37|   718k|            }
   38|       |
   39|  8.79k|            const uint32_t length = countr_zero(mask);
   40|  8.79k|            c += length;
   41|  8.79k|            data += length;
   42|  8.79k|            write_escape();
   43|  8.79k|         }
   44|    226|      }
   45|    859|   }
_ZN3glz6detail18sse2_string_escapeIcRZNS_2toILj10ENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEE2opITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERS9_S9_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_EUlvE0_EEvRPKcSR_RPT_mSL_:
   17|  4.09M|   {
   18|       |      // SSE2: 16 bytes at a time with direct comparison instructions
   19|  4.09M|      if (n > 15) {
  ------------------
  |  Branch (19:11): [True: 4.09M, False: 0]
  ------------------
   20|  4.09M|         const __m128i quote_vec = _mm_set1_epi8('"');
   21|  4.09M|         const __m128i bs_vec = _mm_set1_epi8('\\');
   22|  4.09M|         const __m128i ctrl_mask = _mm_set1_epi8(static_cast<int8_t>(0xE0));
   23|  4.09M|         const __m128i zero = _mm_setzero_si128();
   24|       |
   25|  9.23M|         for (const char* end_m15 = e - 15; c < end_m15;) {
  ------------------
  |  Branch (25:45): [True: 5.13M, False: 4.09M]
  ------------------
   26|  5.13M|            __m128i v = _mm_loadu_si128(reinterpret_cast<const __m128i*>(c));
   27|  5.13M|            _mm_storeu_si128(reinterpret_cast<__m128i*>(data), v);
   28|       |
   29|  5.13M|            const uint32_t mask = static_cast<uint32_t>(
   30|  5.13M|               _mm_movemask_epi8(_mm_or_si128(_mm_or_si128(_mm_cmpeq_epi8(v, quote_vec), _mm_cmpeq_epi8(v, bs_vec)),
   31|  5.13M|                                              _mm_cmpeq_epi8(_mm_and_si128(v, ctrl_mask), zero))));
   32|       |
   33|  5.13M|            if (mask == 0) {
  ------------------
  |  Branch (33:17): [True: 4.23M, False: 895k]
  ------------------
   34|  4.23M|               data += 16;
   35|  4.23M|               c += 16;
   36|  4.23M|               continue;
   37|  4.23M|            }
   38|       |
   39|   895k|            const uint32_t length = countr_zero(mask);
   40|   895k|            c += length;
   41|   895k|            data += length;
   42|   895k|            write_escape();
   43|   895k|         }
   44|  4.09M|      }
   45|  4.09M|   }
_ZN3glz6detail18sse2_string_escapeIcRZNS_2toILj10ENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEE2opITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERNS3_12basic_stringIcS6_NS3_9allocatorIcEEEERKS7_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_EUlvE0_EEvRPKcSV_RPT_mSP_:
   17|     40|   {
   18|       |      // SSE2: 16 bytes at a time with direct comparison instructions
   19|     40|      if (n > 15) {
  ------------------
  |  Branch (19:11): [True: 0, False: 40]
  ------------------
   20|      0|         const __m128i quote_vec = _mm_set1_epi8('"');
   21|      0|         const __m128i bs_vec = _mm_set1_epi8('\\');
   22|      0|         const __m128i ctrl_mask = _mm_set1_epi8(static_cast<int8_t>(0xE0));
   23|      0|         const __m128i zero = _mm_setzero_si128();
   24|       |
   25|      0|         for (const char* end_m15 = e - 15; c < end_m15;) {
  ------------------
  |  Branch (25:45): [True: 0, False: 0]
  ------------------
   26|      0|            __m128i v = _mm_loadu_si128(reinterpret_cast<const __m128i*>(c));
   27|      0|            _mm_storeu_si128(reinterpret_cast<__m128i*>(data), v);
   28|       |
   29|      0|            const uint32_t mask = static_cast<uint32_t>(
   30|      0|               _mm_movemask_epi8(_mm_or_si128(_mm_or_si128(_mm_cmpeq_epi8(v, quote_vec), _mm_cmpeq_epi8(v, bs_vec)),
   31|      0|                                              _mm_cmpeq_epi8(_mm_and_si128(v, ctrl_mask), zero))));
   32|       |
   33|      0|            if (mask == 0) {
  ------------------
  |  Branch (33:17): [True: 0, False: 0]
  ------------------
   34|      0|               data += 16;
   35|      0|               c += 16;
   36|      0|               continue;
   37|      0|            }
   38|       |
   39|      0|            const uint32_t length = countr_zero(mask);
   40|      0|            c += length;
   41|      0|            data += length;
   42|      0|            write_escape();
   43|      0|         }
   44|      0|      }
   45|     40|   }

_ZN3glz4atoiITkNSt3__18integralEicEEbRT_RPKT0_S6_:
  803|   644k|   {
  804|       |      // The number of characters needed at most for each type, rounded to nearest 8 bytes
  805|   644k|      constexpr auto buffer_length = int_buffer_lengths[std::bit_width(sizeof(T)) - 1];
  806|       |      // We copy the rest of the buffer, or buffer_length bytes, into a null terminated buffer. The
  807|       |      // trailing byte is never written by the copy, so the null-terminated atoi below always halts
  808|       |      // inside the array even when the input fills it: the exponent scan stops at a non-digit rather
  809|       |      // than after a fixed digit count, and a value-initialized array alone would not terminate a
  810|       |      // copy that covers every byte.
  811|   644k|      std::array<char, buffer_length + 1> data{};
  812|   644k|      const auto n = size_t(end - it);
  813|   644k|      if (n > 0) [[likely]] {
  ------------------
  |  Branch (813:11): [True: 644k, False: 0]
  ------------------
  814|   644k|         const auto truncated = n > buffer_length;
  815|   644k|         std::memcpy(data.data(), it, truncated ? buffer_length : n);
  ------------------
  |  Branch (815:39): [True: 633k, False: 10.8k]
  ------------------
  816|       |
  817|   644k|         const auto start = data.data();
  818|   644k|         const auto* c = start;
  819|   644k|         const auto valid = glz::atoi(v, c);
  820|   644k|         const auto consumed = size_t(c - start);
  821|   644k|         it += consumed;
  822|       |         // Reaching the end of a truncated copy means the number was cut off: parsing halted on the
  823|       |         // terminator this buffer supplies rather than on a character of the input, so what parsed is
  824|       |         // a prefix and its value is not the number's. Only zero padding can stretch a number this
  825|       |         // far -- no in-range integer needs buffer_length characters -- but a caller that ignores
  826|       |         // trailing content would otherwise take the prefix's value as the answer.
  827|   644k|         return valid && not(truncated && consumed == buffer_length);
  ------------------
  |  Branch (827:17): [True: 641k, False: 3.12k]
  |  Branch (827:30): [True: 633k, False: 8.06k]
  |  Branch (827:43): [True: 0, False: 633k]
  ------------------
  828|   644k|      }
  829|      0|      else [[unlikely]] {
  830|      0|         return false;
  831|      0|      }
  832|   644k|   }
_ZN3glz4atoiITkNSt3__18integralEiKcQsr3stdE11is_signed_vIT_EEEbRS3_RPT0_:
  715|   644k|   {
  716|   644k|      using X = std::decay_t<T>;
  717|   644k|      using utype = std::make_unsigned_t<X>;
  718|       |
  719|   644k|      const uint8_t sign = *c == '-';
  720|   644k|      if (auto ptr = parse_int(v, reinterpret_cast<const uint8_t*>(c))) [[likely]] {
  ------------------
  |  Branch (720:16): [True: 642k, False: 1.77k]
  ------------------
  721|   642k|         c = reinterpret_cast<const Char*>(ptr);
  722|   642k|         if (*c == 'e' || *c == 'E') {
  ------------------
  |  Branch (722:14): [True: 5.28k, False: 637k]
  |  Branch (722:27): [True: 14.9k, False: 622k]
  ------------------
  723|  20.2k|            ++c;
  724|  20.2k|         }
  725|   622k|         else {
  726|   622k|            if (*c == '.') [[unlikely]] {
  ------------------
  |  Branch (726:17): [True: 30, False: 622k]
  ------------------
  727|     30|               return false;
  728|     30|            }
  729|   622k|            return true;
  730|   622k|         }
  731|       |
  732|  20.2k|         c += (*c == '+');
  733|       |
  734|  20.2k|         if (not is_digit(*c)) [[unlikely]] {
  ------------------
  |  Branch (734:14): [True: 225, False: 20.0k]
  ------------------
  735|    225|            return false;
  736|    225|         }
  737|  20.0k|         const uint32_t exp = parse_exponent(c);
  738|       |         // As in the unsigned overload: only a non-zero magnitude can overflow, so "0e19" and
  739|       |         // "-0e19" are in range for every width. `v` is already the signed mantissa, and negative
  740|       |         // zero compares equal to zero, so both spellings land here with the value they should keep.
  741|       |         if constexpr (sizeof(T) == 1) {
  742|       |            if (exp > 2) [[unlikely]] {
  743|       |               return v == 0;
  744|       |            }
  745|       |         }
  746|       |         else if constexpr (sizeof(T) == 2) {
  747|       |            if (exp > 4) [[unlikely]] {
  748|       |               return v == 0;
  749|       |            }
  750|       |         }
  751|  20.0k|         else if constexpr (sizeof(T) == 4) {
  752|  20.0k|            if (exp > 9) [[unlikely]] {
  ------------------
  |  Branch (752:17): [True: 2.02k, False: 18.0k]
  ------------------
  753|  2.02k|               return v == 0;
  754|  2.02k|            }
  755|       |         }
  756|       |         else {
  757|       |            if (exp > 18) [[unlikely]] {
  758|       |               return v == 0;
  759|       |            }
  760|       |         }
  761|       |
  762|  18.0k|         utype i = utype((utype(v) ^ -sign) + sign);
  763|  20.0k|         if constexpr (sizeof(T) < 8) {
  764|       |            // Scale in a width the product cannot wrap, then range check before narrowing. Scaling
  765|       |            // inside `utype` truncated first and checked afterwards, so an out-of-range magnitude
  766|       |            // aliased onto an accepted one: "13e2" read as 20 for int8_t and "5e9" as 705032704 for
  767|       |            // int32_t. The widest case here is a 4-byte magnitude scaled by 10^9, which stays well
  768|       |            // inside uint64_t. The unsigned path already widens the same way.
  769|  20.0k|            const uint64_t scaled = uint64_t(i) * powers_of_ten_int[exp];
  770|  20.0k|            v = T((utype(scaled) ^ -sign) + sign);
  771|       |            // Bound the magnitude directly rather than subtracting the sign from it: a negative
  772|       |            // zero makes `scaled - sign` underflow, and the old narrow expression only survived
  773|       |            // that because it promoted to int. A negative value may reach one past the positive
  774|       |            // limit, which is exactly INT_MIN's magnitude.
  775|  20.0k|            return scaled <= uint64_t((std::numeric_limits<T>::max)()) + sign;
  776|       |         }
  777|       |         else {
  778|       |            // Scale the sign-stripped magnitude `i`, not the two's-complement bit pattern of `v`:
  779|       |            // for a negative value that pattern is a huge unsigned number, so every negative
  780|       |            // 64-bit integer written with an exponent ("-1e2") overflowed and was rejected. The
  781|       |            // narrower branches above already scale `i`.
  782|       |#if defined(__SIZEOF_INT128__)
  783|       |            const __uint128_t res = __uint128_t(i) * powers_of_ten_int[exp];
  784|       |            v = T((uint64_t(res) ^ -sign) + sign);
  785|       |            // Compare the full 128-bit product. Narrowing it to 64 bits first would let an
  786|       |            // out-of-range magnitude alias onto an accepted one, e.g. 9e36 truncating into range.
  787|       |            return res <= __uint128_t(9223372036854775807ull + sign);
  788|       |#else
  789|       |            const auto res = full_multiplication(i, powers_of_ten_int[exp]);
  790|       |            v = T((uint64_t(res.low) ^ -sign) + sign);
  791|       |            return res.high == 0 && (uint64_t(res.low) <= (9223372036854775807ull + sign));
  792|       |#endif
  793|       |         }
  794|  20.0k|      }
  795|  21.8k|      return false;
  796|   644k|   }
_ZN3glz9parse_intITkNSt3__18integralEiQaasr3stdE11is_signed_vIT_ElestS2_Li8EEEPKhRS2_S4_:
  476|   644k|   {
  477|   644k|      const uint8_t sign = *c == '-';
  478|   644k|      c += sign;
  479|       |
  480|   644k|      if (is_digit(*c)) [[likely]] {
  ------------------
  |  Branch (480:11): [True: 642k, False: 1.46k]
  ------------------
  481|   642k|         v = *c - '0';
  482|   642k|         ++c;
  483|   642k|      }
  484|  1.46k|      else [[unlikely]] {
  485|  1.46k|         return {};
  486|  1.46k|      }
  487|       |
  488|   642k|      if (is_digit(*c)) {
  ------------------
  |  Branch (488:11): [True: 538k, False: 104k]
  ------------------
  489|   538k|         v = v * 10 + (*c - '0');
  490|   538k|         ++c;
  491|   538k|      }
  492|   104k|      else {
  493|   104k|         if (sign) {
  ------------------
  |  Branch (493:14): [True: 78.7k, False: 25.6k]
  ------------------
  494|  78.7k|            v = -v;
  495|  78.7k|         }
  496|   104k|         return c;
  497|   104k|      }
  498|       |
  499|   538k|      if (c[-2] == '0') [[unlikely]] {
  ------------------
  |  Branch (499:11): [True: 48, False: 538k]
  ------------------
  500|     48|         return {};
  501|     48|      }
  502|       |
  503|   538k|      if constexpr (sizeof(T) > 1) {
  504|   538k|         if (is_digit(*c)) {
  ------------------
  |  Branch (504:14): [True: 286k, False: 252k]
  ------------------
  505|   286k|            v = v * 10 + (*c - '0');
  506|   286k|            ++c;
  507|   286k|         }
  508|   252k|         else {
  509|   252k|            if (sign) {
  ------------------
  |  Branch (509:17): [True: 241k, False: 10.6k]
  ------------------
  510|   241k|               v = -v;
  511|   241k|            }
  512|   252k|            return c;
  513|   252k|         }
  514|       |
  515|   286k|         if (is_digit(*c)) {
  ------------------
  |  Branch (515:14): [True: 129k, False: 157k]
  ------------------
  516|   129k|            v = v * 10 + (*c - '0');
  517|   129k|            ++c;
  518|   129k|         }
  519|   157k|         else {
  520|   157k|            if (sign) {
  ------------------
  |  Branch (520:17): [True: 149k, False: 7.84k]
  ------------------
  521|   149k|               v = -v;
  522|   149k|            }
  523|   157k|            return c;
  524|   157k|         }
  525|       |
  526|   129k|         if constexpr (sizeof(T) > 2) {
  527|   129k|            if (is_digit(*c)) {
  ------------------
  |  Branch (527:17): [True: 74.1k, False: 54.8k]
  ------------------
  528|  74.1k|               v = v * 10 + (*c - '0');
  529|  74.1k|               ++c;
  530|  74.1k|            }
  531|  54.8k|            else {
  532|  54.8k|               if (sign) {
  ------------------
  |  Branch (532:20): [True: 3.81k, False: 51.0k]
  ------------------
  533|  3.81k|                  v = -v;
  534|  3.81k|               }
  535|  54.8k|               return c;
  536|  54.8k|            }
  537|       |
  538|  74.1k|            if (is_digit(*c)) {
  ------------------
  |  Branch (538:17): [True: 63.5k, False: 10.5k]
  ------------------
  539|  63.5k|               v = v * 10 + (*c - '0');
  540|  63.5k|               ++c;
  541|  63.5k|            }
  542|  10.5k|            else {
  543|  10.5k|               if (sign) {
  ------------------
  |  Branch (543:20): [True: 3.17k, False: 7.40k]
  ------------------
  544|  3.17k|                  v = -v;
  545|  3.17k|               }
  546|  10.5k|               return c;
  547|  10.5k|            }
  548|       |
  549|  63.5k|            if (is_digit(*c)) {
  ------------------
  |  Branch (549:17): [True: 28.2k, False: 35.3k]
  ------------------
  550|  28.2k|               v = v * 10 + (*c - '0');
  551|  28.2k|               ++c;
  552|  28.2k|            }
  553|  35.3k|            else {
  554|  35.3k|               if (sign) {
  ------------------
  |  Branch (554:20): [True: 7.34k, False: 27.9k]
  ------------------
  555|  7.34k|                  v = -v;
  556|  7.34k|               }
  557|  35.3k|               return c;
  558|  35.3k|            }
  559|       |
  560|  28.2k|            if (is_digit(*c)) {
  ------------------
  |  Branch (560:17): [True: 17.5k, False: 10.7k]
  ------------------
  561|  17.5k|               v = v * 10 + (*c - '0');
  562|  17.5k|               ++c;
  563|  17.5k|            }
  564|  10.7k|            else {
  565|  10.7k|               if (sign) {
  ------------------
  |  Branch (565:20): [True: 2.35k, False: 8.35k]
  ------------------
  566|  2.35k|                  v = -v;
  567|  2.35k|               }
  568|  10.7k|               return c;
  569|  10.7k|            }
  570|       |
  571|  17.5k|            if (is_digit(*c)) {
  ------------------
  |  Branch (571:17): [True: 8.60k, False: 8.93k]
  ------------------
  572|  8.60k|               v = v * 10 + (*c - '0');
  573|  8.60k|               ++c;
  574|  8.60k|            }
  575|  8.93k|            else {
  576|  8.93k|               if (sign) {
  ------------------
  |  Branch (576:20): [True: 3.37k, False: 5.55k]
  ------------------
  577|  3.37k|                  v = -v;
  578|  3.37k|               }
  579|  8.93k|               return c;
  580|  8.93k|            }
  581|       |
  582|       |            if constexpr (sizeof(T) > 4) {
  583|       |               if (is_digit(*c)) {
  584|       |                  v = v * 10 + (*c - '0');
  585|       |                  ++c;
  586|       |               }
  587|       |               else {
  588|       |                  if (sign) {
  589|       |                     v = -v;
  590|       |                  }
  591|       |                  return c;
  592|       |               }
  593|       |
  594|       |               if (is_digit(*c)) {
  595|       |                  v = v * 10 + (*c - '0');
  596|       |                  ++c;
  597|       |               }
  598|       |               else {
  599|       |                  if (sign) {
  600|       |                     v = -v;
  601|       |                  }
  602|       |                  return c;
  603|       |               }
  604|       |
  605|       |               if (is_digit(*c)) {
  606|       |                  v = v * 10 + (*c - '0');
  607|       |                  ++c;
  608|       |               }
  609|       |               else {
  610|       |                  if (sign) {
  611|       |                     v = -v;
  612|       |                  }
  613|       |                  return c;
  614|       |               }
  615|       |
  616|       |               if (is_digit(*c)) {
  617|       |                  v = v * 10 + (*c - '0');
  618|       |                  ++c;
  619|       |               }
  620|       |               else {
  621|       |                  if (sign) {
  622|       |                     v = -v;
  623|       |                  }
  624|       |                  return c;
  625|       |               }
  626|       |
  627|       |               if (is_digit(*c)) {
  628|       |                  v = v * 10 + (*c - '0');
  629|       |                  ++c;
  630|       |               }
  631|       |               else {
  632|       |                  if (sign) {
  633|       |                     v = -v;
  634|       |                  }
  635|       |                  return c;
  636|       |               }
  637|       |
  638|       |               if (is_digit(*c)) {
  639|       |                  v = v * 10 + (*c - '0');
  640|       |                  ++c;
  641|       |               }
  642|       |               else {
  643|       |                  if (sign) {
  644|       |                     v = -v;
  645|       |                  }
  646|       |                  return c;
  647|       |               }
  648|       |
  649|       |               if (is_digit(*c)) {
  650|       |                  v = v * 10 + (*c - '0');
  651|       |                  ++c;
  652|       |               }
  653|       |               else {
  654|       |                  if (sign) {
  655|       |                     v = -v;
  656|       |                  }
  657|       |                  return c;
  658|       |               }
  659|       |
  660|       |               if (is_digit(*c)) {
  661|       |                  v = v * 10 + (*c - '0');
  662|       |                  ++c;
  663|       |               }
  664|       |               else {
  665|       |                  if (sign) {
  666|       |                     v = -v;
  667|       |                  }
  668|       |                  return c;
  669|       |               }
  670|       |
  671|       |               if (is_digit(*c)) {
  672|       |                  v = v * 10 + (*c - '0');
  673|       |                  ++c;
  674|       |               }
  675|       |               else {
  676|       |                  if (sign) {
  677|       |                     v = -v;
  678|       |                  }
  679|       |                  return c;
  680|       |               }
  681|       |            }
  682|  8.60k|         }
  683|   129k|      }
  684|       |
  685|   538k|      if (is_digit(*c)) {
  ------------------
  |  Branch (685:11): [True: 3.63k, False: 534k]
  ------------------
  686|  3.63k|         if (sign) {
  ------------------
  |  Branch (686:14): [True: 1.70k, False: 1.92k]
  ------------------
  687|  1.70k|            if (would_overflow_negative<T>(v, *c)) [[unlikely]] {
  ------------------
  |  Branch (687:17): [True: 94, False: 1.61k]
  ------------------
  688|     94|               return {};
  689|     94|            }
  690|  1.61k|            v = -1 * v;
  691|  1.61k|            v = v * 10 - (*c - '0');
  692|  1.61k|         }
  693|  1.92k|         else {
  694|  1.92k|            if (would_overflow_positive<T>(v, *c)) [[unlikely]] {
  ------------------
  |  Branch (694:17): [True: 83, False: 1.84k]
  ------------------
  695|     83|               return {};
  696|     83|            }
  697|  1.84k|            v = v * 10 + (*c - '0');
  698|  1.84k|         }
  699|  3.45k|         ++c;
  700|  3.45k|         if (is_digit(*c)) [[unlikely]] {
  ------------------
  |  Branch (700:14): [True: 80, False: 3.37k]
  ------------------
  701|     80|            return {};
  702|     80|         }
  703|  3.37k|         return c;
  704|  3.45k|      }
  705|       |
  706|   534k|      if (sign) {
  ------------------
  |  Branch (706:11): [True: 1.45k, False: 533k]
  ------------------
  707|  1.45k|         v = -v;
  708|  1.45k|      }
  709|   534k|      return c;
  710|   538k|   }
_ZN3glz23would_overflow_negativeIiEEbu17__remove_volatileIT_Eh:
  151|  1.70k|   {
  152|       |      // For negative: max magnitude is max + 1 (e.g., -2147483648 for int32)
  153|  1.70k|      using U = std::remove_volatile_t<T>;
  154|  1.70k|      constexpr auto max_val = static_cast<uint64_t>((std::numeric_limits<U>::max)()) + 1;
  155|  1.70k|      constexpr auto threshold = max_val / 10;
  156|  1.70k|      constexpr auto last_digit = max_val % 10;
  157|  1.70k|      const auto uv = static_cast<uint64_t>(v);
  158|  1.70k|      const auto digit = static_cast<uint64_t>(next_digit - '0');
  159|       |      // When digit > last_digit, effective threshold is one less
  160|  1.70k|      return uv > (threshold - uint64_t(digit > last_digit));
  161|  1.70k|   }
_ZN3glz23would_overflow_positiveIiEEbu17__remove_volatileIT_Eh:
  137|  1.92k|   {
  138|  1.92k|      using U = std::remove_volatile_t<T>;
  139|  1.92k|      constexpr auto max_val = static_cast<uint64_t>((std::numeric_limits<U>::max)());
  140|  1.92k|      constexpr auto threshold = max_val / 10;
  141|  1.92k|      constexpr auto last_digit = max_val % 10;
  142|  1.92k|      const auto uv = static_cast<uint64_t>(v);
  143|  1.92k|      const auto digit = static_cast<uint64_t>(next_digit - '0');
  144|       |      // When digit > last_digit, effective threshold is one less
  145|       |      // This is branch-free and faster than bitwise OR/AND approach
  146|  1.92k|      return uv > (threshold - uint64_t(digit > last_digit));
  147|  1.92k|   }
_ZN3glz8is_digitEh:
  103|  11.0M|   GLZ_ALWAYS_INLINE constexpr bool is_digit(const uint8_t c) noexcept { return c <= '9' && c >= '0'; }
  ------------------
  |  Branch (103:81): [True: 10.6M, False: 427k]
  |  Branch (103:93): [True: 5.07M, False: 5.54M]
  ------------------
_ZN3glz14parse_exponentIKcEEjRPT_:
  121|  26.4k|   {
  122|  26.4k|      uint32_t exp = uint32_t(*c - '0');
  123|  26.4k|      ++c;
  124|  79.4k|      while (is_digit(*c)) {
  ------------------
  |  Branch (124:14): [True: 52.9k, False: 26.4k]
  ------------------
  125|       |         // Written as a select rather than a branch: the clamp only ever engages on absurdly long
  126|       |         // exponents, so a branch here would be a mispredict risk on the path that matters.
  127|  52.9k|         exp = exp < exponent_clamp ? exp * 10 + uint32_t(*c - '0') : exp;
  ------------------
  |  Branch (127:16): [True: 47.9k, False: 5.05k]
  ------------------
  128|  52.9k|         ++c;
  129|  52.9k|      }
  130|  26.4k|      return exp;
  131|  26.4k|   }
_ZN3glz4atoiITkNSt3__18integralElcEEbRT_RPKT0_S6_:
  803|  86.1k|   {
  804|       |      // The number of characters needed at most for each type, rounded to nearest 8 bytes
  805|  86.1k|      constexpr auto buffer_length = int_buffer_lengths[std::bit_width(sizeof(T)) - 1];
  806|       |      // We copy the rest of the buffer, or buffer_length bytes, into a null terminated buffer. The
  807|       |      // trailing byte is never written by the copy, so the null-terminated atoi below always halts
  808|       |      // inside the array even when the input fills it: the exponent scan stops at a non-digit rather
  809|       |      // than after a fixed digit count, and a value-initialized array alone would not terminate a
  810|       |      // copy that covers every byte.
  811|  86.1k|      std::array<char, buffer_length + 1> data{};
  812|  86.1k|      const auto n = size_t(end - it);
  813|  86.1k|      if (n > 0) [[likely]] {
  ------------------
  |  Branch (813:11): [True: 86.1k, False: 0]
  ------------------
  814|  86.1k|         const auto truncated = n > buffer_length;
  815|  86.1k|         std::memcpy(data.data(), it, truncated ? buffer_length : n);
  ------------------
  |  Branch (815:39): [True: 18.9k, False: 67.2k]
  ------------------
  816|       |
  817|  86.1k|         const auto start = data.data();
  818|  86.1k|         const auto* c = start;
  819|  86.1k|         const auto valid = glz::atoi(v, c);
  820|  86.1k|         const auto consumed = size_t(c - start);
  821|  86.1k|         it += consumed;
  822|       |         // Reaching the end of a truncated copy means the number was cut off: parsing halted on the
  823|       |         // terminator this buffer supplies rather than on a character of the input, so what parsed is
  824|       |         // a prefix and its value is not the number's. Only zero padding can stretch a number this
  825|       |         // far -- no in-range integer needs buffer_length characters -- but a caller that ignores
  826|       |         // trailing content would otherwise take the prefix's value as the answer.
  827|  86.1k|         return valid && not(truncated && consumed == buffer_length);
  ------------------
  |  Branch (827:17): [True: 54.9k, False: 31.1k]
  |  Branch (827:30): [True: 15.4k, False: 39.5k]
  |  Branch (827:43): [True: 74, False: 15.3k]
  ------------------
  828|  86.1k|      }
  829|      0|      else [[unlikely]] {
  830|      0|         return false;
  831|      0|      }
  832|  86.1k|   }
_ZN3glz4atoiITkNSt3__18integralElKcQsr3stdE11is_signed_vIT_EEEbRS3_RPT0_:
  715|  86.1k|   {
  716|  86.1k|      using X = std::decay_t<T>;
  717|  86.1k|      using utype = std::make_unsigned_t<X>;
  718|       |
  719|  86.1k|      const uint8_t sign = *c == '-';
  720|  86.1k|      if (auto ptr = parse_int(v, reinterpret_cast<const uint8_t*>(c))) [[likely]] {
  ------------------
  |  Branch (720:16): [True: 76.5k, False: 9.53k]
  ------------------
  721|  76.5k|         c = reinterpret_cast<const Char*>(ptr);
  722|  76.5k|         if (*c == 'e' || *c == 'E') {
  ------------------
  |  Branch (722:14): [True: 1.78k, False: 74.8k]
  |  Branch (722:27): [True: 8.07k, False: 66.7k]
  ------------------
  723|  9.86k|            ++c;
  724|  9.86k|         }
  725|  66.7k|         else {
  726|  66.7k|            if (*c == '.') [[unlikely]] {
  ------------------
  |  Branch (726:17): [True: 14.5k, False: 52.1k]
  ------------------
  727|  14.5k|               return false;
  728|  14.5k|            }
  729|  52.1k|            return true;
  730|  66.7k|         }
  731|       |
  732|  9.86k|         c += (*c == '+');
  733|       |
  734|  9.86k|         if (not is_digit(*c)) [[unlikely]] {
  ------------------
  |  Branch (734:14): [True: 3.44k, False: 6.41k]
  ------------------
  735|  3.44k|            return false;
  736|  3.44k|         }
  737|  6.41k|         const uint32_t exp = parse_exponent(c);
  738|       |         // As in the unsigned overload: only a non-zero magnitude can overflow, so "0e19" and
  739|       |         // "-0e19" are in range for every width. `v` is already the signed mantissa, and negative
  740|       |         // zero compares equal to zero, so both spellings land here with the value they should keep.
  741|       |         if constexpr (sizeof(T) == 1) {
  742|       |            if (exp > 2) [[unlikely]] {
  743|       |               return v == 0;
  744|       |            }
  745|       |         }
  746|       |         else if constexpr (sizeof(T) == 2) {
  747|       |            if (exp > 4) [[unlikely]] {
  748|       |               return v == 0;
  749|       |            }
  750|       |         }
  751|       |         else if constexpr (sizeof(T) == 4) {
  752|       |            if (exp > 9) [[unlikely]] {
  753|       |               return v == 0;
  754|       |            }
  755|       |         }
  756|  6.41k|         else {
  757|  6.41k|            if (exp > 18) [[unlikely]] {
  ------------------
  |  Branch (757:17): [True: 3.42k, False: 2.98k]
  ------------------
  758|  3.42k|               return v == 0;
  759|  3.42k|            }
  760|  6.41k|         }
  761|       |
  762|  2.98k|         utype i = utype((utype(v) ^ -sign) + sign);
  763|       |         if constexpr (sizeof(T) < 8) {
  764|       |            // Scale in a width the product cannot wrap, then range check before narrowing. Scaling
  765|       |            // inside `utype` truncated first and checked afterwards, so an out-of-range magnitude
  766|       |            // aliased onto an accepted one: "13e2" read as 20 for int8_t and "5e9" as 705032704 for
  767|       |            // int32_t. The widest case here is a 4-byte magnitude scaled by 10^9, which stays well
  768|       |            // inside uint64_t. The unsigned path already widens the same way.
  769|       |            const uint64_t scaled = uint64_t(i) * powers_of_ten_int[exp];
  770|       |            v = T((utype(scaled) ^ -sign) + sign);
  771|       |            // Bound the magnitude directly rather than subtracting the sign from it: a negative
  772|       |            // zero makes `scaled - sign` underflow, and the old narrow expression only survived
  773|       |            // that because it promoted to int. A negative value may reach one past the positive
  774|       |            // limit, which is exactly INT_MIN's magnitude.
  775|       |            return scaled <= uint64_t((std::numeric_limits<T>::max)()) + sign;
  776|       |         }
  777|  6.41k|         else {
  778|       |            // Scale the sign-stripped magnitude `i`, not the two's-complement bit pattern of `v`:
  779|       |            // for a negative value that pattern is a huge unsigned number, so every negative
  780|       |            // 64-bit integer written with an exponent ("-1e2") overflowed and was rejected. The
  781|       |            // narrower branches above already scale `i`.
  782|  6.41k|#if defined(__SIZEOF_INT128__)
  783|  6.41k|            const __uint128_t res = __uint128_t(i) * powers_of_ten_int[exp];
  784|  6.41k|            v = T((uint64_t(res) ^ -sign) + sign);
  785|       |            // Compare the full 128-bit product. Narrowing it to 64 bits first would let an
  786|       |            // out-of-range magnitude alias onto an accepted one, e.g. 9e36 truncating into range.
  787|  6.41k|            return res <= __uint128_t(9223372036854775807ull + sign);
  788|       |#else
  789|       |            const auto res = full_multiplication(i, powers_of_ten_int[exp]);
  790|       |            v = T((uint64_t(res.low) ^ -sign) + sign);
  791|       |            return res.high == 0 && (uint64_t(res.low) <= (9223372036854775807ull + sign));
  792|       |#endif
  793|  6.41k|         }
  794|  6.41k|      }
  795|  15.9k|      return false;
  796|  86.1k|   }
_ZN3glz9parse_intITkNSt3__18integralElQaasr3stdE11is_signed_vIT_ElestS2_Li8EEEPKhRS2_S4_:
  476|  86.1k|   {
  477|  86.1k|      const uint8_t sign = *c == '-';
  478|  86.1k|      c += sign;
  479|       |
  480|  86.1k|      if (is_digit(*c)) [[likely]] {
  ------------------
  |  Branch (480:11): [True: 84.6k, False: 1.51k]
  ------------------
  481|  84.6k|         v = *c - '0';
  482|  84.6k|         ++c;
  483|  84.6k|      }
  484|  1.51k|      else [[unlikely]] {
  485|  1.51k|         return {};
  486|  1.51k|      }
  487|       |
  488|  84.6k|      if (is_digit(*c)) {
  ------------------
  |  Branch (488:11): [True: 55.2k, False: 29.3k]
  ------------------
  489|  55.2k|         v = v * 10 + (*c - '0');
  490|  55.2k|         ++c;
  491|  55.2k|      }
  492|  29.3k|      else {
  493|  29.3k|         if (sign) {
  ------------------
  |  Branch (493:14): [True: 1.71k, False: 27.6k]
  ------------------
  494|  1.71k|            v = -v;
  495|  1.71k|         }
  496|  29.3k|         return c;
  497|  29.3k|      }
  498|       |
  499|  55.2k|      if (c[-2] == '0') [[unlikely]] {
  ------------------
  |  Branch (499:11): [True: 521, False: 54.7k]
  ------------------
  500|    521|         return {};
  501|    521|      }
  502|       |
  503|  54.7k|      if constexpr (sizeof(T) > 1) {
  504|  54.7k|         if (is_digit(*c)) {
  ------------------
  |  Branch (504:14): [True: 52.5k, False: 2.14k]
  ------------------
  505|  52.5k|            v = v * 10 + (*c - '0');
  506|  52.5k|            ++c;
  507|  52.5k|         }
  508|  2.14k|         else {
  509|  2.14k|            if (sign) {
  ------------------
  |  Branch (509:17): [True: 811, False: 1.33k]
  ------------------
  510|    811|               v = -v;
  511|    811|            }
  512|  2.14k|            return c;
  513|  2.14k|         }
  514|       |
  515|  52.5k|         if (is_digit(*c)) {
  ------------------
  |  Branch (515:14): [True: 50.9k, False: 1.59k]
  ------------------
  516|  50.9k|            v = v * 10 + (*c - '0');
  517|  50.9k|            ++c;
  518|  50.9k|         }
  519|  1.59k|         else {
  520|  1.59k|            if (sign) {
  ------------------
  |  Branch (520:17): [True: 663, False: 931]
  ------------------
  521|    663|               v = -v;
  522|    663|            }
  523|  1.59k|            return c;
  524|  1.59k|         }
  525|       |
  526|  50.9k|         if constexpr (sizeof(T) > 2) {
  527|  50.9k|            if (is_digit(*c)) {
  ------------------
  |  Branch (527:17): [True: 48.2k, False: 2.68k]
  ------------------
  528|  48.2k|               v = v * 10 + (*c - '0');
  529|  48.2k|               ++c;
  530|  48.2k|            }
  531|  2.68k|            else {
  532|  2.68k|               if (sign) {
  ------------------
  |  Branch (532:20): [True: 1.51k, False: 1.17k]
  ------------------
  533|  1.51k|                  v = -v;
  534|  1.51k|               }
  535|  2.68k|               return c;
  536|  2.68k|            }
  537|       |
  538|  48.2k|            if (is_digit(*c)) {
  ------------------
  |  Branch (538:17): [True: 45.2k, False: 3.00k]
  ------------------
  539|  45.2k|               v = v * 10 + (*c - '0');
  540|  45.2k|               ++c;
  541|  45.2k|            }
  542|  3.00k|            else {
  543|  3.00k|               if (sign) {
  ------------------
  |  Branch (543:20): [True: 1.72k, False: 1.28k]
  ------------------
  544|  1.72k|                  v = -v;
  545|  1.72k|               }
  546|  3.00k|               return c;
  547|  3.00k|            }
  548|       |
  549|  45.2k|            if (is_digit(*c)) {
  ------------------
  |  Branch (549:17): [True: 43.4k, False: 1.84k]
  ------------------
  550|  43.4k|               v = v * 10 + (*c - '0');
  551|  43.4k|               ++c;
  552|  43.4k|            }
  553|  1.84k|            else {
  554|  1.84k|               if (sign) {
  ------------------
  |  Branch (554:20): [True: 854, False: 993]
  ------------------
  555|    854|                  v = -v;
  556|    854|               }
  557|  1.84k|               return c;
  558|  1.84k|            }
  559|       |
  560|  43.4k|            if (is_digit(*c)) {
  ------------------
  |  Branch (560:17): [True: 41.9k, False: 1.48k]
  ------------------
  561|  41.9k|               v = v * 10 + (*c - '0');
  562|  41.9k|               ++c;
  563|  41.9k|            }
  564|  1.48k|            else {
  565|  1.48k|               if (sign) {
  ------------------
  |  Branch (565:20): [True: 849, False: 639]
  ------------------
  566|    849|                  v = -v;
  567|    849|               }
  568|  1.48k|               return c;
  569|  1.48k|            }
  570|       |
  571|  41.9k|            if (is_digit(*c)) {
  ------------------
  |  Branch (571:17): [True: 40.4k, False: 1.51k]
  ------------------
  572|  40.4k|               v = v * 10 + (*c - '0');
  573|  40.4k|               ++c;
  574|  40.4k|            }
  575|  1.51k|            else {
  576|  1.51k|               if (sign) {
  ------------------
  |  Branch (576:20): [True: 929, False: 584]
  ------------------
  577|    929|                  v = -v;
  578|    929|               }
  579|  1.51k|               return c;
  580|  1.51k|            }
  581|       |
  582|  40.4k|            if constexpr (sizeof(T) > 4) {
  583|  40.4k|               if (is_digit(*c)) {
  ------------------
  |  Branch (583:20): [True: 38.7k, False: 1.66k]
  ------------------
  584|  38.7k|                  v = v * 10 + (*c - '0');
  585|  38.7k|                  ++c;
  586|  38.7k|               }
  587|  1.66k|               else {
  588|  1.66k|                  if (sign) {
  ------------------
  |  Branch (588:23): [True: 634, False: 1.02k]
  ------------------
  589|    634|                     v = -v;
  590|    634|                  }
  591|  1.66k|                  return c;
  592|  1.66k|               }
  593|       |
  594|  38.7k|               if (is_digit(*c)) {
  ------------------
  |  Branch (594:20): [True: 37.1k, False: 1.64k]
  ------------------
  595|  37.1k|                  v = v * 10 + (*c - '0');
  596|  37.1k|                  ++c;
  597|  37.1k|               }
  598|  1.64k|               else {
  599|  1.64k|                  if (sign) {
  ------------------
  |  Branch (599:23): [True: 766, False: 876]
  ------------------
  600|    766|                     v = -v;
  601|    766|                  }
  602|  1.64k|                  return c;
  603|  1.64k|               }
  604|       |
  605|  37.1k|               if (is_digit(*c)) {
  ------------------
  |  Branch (605:20): [True: 25.3k, False: 11.7k]
  ------------------
  606|  25.3k|                  v = v * 10 + (*c - '0');
  607|  25.3k|                  ++c;
  608|  25.3k|               }
  609|  11.7k|               else {
  610|  11.7k|                  if (sign) {
  ------------------
  |  Branch (610:23): [True: 670, False: 11.0k]
  ------------------
  611|    670|                     v = -v;
  612|    670|                  }
  613|  11.7k|                  return c;
  614|  11.7k|               }
  615|       |
  616|  25.3k|               if (is_digit(*c)) {
  ------------------
  |  Branch (616:20): [True: 24.3k, False: 1.00k]
  ------------------
  617|  24.3k|                  v = v * 10 + (*c - '0');
  618|  24.3k|                  ++c;
  619|  24.3k|               }
  620|  1.00k|               else {
  621|  1.00k|                  if (sign) {
  ------------------
  |  Branch (621:23): [True: 552, False: 454]
  ------------------
  622|    552|                     v = -v;
  623|    552|                  }
  624|  1.00k|                  return c;
  625|  1.00k|               }
  626|       |
  627|  24.3k|               if (is_digit(*c)) {
  ------------------
  |  Branch (627:20): [True: 21.8k, False: 2.55k]
  ------------------
  628|  21.8k|                  v = v * 10 + (*c - '0');
  629|  21.8k|                  ++c;
  630|  21.8k|               }
  631|  2.55k|               else {
  632|  2.55k|                  if (sign) {
  ------------------
  |  Branch (632:23): [True: 456, False: 2.10k]
  ------------------
  633|    456|                     v = -v;
  634|    456|                  }
  635|  2.55k|                  return c;
  636|  2.55k|               }
  637|       |
  638|  21.8k|               if (is_digit(*c)) {
  ------------------
  |  Branch (638:20): [True: 20.6k, False: 1.13k]
  ------------------
  639|  20.6k|                  v = v * 10 + (*c - '0');
  640|  20.6k|                  ++c;
  641|  20.6k|               }
  642|  1.13k|               else {
  643|  1.13k|                  if (sign) {
  ------------------
  |  Branch (643:23): [True: 625, False: 513]
  ------------------
  644|    625|                     v = -v;
  645|    625|                  }
  646|  1.13k|                  return c;
  647|  1.13k|               }
  648|       |
  649|  20.6k|               if (is_digit(*c)) {
  ------------------
  |  Branch (649:20): [True: 19.7k, False: 912]
  ------------------
  650|  19.7k|                  v = v * 10 + (*c - '0');
  651|  19.7k|                  ++c;
  652|  19.7k|               }
  653|    912|               else {
  654|    912|                  if (sign) {
  ------------------
  |  Branch (654:23): [True: 519, False: 393]
  ------------------
  655|    519|                     v = -v;
  656|    519|                  }
  657|    912|                  return c;
  658|    912|               }
  659|       |
  660|  19.7k|               if (is_digit(*c)) {
  ------------------
  |  Branch (660:20): [True: 17.7k, False: 1.98k]
  ------------------
  661|  17.7k|                  v = v * 10 + (*c - '0');
  662|  17.7k|                  ++c;
  663|  17.7k|               }
  664|  1.98k|               else {
  665|  1.98k|                  if (sign) {
  ------------------
  |  Branch (665:23): [True: 601, False: 1.38k]
  ------------------
  666|    601|                     v = -v;
  667|    601|                  }
  668|  1.98k|                  return c;
  669|  1.98k|               }
  670|       |
  671|  17.7k|               if (is_digit(*c)) {
  ------------------
  |  Branch (671:20): [True: 9.33k, False: 8.43k]
  ------------------
  672|  9.33k|                  v = v * 10 + (*c - '0');
  673|  9.33k|                  ++c;
  674|  9.33k|               }
  675|  8.43k|               else {
  676|  8.43k|                  if (sign) {
  ------------------
  |  Branch (676:23): [True: 7.65k, False: 778]
  ------------------
  677|  7.65k|                     v = -v;
  678|  7.65k|                  }
  679|  8.43k|                  return c;
  680|  8.43k|               }
  681|  17.7k|            }
  682|  40.4k|         }
  683|  50.9k|      }
  684|       |
  685|  54.7k|      if (is_digit(*c)) {
  ------------------
  |  Branch (685:11): [True: 8.39k, False: 46.3k]
  ------------------
  686|  8.39k|         if (sign) {
  ------------------
  |  Branch (686:14): [True: 7.21k, False: 1.18k]
  ------------------
  687|  7.21k|            if (would_overflow_negative<T>(v, *c)) [[unlikely]] {
  ------------------
  |  Branch (687:17): [True: 6.48k, False: 732]
  ------------------
  688|  6.48k|               return {};
  689|  6.48k|            }
  690|    732|            v = -1 * v;
  691|    732|            v = v * 10 - (*c - '0');
  692|    732|         }
  693|  1.18k|         else {
  694|  1.18k|            if (would_overflow_positive<T>(v, *c)) [[unlikely]] {
  ------------------
  |  Branch (694:17): [True: 359, False: 827]
  ------------------
  695|    359|               return {};
  696|    359|            }
  697|    827|            v = v * 10 + (*c - '0');
  698|    827|         }
  699|  1.55k|         ++c;
  700|  1.55k|         if (is_digit(*c)) [[unlikely]] {
  ------------------
  |  Branch (700:14): [True: 662, False: 897]
  ------------------
  701|    662|            return {};
  702|    662|         }
  703|    897|         return c;
  704|  1.55k|      }
  705|       |
  706|  46.3k|      if (sign) {
  ------------------
  |  Branch (706:11): [True: 601, False: 45.7k]
  ------------------
  707|    601|         v = -v;
  708|    601|      }
  709|  46.3k|      return c;
  710|  54.7k|   }
_ZN3glz23would_overflow_negativeIlEEbu17__remove_volatileIT_Eh:
  151|  7.21k|   {
  152|       |      // For negative: max magnitude is max + 1 (e.g., -2147483648 for int32)
  153|  7.21k|      using U = std::remove_volatile_t<T>;
  154|  7.21k|      constexpr auto max_val = static_cast<uint64_t>((std::numeric_limits<U>::max)()) + 1;
  155|  7.21k|      constexpr auto threshold = max_val / 10;
  156|  7.21k|      constexpr auto last_digit = max_val % 10;
  157|  7.21k|      const auto uv = static_cast<uint64_t>(v);
  158|  7.21k|      const auto digit = static_cast<uint64_t>(next_digit - '0');
  159|       |      // When digit > last_digit, effective threshold is one less
  160|  7.21k|      return uv > (threshold - uint64_t(digit > last_digit));
  161|  7.21k|   }
_ZN3glz23would_overflow_positiveIlEEbu17__remove_volatileIT_Eh:
  137|  1.18k|   {
  138|  1.18k|      using U = std::remove_volatile_t<T>;
  139|  1.18k|      constexpr auto max_val = static_cast<uint64_t>((std::numeric_limits<U>::max)());
  140|  1.18k|      constexpr auto threshold = max_val / 10;
  141|  1.18k|      constexpr auto last_digit = max_val % 10;
  142|  1.18k|      const auto uv = static_cast<uint64_t>(v);
  143|  1.18k|      const auto digit = static_cast<uint64_t>(next_digit - '0');
  144|       |      // When digit > last_digit, effective threshold is one less
  145|       |      // This is branch-free and faster than bitwise OR/AND approach
  146|  1.18k|      return uv > (threshold - uint64_t(digit > last_digit));
  147|  1.18k|   }

_ZN3glz11countr_zeroEm:
   29|  8.82M|   {
   30|       |#ifdef _MSC_VER
   31|       |      return std::countr_zero(x);
   32|       |#else
   33|  8.82M|#if __has_builtin(__builtin_ctzll)
   34|  8.82M|      return __builtin_ctzll(x);
   35|       |#else
   36|       |      return std::countr_zero(x);
   37|       |#endif
   38|  8.82M|#endif
   39|  8.82M|   }
_ZN3glz11countr_zeroEj:
   16|  42.1M|   {
   17|       |#ifdef _MSC_VER
   18|       |      return std::countr_zero(x);
   19|       |#else
   20|  42.1M|#if __has_builtin(__builtin_ctzl)
   21|  42.1M|      return __builtin_ctzl(x);
   22|       |#else
   23|       |      return std::countr_zero(x);
   24|       |#endif
   25|  42.1M|#endif
   26|  42.1M|   }

_ZN3glz10comparitorIL_ZZNS_12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz5pointELm0ERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT2_OT4_OT5_OT6_DpOT3_E15KeyWithEndQuoteELm2EcEEbPKT1_:
  245|  5.72k|   {
  246|       |      // pack() builds values in little-endian order (byte 0 in LSB position).
  247|       |      // On big-endian systems, memcpy produces native (big-endian) values,
  248|       |      // so we need to byteswap to match the packed representation.
  249|       |      if constexpr (N == 8) {
  250|       |         static constexpr auto packed = pack<Str, 8>();
  251|       |         uint64_t in;
  252|       |         std::memcpy(&in, other, 8);
  253|       |         if constexpr (std::endian::native == std::endian::big) {
  254|       |            in = std::byteswap(in);
  255|       |         }
  256|       |         return (in == packed);
  257|       |      }
  258|       |      else if constexpr (N == 7) {
  259|       |         static constexpr auto packed = pack_buffered<Str, 8>();
  260|       |         uint64_t in{};
  261|       |         std::memcpy(&in, other, 7);
  262|       |         if constexpr (std::endian::native == std::endian::big) {
  263|       |            in = std::byteswap(in);
  264|       |         }
  265|       |         return (in == packed);
  266|       |      }
  267|       |      else if constexpr (N == 6) {
  268|       |         static constexpr auto packed = pack_buffered<Str, 8>();
  269|       |         uint64_t in{};
  270|       |         std::memcpy(&in, other, 6);
  271|       |         if constexpr (std::endian::native == std::endian::big) {
  272|       |            in = std::byteswap(in);
  273|       |         }
  274|       |         return (in == packed);
  275|       |      }
  276|       |      else if constexpr (N == 5) {
  277|       |         static constexpr auto packed = pack<Str, 4>();
  278|       |         uint32_t in;
  279|       |         std::memcpy(&in, other, 4);
  280|       |         if constexpr (std::endian::native == std::endian::big) {
  281|       |            in = std::byteswap(in);
  282|       |         }
  283|       |         return (in == packed) & (Str[4] == other[4]);
  284|       |      }
  285|       |      else if constexpr (N == 4) {
  286|       |         static constexpr auto packed = pack<Str, 4>();
  287|       |         uint32_t in;
  288|       |         std::memcpy(&in, other, 4);
  289|       |         if constexpr (std::endian::native == std::endian::big) {
  290|       |            in = std::byteswap(in);
  291|       |         }
  292|       |         return (in == packed);
  293|       |      }
  294|       |      else if constexpr (N == 3) {
  295|       |         static constexpr auto packed = pack<Str, 2>();
  296|       |         uint16_t in;
  297|       |         std::memcpy(&in, other, 2);
  298|       |         if constexpr (std::endian::native == std::endian::big) {
  299|       |            in = std::byteswap(in);
  300|       |         }
  301|       |         return (in == packed) & (Str[2] == other[2]);
  302|       |      }
  303|  5.72k|      else if constexpr (N == 2) {
  304|  5.72k|         static constexpr auto packed = pack<Str, 2>();
  305|  5.72k|         uint16_t in;
  306|  5.72k|         std::memcpy(&in, other, 2);
  307|       |         if constexpr (std::endian::native == std::endian::big) {
  308|       |            in = std::byteswap(in);
  309|       |         }
  310|  5.72k|         return (in == packed);
  311|       |      }
  312|       |      else if constexpr (N == 1) {
  313|       |         return Str[0] == other[0];
  314|       |      }
  315|       |      else if constexpr (N == 0) {
  316|       |         return true;
  317|       |      }
  318|       |      else {
  319|       |         // Clang and GCC optimize this extremely well for constexpr std::string_view
  320|       |         // Packing data can create more binary on GCC
  321|       |         // The other cases probably aren't needed as compiler explorer shows them optimized equally well as memcmp
  322|       |         return 0 == std::memcmp(Str.data(), other, N);
  323|       |      }
  324|  5.72k|   }
_ZN3glz10comparitorIL_ZZNS_12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz5pointELm1ERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT2_OT4_OT5_OT6_DpOT3_E15KeyWithEndQuoteELm2EcEEbPKT1_:
  245|  1.63k|   {
  246|       |      // pack() builds values in little-endian order (byte 0 in LSB position).
  247|       |      // On big-endian systems, memcpy produces native (big-endian) values,
  248|       |      // so we need to byteswap to match the packed representation.
  249|       |      if constexpr (N == 8) {
  250|       |         static constexpr auto packed = pack<Str, 8>();
  251|       |         uint64_t in;
  252|       |         std::memcpy(&in, other, 8);
  253|       |         if constexpr (std::endian::native == std::endian::big) {
  254|       |            in = std::byteswap(in);
  255|       |         }
  256|       |         return (in == packed);
  257|       |      }
  258|       |      else if constexpr (N == 7) {
  259|       |         static constexpr auto packed = pack_buffered<Str, 8>();
  260|       |         uint64_t in{};
  261|       |         std::memcpy(&in, other, 7);
  262|       |         if constexpr (std::endian::native == std::endian::big) {
  263|       |            in = std::byteswap(in);
  264|       |         }
  265|       |         return (in == packed);
  266|       |      }
  267|       |      else if constexpr (N == 6) {
  268|       |         static constexpr auto packed = pack_buffered<Str, 8>();
  269|       |         uint64_t in{};
  270|       |         std::memcpy(&in, other, 6);
  271|       |         if constexpr (std::endian::native == std::endian::big) {
  272|       |            in = std::byteswap(in);
  273|       |         }
  274|       |         return (in == packed);
  275|       |      }
  276|       |      else if constexpr (N == 5) {
  277|       |         static constexpr auto packed = pack<Str, 4>();
  278|       |         uint32_t in;
  279|       |         std::memcpy(&in, other, 4);
  280|       |         if constexpr (std::endian::native == std::endian::big) {
  281|       |            in = std::byteswap(in);
  282|       |         }
  283|       |         return (in == packed) & (Str[4] == other[4]);
  284|       |      }
  285|       |      else if constexpr (N == 4) {
  286|       |         static constexpr auto packed = pack<Str, 4>();
  287|       |         uint32_t in;
  288|       |         std::memcpy(&in, other, 4);
  289|       |         if constexpr (std::endian::native == std::endian::big) {
  290|       |            in = std::byteswap(in);
  291|       |         }
  292|       |         return (in == packed);
  293|       |      }
  294|       |      else if constexpr (N == 3) {
  295|       |         static constexpr auto packed = pack<Str, 2>();
  296|       |         uint16_t in;
  297|       |         std::memcpy(&in, other, 2);
  298|       |         if constexpr (std::endian::native == std::endian::big) {
  299|       |            in = std::byteswap(in);
  300|       |         }
  301|       |         return (in == packed) & (Str[2] == other[2]);
  302|       |      }
  303|  1.63k|      else if constexpr (N == 2) {
  304|  1.63k|         static constexpr auto packed = pack<Str, 2>();
  305|  1.63k|         uint16_t in;
  306|  1.63k|         std::memcpy(&in, other, 2);
  307|       |         if constexpr (std::endian::native == std::endian::big) {
  308|       |            in = std::byteswap(in);
  309|       |         }
  310|  1.63k|         return (in == packed);
  311|       |      }
  312|       |      else if constexpr (N == 1) {
  313|       |         return Str[0] == other[0];
  314|       |      }
  315|       |      else if constexpr (N == 0) {
  316|       |         return true;
  317|       |      }
  318|       |      else {
  319|       |         // Clang and GCC optimize this extremely well for constexpr std::string_view
  320|       |         // Packing data can create more binary on GCC
  321|       |         // The other cases probably aren't needed as compiler explorer shows them optimized equally well as memcmp
  322|       |         return 0 == std::memcmp(Str.data(), other, N);
  323|       |      }
  324|  1.63k|   }
_ZN3glz10comparitorIL_ZZNS_12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiELm0ERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT2_OT4_OT5_OT6_DpOT3_E15KeyWithEndQuoteELm6EcEEbPKT1_:
  245|  14.1k|   {
  246|       |      // pack() builds values in little-endian order (byte 0 in LSB position).
  247|       |      // On big-endian systems, memcpy produces native (big-endian) values,
  248|       |      // so we need to byteswap to match the packed representation.
  249|       |      if constexpr (N == 8) {
  250|       |         static constexpr auto packed = pack<Str, 8>();
  251|       |         uint64_t in;
  252|       |         std::memcpy(&in, other, 8);
  253|       |         if constexpr (std::endian::native == std::endian::big) {
  254|       |            in = std::byteswap(in);
  255|       |         }
  256|       |         return (in == packed);
  257|       |      }
  258|       |      else if constexpr (N == 7) {
  259|       |         static constexpr auto packed = pack_buffered<Str, 8>();
  260|       |         uint64_t in{};
  261|       |         std::memcpy(&in, other, 7);
  262|       |         if constexpr (std::endian::native == std::endian::big) {
  263|       |            in = std::byteswap(in);
  264|       |         }
  265|       |         return (in == packed);
  266|       |      }
  267|  14.1k|      else if constexpr (N == 6) {
  268|  14.1k|         static constexpr auto packed = pack_buffered<Str, 8>();
  269|  14.1k|         uint64_t in{};
  270|  14.1k|         std::memcpy(&in, other, 6);
  271|       |         if constexpr (std::endian::native == std::endian::big) {
  272|       |            in = std::byteswap(in);
  273|       |         }
  274|  14.1k|         return (in == packed);
  275|       |      }
  276|       |      else if constexpr (N == 5) {
  277|       |         static constexpr auto packed = pack<Str, 4>();
  278|       |         uint32_t in;
  279|       |         std::memcpy(&in, other, 4);
  280|       |         if constexpr (std::endian::native == std::endian::big) {
  281|       |            in = std::byteswap(in);
  282|       |         }
  283|       |         return (in == packed) & (Str[4] == other[4]);
  284|       |      }
  285|       |      else if constexpr (N == 4) {
  286|       |         static constexpr auto packed = pack<Str, 4>();
  287|       |         uint32_t in;
  288|       |         std::memcpy(&in, other, 4);
  289|       |         if constexpr (std::endian::native == std::endian::big) {
  290|       |            in = std::byteswap(in);
  291|       |         }
  292|       |         return (in == packed);
  293|       |      }
  294|       |      else if constexpr (N == 3) {
  295|       |         static constexpr auto packed = pack<Str, 2>();
  296|       |         uint16_t in;
  297|       |         std::memcpy(&in, other, 2);
  298|       |         if constexpr (std::endian::native == std::endian::big) {
  299|       |            in = std::byteswap(in);
  300|       |         }
  301|       |         return (in == packed) & (Str[2] == other[2]);
  302|       |      }
  303|       |      else if constexpr (N == 2) {
  304|       |         static constexpr auto packed = pack<Str, 2>();
  305|       |         uint16_t in;
  306|       |         std::memcpy(&in, other, 2);
  307|       |         if constexpr (std::endian::native == std::endian::big) {
  308|       |            in = std::byteswap(in);
  309|       |         }
  310|       |         return (in == packed);
  311|       |      }
  312|       |      else if constexpr (N == 1) {
  313|       |         return Str[0] == other[0];
  314|       |      }
  315|       |      else if constexpr (N == 0) {
  316|       |         return true;
  317|       |      }
  318|       |      else {
  319|       |         // Clang and GCC optimize this extremely well for constexpr std::string_view
  320|       |         // Packing data can create more binary on GCC
  321|       |         // The other cases probably aren't needed as compiler explorer shows them optimized equally well as memcmp
  322|       |         return 0 == std::memcmp(Str.data(), other, N);
  323|       |      }
  324|  14.1k|   }
_ZN3glz10comparitorIL_ZZNS_12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiELm1ERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT2_OT4_OT5_OT6_DpOT3_E15KeyWithEndQuoteELm5EcEEbPKT1_:
  245|    282|   {
  246|       |      // pack() builds values in little-endian order (byte 0 in LSB position).
  247|       |      // On big-endian systems, memcpy produces native (big-endian) values,
  248|       |      // so we need to byteswap to match the packed representation.
  249|       |      if constexpr (N == 8) {
  250|       |         static constexpr auto packed = pack<Str, 8>();
  251|       |         uint64_t in;
  252|       |         std::memcpy(&in, other, 8);
  253|       |         if constexpr (std::endian::native == std::endian::big) {
  254|       |            in = std::byteswap(in);
  255|       |         }
  256|       |         return (in == packed);
  257|       |      }
  258|       |      else if constexpr (N == 7) {
  259|       |         static constexpr auto packed = pack_buffered<Str, 8>();
  260|       |         uint64_t in{};
  261|       |         std::memcpy(&in, other, 7);
  262|       |         if constexpr (std::endian::native == std::endian::big) {
  263|       |            in = std::byteswap(in);
  264|       |         }
  265|       |         return (in == packed);
  266|       |      }
  267|       |      else if constexpr (N == 6) {
  268|       |         static constexpr auto packed = pack_buffered<Str, 8>();
  269|       |         uint64_t in{};
  270|       |         std::memcpy(&in, other, 6);
  271|       |         if constexpr (std::endian::native == std::endian::big) {
  272|       |            in = std::byteswap(in);
  273|       |         }
  274|       |         return (in == packed);
  275|       |      }
  276|    282|      else if constexpr (N == 5) {
  277|    282|         static constexpr auto packed = pack<Str, 4>();
  278|    282|         uint32_t in;
  279|    282|         std::memcpy(&in, other, 4);
  280|       |         if constexpr (std::endian::native == std::endian::big) {
  281|       |            in = std::byteswap(in);
  282|       |         }
  283|    282|         return (in == packed) & (Str[4] == other[4]);
  284|       |      }
  285|       |      else if constexpr (N == 4) {
  286|       |         static constexpr auto packed = pack<Str, 4>();
  287|       |         uint32_t in;
  288|       |         std::memcpy(&in, other, 4);
  289|       |         if constexpr (std::endian::native == std::endian::big) {
  290|       |            in = std::byteswap(in);
  291|       |         }
  292|       |         return (in == packed);
  293|       |      }
  294|       |      else if constexpr (N == 3) {
  295|       |         static constexpr auto packed = pack<Str, 2>();
  296|       |         uint16_t in;
  297|       |         std::memcpy(&in, other, 2);
  298|       |         if constexpr (std::endian::native == std::endian::big) {
  299|       |            in = std::byteswap(in);
  300|       |         }
  301|       |         return (in == packed) & (Str[2] == other[2]);
  302|       |      }
  303|       |      else if constexpr (N == 2) {
  304|       |         static constexpr auto packed = pack<Str, 2>();
  305|       |         uint16_t in;
  306|       |         std::memcpy(&in, other, 2);
  307|       |         if constexpr (std::endian::native == std::endian::big) {
  308|       |            in = std::byteswap(in);
  309|       |         }
  310|       |         return (in == packed);
  311|       |      }
  312|       |      else if constexpr (N == 1) {
  313|       |         return Str[0] == other[0];
  314|       |      }
  315|       |      else if constexpr (N == 0) {
  316|       |         return true;
  317|       |      }
  318|       |      else {
  319|       |         // Clang and GCC optimize this extremely well for constexpr std::string_view
  320|       |         // Packing data can create more binary on GCC
  321|       |         // The other cases probably aren't needed as compiler explorer shows them optimized equally well as memcmp
  322|       |         return 0 == std::memcmp(Str.data(), other, N);
  323|       |      }
  324|    282|   }
_ZN3glz10comparitorIL_ZZNS_12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiELm2ERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT2_OT4_OT5_OT6_DpOT3_E15KeyWithEndQuoteELm9EcEEbPKT1_:
  245|    724|   {
  246|       |      // pack() builds values in little-endian order (byte 0 in LSB position).
  247|       |      // On big-endian systems, memcpy produces native (big-endian) values,
  248|       |      // so we need to byteswap to match the packed representation.
  249|       |      if constexpr (N == 8) {
  250|       |         static constexpr auto packed = pack<Str, 8>();
  251|       |         uint64_t in;
  252|       |         std::memcpy(&in, other, 8);
  253|       |         if constexpr (std::endian::native == std::endian::big) {
  254|       |            in = std::byteswap(in);
  255|       |         }
  256|       |         return (in == packed);
  257|       |      }
  258|       |      else if constexpr (N == 7) {
  259|       |         static constexpr auto packed = pack_buffered<Str, 8>();
  260|       |         uint64_t in{};
  261|       |         std::memcpy(&in, other, 7);
  262|       |         if constexpr (std::endian::native == std::endian::big) {
  263|       |            in = std::byteswap(in);
  264|       |         }
  265|       |         return (in == packed);
  266|       |      }
  267|       |      else if constexpr (N == 6) {
  268|       |         static constexpr auto packed = pack_buffered<Str, 8>();
  269|       |         uint64_t in{};
  270|       |         std::memcpy(&in, other, 6);
  271|       |         if constexpr (std::endian::native == std::endian::big) {
  272|       |            in = std::byteswap(in);
  273|       |         }
  274|       |         return (in == packed);
  275|       |      }
  276|       |      else if constexpr (N == 5) {
  277|       |         static constexpr auto packed = pack<Str, 4>();
  278|       |         uint32_t in;
  279|       |         std::memcpy(&in, other, 4);
  280|       |         if constexpr (std::endian::native == std::endian::big) {
  281|       |            in = std::byteswap(in);
  282|       |         }
  283|       |         return (in == packed) & (Str[4] == other[4]);
  284|       |      }
  285|       |      else if constexpr (N == 4) {
  286|       |         static constexpr auto packed = pack<Str, 4>();
  287|       |         uint32_t in;
  288|       |         std::memcpy(&in, other, 4);
  289|       |         if constexpr (std::endian::native == std::endian::big) {
  290|       |            in = std::byteswap(in);
  291|       |         }
  292|       |         return (in == packed);
  293|       |      }
  294|       |      else if constexpr (N == 3) {
  295|       |         static constexpr auto packed = pack<Str, 2>();
  296|       |         uint16_t in;
  297|       |         std::memcpy(&in, other, 2);
  298|       |         if constexpr (std::endian::native == std::endian::big) {
  299|       |            in = std::byteswap(in);
  300|       |         }
  301|       |         return (in == packed) & (Str[2] == other[2]);
  302|       |      }
  303|       |      else if constexpr (N == 2) {
  304|       |         static constexpr auto packed = pack<Str, 2>();
  305|       |         uint16_t in;
  306|       |         std::memcpy(&in, other, 2);
  307|       |         if constexpr (std::endian::native == std::endian::big) {
  308|       |            in = std::byteswap(in);
  309|       |         }
  310|       |         return (in == packed);
  311|       |      }
  312|       |      else if constexpr (N == 1) {
  313|       |         return Str[0] == other[0];
  314|       |      }
  315|       |      else if constexpr (N == 0) {
  316|       |         return true;
  317|       |      }
  318|    724|      else {
  319|       |         // Clang and GCC optimize this extremely well for constexpr std::string_view
  320|       |         // Packing data can create more binary on GCC
  321|       |         // The other cases probably aren't needed as compiler explorer shows them optimized equally well as memcmp
  322|    724|         return 0 == std::memcmp(Str.data(), other, N);
  323|    724|      }
  324|    724|   }
_ZN3glz10comparitorIL_ZZNS_12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiELm3ERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT2_OT4_OT5_OT6_DpOT3_E15KeyWithEndQuoteELm6EcEEbPKT1_:
  245|    834|   {
  246|       |      // pack() builds values in little-endian order (byte 0 in LSB position).
  247|       |      // On big-endian systems, memcpy produces native (big-endian) values,
  248|       |      // so we need to byteswap to match the packed representation.
  249|       |      if constexpr (N == 8) {
  250|       |         static constexpr auto packed = pack<Str, 8>();
  251|       |         uint64_t in;
  252|       |         std::memcpy(&in, other, 8);
  253|       |         if constexpr (std::endian::native == std::endian::big) {
  254|       |            in = std::byteswap(in);
  255|       |         }
  256|       |         return (in == packed);
  257|       |      }
  258|       |      else if constexpr (N == 7) {
  259|       |         static constexpr auto packed = pack_buffered<Str, 8>();
  260|       |         uint64_t in{};
  261|       |         std::memcpy(&in, other, 7);
  262|       |         if constexpr (std::endian::native == std::endian::big) {
  263|       |            in = std::byteswap(in);
  264|       |         }
  265|       |         return (in == packed);
  266|       |      }
  267|    834|      else if constexpr (N == 6) {
  268|    834|         static constexpr auto packed = pack_buffered<Str, 8>();
  269|    834|         uint64_t in{};
  270|    834|         std::memcpy(&in, other, 6);
  271|       |         if constexpr (std::endian::native == std::endian::big) {
  272|       |            in = std::byteswap(in);
  273|       |         }
  274|    834|         return (in == packed);
  275|       |      }
  276|       |      else if constexpr (N == 5) {
  277|       |         static constexpr auto packed = pack<Str, 4>();
  278|       |         uint32_t in;
  279|       |         std::memcpy(&in, other, 4);
  280|       |         if constexpr (std::endian::native == std::endian::big) {
  281|       |            in = std::byteswap(in);
  282|       |         }
  283|       |         return (in == packed) & (Str[4] == other[4]);
  284|       |      }
  285|       |      else if constexpr (N == 4) {
  286|       |         static constexpr auto packed = pack<Str, 4>();
  287|       |         uint32_t in;
  288|       |         std::memcpy(&in, other, 4);
  289|       |         if constexpr (std::endian::native == std::endian::big) {
  290|       |            in = std::byteswap(in);
  291|       |         }
  292|       |         return (in == packed);
  293|       |      }
  294|       |      else if constexpr (N == 3) {
  295|       |         static constexpr auto packed = pack<Str, 2>();
  296|       |         uint16_t in;
  297|       |         std::memcpy(&in, other, 2);
  298|       |         if constexpr (std::endian::native == std::endian::big) {
  299|       |            in = std::byteswap(in);
  300|       |         }
  301|       |         return (in == packed) & (Str[2] == other[2]);
  302|       |      }
  303|       |      else if constexpr (N == 2) {
  304|       |         static constexpr auto packed = pack<Str, 2>();
  305|       |         uint16_t in;
  306|       |         std::memcpy(&in, other, 2);
  307|       |         if constexpr (std::endian::native == std::endian::big) {
  308|       |            in = std::byteswap(in);
  309|       |         }
  310|       |         return (in == packed);
  311|       |      }
  312|       |      else if constexpr (N == 1) {
  313|       |         return Str[0] == other[0];
  314|       |      }
  315|       |      else if constexpr (N == 0) {
  316|       |         return true;
  317|       |      }
  318|       |      else {
  319|       |         // Clang and GCC optimize this extremely well for constexpr std::string_view
  320|       |         // Packing data can create more binary on GCC
  321|       |         // The other cases probably aren't needed as compiler explorer shows them optimized equally well as memcmp
  322|       |         return 0 == std::memcmp(Str.data(), other, N);
  323|       |      }
  324|    834|   }
_ZN3glz10comparitorIL_ZZNS_12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz6nestedELm0ERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT2_OT4_OT5_OT6_DpOT3_E15KeyWithEndQuoteELm6EcEEbPKT1_:
  245|  12.5k|   {
  246|       |      // pack() builds values in little-endian order (byte 0 in LSB position).
  247|       |      // On big-endian systems, memcpy produces native (big-endian) values,
  248|       |      // so we need to byteswap to match the packed representation.
  249|       |      if constexpr (N == 8) {
  250|       |         static constexpr auto packed = pack<Str, 8>();
  251|       |         uint64_t in;
  252|       |         std::memcpy(&in, other, 8);
  253|       |         if constexpr (std::endian::native == std::endian::big) {
  254|       |            in = std::byteswap(in);
  255|       |         }
  256|       |         return (in == packed);
  257|       |      }
  258|       |      else if constexpr (N == 7) {
  259|       |         static constexpr auto packed = pack_buffered<Str, 8>();
  260|       |         uint64_t in{};
  261|       |         std::memcpy(&in, other, 7);
  262|       |         if constexpr (std::endian::native == std::endian::big) {
  263|       |            in = std::byteswap(in);
  264|       |         }
  265|       |         return (in == packed);
  266|       |      }
  267|  12.5k|      else if constexpr (N == 6) {
  268|  12.5k|         static constexpr auto packed = pack_buffered<Str, 8>();
  269|  12.5k|         uint64_t in{};
  270|  12.5k|         std::memcpy(&in, other, 6);
  271|       |         if constexpr (std::endian::native == std::endian::big) {
  272|       |            in = std::byteswap(in);
  273|       |         }
  274|  12.5k|         return (in == packed);
  275|       |      }
  276|       |      else if constexpr (N == 5) {
  277|       |         static constexpr auto packed = pack<Str, 4>();
  278|       |         uint32_t in;
  279|       |         std::memcpy(&in, other, 4);
  280|       |         if constexpr (std::endian::native == std::endian::big) {
  281|       |            in = std::byteswap(in);
  282|       |         }
  283|       |         return (in == packed) & (Str[4] == other[4]);
  284|       |      }
  285|       |      else if constexpr (N == 4) {
  286|       |         static constexpr auto packed = pack<Str, 4>();
  287|       |         uint32_t in;
  288|       |         std::memcpy(&in, other, 4);
  289|       |         if constexpr (std::endian::native == std::endian::big) {
  290|       |            in = std::byteswap(in);
  291|       |         }
  292|       |         return (in == packed);
  293|       |      }
  294|       |      else if constexpr (N == 3) {
  295|       |         static constexpr auto packed = pack<Str, 2>();
  296|       |         uint16_t in;
  297|       |         std::memcpy(&in, other, 2);
  298|       |         if constexpr (std::endian::native == std::endian::big) {
  299|       |            in = std::byteswap(in);
  300|       |         }
  301|       |         return (in == packed) & (Str[2] == other[2]);
  302|       |      }
  303|       |      else if constexpr (N == 2) {
  304|       |         static constexpr auto packed = pack<Str, 2>();
  305|       |         uint16_t in;
  306|       |         std::memcpy(&in, other, 2);
  307|       |         if constexpr (std::endian::native == std::endian::big) {
  308|       |            in = std::byteswap(in);
  309|       |         }
  310|       |         return (in == packed);
  311|       |      }
  312|       |      else if constexpr (N == 1) {
  313|       |         return Str[0] == other[0];
  314|       |      }
  315|       |      else if constexpr (N == 0) {
  316|       |         return true;
  317|       |      }
  318|       |      else {
  319|       |         // Clang and GCC optimize this extremely well for constexpr std::string_view
  320|       |         // Packing data can create more binary on GCC
  321|       |         // The other cases probably aren't needed as compiler explorer shows them optimized equally well as memcmp
  322|       |         return 0 == std::memcmp(Str.data(), other, N);
  323|       |      }
  324|  12.5k|   }
_ZN3glz10comparitorIL_ZZNS_12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz6nestedELm1ERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT2_OT4_OT5_OT6_DpOT3_E15KeyWithEndQuoteELm6EcEEbPKT1_:
  245|    593|   {
  246|       |      // pack() builds values in little-endian order (byte 0 in LSB position).
  247|       |      // On big-endian systems, memcpy produces native (big-endian) values,
  248|       |      // so we need to byteswap to match the packed representation.
  249|       |      if constexpr (N == 8) {
  250|       |         static constexpr auto packed = pack<Str, 8>();
  251|       |         uint64_t in;
  252|       |         std::memcpy(&in, other, 8);
  253|       |         if constexpr (std::endian::native == std::endian::big) {
  254|       |            in = std::byteswap(in);
  255|       |         }
  256|       |         return (in == packed);
  257|       |      }
  258|       |      else if constexpr (N == 7) {
  259|       |         static constexpr auto packed = pack_buffered<Str, 8>();
  260|       |         uint64_t in{};
  261|       |         std::memcpy(&in, other, 7);
  262|       |         if constexpr (std::endian::native == std::endian::big) {
  263|       |            in = std::byteswap(in);
  264|       |         }
  265|       |         return (in == packed);
  266|       |      }
  267|    593|      else if constexpr (N == 6) {
  268|    593|         static constexpr auto packed = pack_buffered<Str, 8>();
  269|    593|         uint64_t in{};
  270|    593|         std::memcpy(&in, other, 6);
  271|       |         if constexpr (std::endian::native == std::endian::big) {
  272|       |            in = std::byteswap(in);
  273|       |         }
  274|    593|         return (in == packed);
  275|       |      }
  276|       |      else if constexpr (N == 5) {
  277|       |         static constexpr auto packed = pack<Str, 4>();
  278|       |         uint32_t in;
  279|       |         std::memcpy(&in, other, 4);
  280|       |         if constexpr (std::endian::native == std::endian::big) {
  281|       |            in = std::byteswap(in);
  282|       |         }
  283|       |         return (in == packed) & (Str[4] == other[4]);
  284|       |      }
  285|       |      else if constexpr (N == 4) {
  286|       |         static constexpr auto packed = pack<Str, 4>();
  287|       |         uint32_t in;
  288|       |         std::memcpy(&in, other, 4);
  289|       |         if constexpr (std::endian::native == std::endian::big) {
  290|       |            in = std::byteswap(in);
  291|       |         }
  292|       |         return (in == packed);
  293|       |      }
  294|       |      else if constexpr (N == 3) {
  295|       |         static constexpr auto packed = pack<Str, 2>();
  296|       |         uint16_t in;
  297|       |         std::memcpy(&in, other, 2);
  298|       |         if constexpr (std::endian::native == std::endian::big) {
  299|       |            in = std::byteswap(in);
  300|       |         }
  301|       |         return (in == packed) & (Str[2] == other[2]);
  302|       |      }
  303|       |      else if constexpr (N == 2) {
  304|       |         static constexpr auto packed = pack<Str, 2>();
  305|       |         uint16_t in;
  306|       |         std::memcpy(&in, other, 2);
  307|       |         if constexpr (std::endian::native == std::endian::big) {
  308|       |            in = std::byteswap(in);
  309|       |         }
  310|       |         return (in == packed);
  311|       |      }
  312|       |      else if constexpr (N == 1) {
  313|       |         return Str[0] == other[0];
  314|       |      }
  315|       |      else if constexpr (N == 0) {
  316|       |         return true;
  317|       |      }
  318|       |      else {
  319|       |         // Clang and GCC optimize this extremely well for constexpr std::string_view
  320|       |         // Packing data can create more binary on GCC
  321|       |         // The other cases probably aren't needed as compiler explorer shows them optimized equally well as memcmp
  322|       |         return 0 == std::memcmp(Str.data(), other, N);
  323|       |      }
  324|    593|   }
_ZN3glz10comparitorIL_ZZNS_12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiELm4ERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT2_OT4_OT5_OT6_DpOT3_E15KeyWithEndQuoteELm7EcEEbPKT1_:
  245|      3|   {
  246|       |      // pack() builds values in little-endian order (byte 0 in LSB position).
  247|       |      // On big-endian systems, memcpy produces native (big-endian) values,
  248|       |      // so we need to byteswap to match the packed representation.
  249|       |      if constexpr (N == 8) {
  250|       |         static constexpr auto packed = pack<Str, 8>();
  251|       |         uint64_t in;
  252|       |         std::memcpy(&in, other, 8);
  253|       |         if constexpr (std::endian::native == std::endian::big) {
  254|       |            in = std::byteswap(in);
  255|       |         }
  256|       |         return (in == packed);
  257|       |      }
  258|      3|      else if constexpr (N == 7) {
  259|      3|         static constexpr auto packed = pack_buffered<Str, 8>();
  260|      3|         uint64_t in{};
  261|      3|         std::memcpy(&in, other, 7);
  262|       |         if constexpr (std::endian::native == std::endian::big) {
  263|       |            in = std::byteswap(in);
  264|       |         }
  265|      3|         return (in == packed);
  266|       |      }
  267|       |      else if constexpr (N == 6) {
  268|       |         static constexpr auto packed = pack_buffered<Str, 8>();
  269|       |         uint64_t in{};
  270|       |         std::memcpy(&in, other, 6);
  271|       |         if constexpr (std::endian::native == std::endian::big) {
  272|       |            in = std::byteswap(in);
  273|       |         }
  274|       |         return (in == packed);
  275|       |      }
  276|       |      else if constexpr (N == 5) {
  277|       |         static constexpr auto packed = pack<Str, 4>();
  278|       |         uint32_t in;
  279|       |         std::memcpy(&in, other, 4);
  280|       |         if constexpr (std::endian::native == std::endian::big) {
  281|       |            in = std::byteswap(in);
  282|       |         }
  283|       |         return (in == packed) & (Str[4] == other[4]);
  284|       |      }
  285|       |      else if constexpr (N == 4) {
  286|       |         static constexpr auto packed = pack<Str, 4>();
  287|       |         uint32_t in;
  288|       |         std::memcpy(&in, other, 4);
  289|       |         if constexpr (std::endian::native == std::endian::big) {
  290|       |            in = std::byteswap(in);
  291|       |         }
  292|       |         return (in == packed);
  293|       |      }
  294|       |      else if constexpr (N == 3) {
  295|       |         static constexpr auto packed = pack<Str, 2>();
  296|       |         uint16_t in;
  297|       |         std::memcpy(&in, other, 2);
  298|       |         if constexpr (std::endian::native == std::endian::big) {
  299|       |            in = std::byteswap(in);
  300|       |         }
  301|       |         return (in == packed) & (Str[2] == other[2]);
  302|       |      }
  303|       |      else if constexpr (N == 2) {
  304|       |         static constexpr auto packed = pack<Str, 2>();
  305|       |         uint16_t in;
  306|       |         std::memcpy(&in, other, 2);
  307|       |         if constexpr (std::endian::native == std::endian::big) {
  308|       |            in = std::byteswap(in);
  309|       |         }
  310|       |         return (in == packed);
  311|       |      }
  312|       |      else if constexpr (N == 1) {
  313|       |         return Str[0] == other[0];
  314|       |      }
  315|       |      else if constexpr (N == 0) {
  316|       |         return true;
  317|       |      }
  318|       |      else {
  319|       |         // Clang and GCC optimize this extremely well for constexpr std::string_view
  320|       |         // Packing data can create more binary on GCC
  321|       |         // The other cases probably aren't needed as compiler explorer shows them optimized equally well as memcmp
  322|       |         return 0 == std::memcmp(Str.data(), other, N);
  323|       |      }
  324|      3|   }
_ZN3glz10comparitorIL_ZZNS_12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiELm5ERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT2_OT4_OT5_OT6_DpOT3_E15KeyWithEndQuoteELm6EcEEbPKT1_:
  245|  1.13k|   {
  246|       |      // pack() builds values in little-endian order (byte 0 in LSB position).
  247|       |      // On big-endian systems, memcpy produces native (big-endian) values,
  248|       |      // so we need to byteswap to match the packed representation.
  249|       |      if constexpr (N == 8) {
  250|       |         static constexpr auto packed = pack<Str, 8>();
  251|       |         uint64_t in;
  252|       |         std::memcpy(&in, other, 8);
  253|       |         if constexpr (std::endian::native == std::endian::big) {
  254|       |            in = std::byteswap(in);
  255|       |         }
  256|       |         return (in == packed);
  257|       |      }
  258|       |      else if constexpr (N == 7) {
  259|       |         static constexpr auto packed = pack_buffered<Str, 8>();
  260|       |         uint64_t in{};
  261|       |         std::memcpy(&in, other, 7);
  262|       |         if constexpr (std::endian::native == std::endian::big) {
  263|       |            in = std::byteswap(in);
  264|       |         }
  265|       |         return (in == packed);
  266|       |      }
  267|  1.13k|      else if constexpr (N == 6) {
  268|  1.13k|         static constexpr auto packed = pack_buffered<Str, 8>();
  269|  1.13k|         uint64_t in{};
  270|  1.13k|         std::memcpy(&in, other, 6);
  271|       |         if constexpr (std::endian::native == std::endian::big) {
  272|       |            in = std::byteswap(in);
  273|       |         }
  274|  1.13k|         return (in == packed);
  275|       |      }
  276|       |      else if constexpr (N == 5) {
  277|       |         static constexpr auto packed = pack<Str, 4>();
  278|       |         uint32_t in;
  279|       |         std::memcpy(&in, other, 4);
  280|       |         if constexpr (std::endian::native == std::endian::big) {
  281|       |            in = std::byteswap(in);
  282|       |         }
  283|       |         return (in == packed) & (Str[4] == other[4]);
  284|       |      }
  285|       |      else if constexpr (N == 4) {
  286|       |         static constexpr auto packed = pack<Str, 4>();
  287|       |         uint32_t in;
  288|       |         std::memcpy(&in, other, 4);
  289|       |         if constexpr (std::endian::native == std::endian::big) {
  290|       |            in = std::byteswap(in);
  291|       |         }
  292|       |         return (in == packed);
  293|       |      }
  294|       |      else if constexpr (N == 3) {
  295|       |         static constexpr auto packed = pack<Str, 2>();
  296|       |         uint16_t in;
  297|       |         std::memcpy(&in, other, 2);
  298|       |         if constexpr (std::endian::native == std::endian::big) {
  299|       |            in = std::byteswap(in);
  300|       |         }
  301|       |         return (in == packed) & (Str[2] == other[2]);
  302|       |      }
  303|       |      else if constexpr (N == 2) {
  304|       |         static constexpr auto packed = pack<Str, 2>();
  305|       |         uint16_t in;
  306|       |         std::memcpy(&in, other, 2);
  307|       |         if constexpr (std::endian::native == std::endian::big) {
  308|       |            in = std::byteswap(in);
  309|       |         }
  310|       |         return (in == packed);
  311|       |      }
  312|       |      else if constexpr (N == 1) {
  313|       |         return Str[0] == other[0];
  314|       |      }
  315|       |      else if constexpr (N == 0) {
  316|       |         return true;
  317|       |      }
  318|       |      else {
  319|       |         // Clang and GCC optimize this extremely well for constexpr std::string_view
  320|       |         // Packing data can create more binary on GCC
  321|       |         // The other cases probably aren't needed as compiler explorer shows them optimized equally well as memcmp
  322|       |         return 0 == std::memcmp(Str.data(), other, N);
  323|       |      }
  324|  1.13k|   }
_ZN3glz10comparitorIL_ZZNS_12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiELm6ERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT2_OT4_OT5_OT6_DpOT3_E15KeyWithEndQuoteELm6EcEEbPKT1_:
  245|  1.56k|   {
  246|       |      // pack() builds values in little-endian order (byte 0 in LSB position).
  247|       |      // On big-endian systems, memcpy produces native (big-endian) values,
  248|       |      // so we need to byteswap to match the packed representation.
  249|       |      if constexpr (N == 8) {
  250|       |         static constexpr auto packed = pack<Str, 8>();
  251|       |         uint64_t in;
  252|       |         std::memcpy(&in, other, 8);
  253|       |         if constexpr (std::endian::native == std::endian::big) {
  254|       |            in = std::byteswap(in);
  255|       |         }
  256|       |         return (in == packed);
  257|       |      }
  258|       |      else if constexpr (N == 7) {
  259|       |         static constexpr auto packed = pack_buffered<Str, 8>();
  260|       |         uint64_t in{};
  261|       |         std::memcpy(&in, other, 7);
  262|       |         if constexpr (std::endian::native == std::endian::big) {
  263|       |            in = std::byteswap(in);
  264|       |         }
  265|       |         return (in == packed);
  266|       |      }
  267|  1.56k|      else if constexpr (N == 6) {
  268|  1.56k|         static constexpr auto packed = pack_buffered<Str, 8>();
  269|  1.56k|         uint64_t in{};
  270|  1.56k|         std::memcpy(&in, other, 6);
  271|       |         if constexpr (std::endian::native == std::endian::big) {
  272|       |            in = std::byteswap(in);
  273|       |         }
  274|  1.56k|         return (in == packed);
  275|       |      }
  276|       |      else if constexpr (N == 5) {
  277|       |         static constexpr auto packed = pack<Str, 4>();
  278|       |         uint32_t in;
  279|       |         std::memcpy(&in, other, 4);
  280|       |         if constexpr (std::endian::native == std::endian::big) {
  281|       |            in = std::byteswap(in);
  282|       |         }
  283|       |         return (in == packed) & (Str[4] == other[4]);
  284|       |      }
  285|       |      else if constexpr (N == 4) {
  286|       |         static constexpr auto packed = pack<Str, 4>();
  287|       |         uint32_t in;
  288|       |         std::memcpy(&in, other, 4);
  289|       |         if constexpr (std::endian::native == std::endian::big) {
  290|       |            in = std::byteswap(in);
  291|       |         }
  292|       |         return (in == packed);
  293|       |      }
  294|       |      else if constexpr (N == 3) {
  295|       |         static constexpr auto packed = pack<Str, 2>();
  296|       |         uint16_t in;
  297|       |         std::memcpy(&in, other, 2);
  298|       |         if constexpr (std::endian::native == std::endian::big) {
  299|       |            in = std::byteswap(in);
  300|       |         }
  301|       |         return (in == packed) & (Str[2] == other[2]);
  302|       |      }
  303|       |      else if constexpr (N == 2) {
  304|       |         static constexpr auto packed = pack<Str, 2>();
  305|       |         uint16_t in;
  306|       |         std::memcpy(&in, other, 2);
  307|       |         if constexpr (std::endian::native == std::endian::big) {
  308|       |            in = std::byteswap(in);
  309|       |         }
  310|       |         return (in == packed);
  311|       |      }
  312|       |      else if constexpr (N == 1) {
  313|       |         return Str[0] == other[0];
  314|       |      }
  315|       |      else if constexpr (N == 0) {
  316|       |         return true;
  317|       |      }
  318|       |      else {
  319|       |         // Clang and GCC optimize this extremely well for constexpr std::string_view
  320|       |         // Packing data can create more binary on GCC
  321|       |         // The other cases probably aren't needed as compiler explorer shows them optimized equally well as memcmp
  322|       |         return 0 == std::memcmp(Str.data(), other, N);
  323|       |      }
  324|  1.56k|   }
_ZN3glz10comparitorIL_ZZNS_5matchITnNS_14string_literalEXtlNS2_ILm4EEEtlA4_cLc117ELc108ELc108EEEETnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETkNS_10is_contextERNS_7contextERPKcS9_Qntcl15check_is_paddedT0_EEEvOT1_OT2_T3_E1SELm3EcEEbPKSB_:
  245|  1.51k|   {
  246|       |      // pack() builds values in little-endian order (byte 0 in LSB position).
  247|       |      // On big-endian systems, memcpy produces native (big-endian) values,
  248|       |      // so we need to byteswap to match the packed representation.
  249|       |      if constexpr (N == 8) {
  250|       |         static constexpr auto packed = pack<Str, 8>();
  251|       |         uint64_t in;
  252|       |         std::memcpy(&in, other, 8);
  253|       |         if constexpr (std::endian::native == std::endian::big) {
  254|       |            in = std::byteswap(in);
  255|       |         }
  256|       |         return (in == packed);
  257|       |      }
  258|       |      else if constexpr (N == 7) {
  259|       |         static constexpr auto packed = pack_buffered<Str, 8>();
  260|       |         uint64_t in{};
  261|       |         std::memcpy(&in, other, 7);
  262|       |         if constexpr (std::endian::native == std::endian::big) {
  263|       |            in = std::byteswap(in);
  264|       |         }
  265|       |         return (in == packed);
  266|       |      }
  267|       |      else if constexpr (N == 6) {
  268|       |         static constexpr auto packed = pack_buffered<Str, 8>();
  269|       |         uint64_t in{};
  270|       |         std::memcpy(&in, other, 6);
  271|       |         if constexpr (std::endian::native == std::endian::big) {
  272|       |            in = std::byteswap(in);
  273|       |         }
  274|       |         return (in == packed);
  275|       |      }
  276|       |      else if constexpr (N == 5) {
  277|       |         static constexpr auto packed = pack<Str, 4>();
  278|       |         uint32_t in;
  279|       |         std::memcpy(&in, other, 4);
  280|       |         if constexpr (std::endian::native == std::endian::big) {
  281|       |            in = std::byteswap(in);
  282|       |         }
  283|       |         return (in == packed) & (Str[4] == other[4]);
  284|       |      }
  285|       |      else if constexpr (N == 4) {
  286|       |         static constexpr auto packed = pack<Str, 4>();
  287|       |         uint32_t in;
  288|       |         std::memcpy(&in, other, 4);
  289|       |         if constexpr (std::endian::native == std::endian::big) {
  290|       |            in = std::byteswap(in);
  291|       |         }
  292|       |         return (in == packed);
  293|       |      }
  294|  1.51k|      else if constexpr (N == 3) {
  295|  1.51k|         static constexpr auto packed = pack<Str, 2>();
  296|  1.51k|         uint16_t in;
  297|  1.51k|         std::memcpy(&in, other, 2);
  298|       |         if constexpr (std::endian::native == std::endian::big) {
  299|       |            in = std::byteswap(in);
  300|       |         }
  301|  1.51k|         return (in == packed) & (Str[2] == other[2]);
  302|       |      }
  303|       |      else if constexpr (N == 2) {
  304|       |         static constexpr auto packed = pack<Str, 2>();
  305|       |         uint16_t in;
  306|       |         std::memcpy(&in, other, 2);
  307|       |         if constexpr (std::endian::native == std::endian::big) {
  308|       |            in = std::byteswap(in);
  309|       |         }
  310|       |         return (in == packed);
  311|       |      }
  312|       |      else if constexpr (N == 1) {
  313|       |         return Str[0] == other[0];
  314|       |      }
  315|       |      else if constexpr (N == 0) {
  316|       |         return true;
  317|       |      }
  318|       |      else {
  319|       |         // Clang and GCC optimize this extremely well for constexpr std::string_view
  320|       |         // Packing data can create more binary on GCC
  321|       |         // The other cases probably aren't needed as compiler explorer shows them optimized equally well as memcmp
  322|       |         return 0 == std::memcmp(Str.data(), other, N);
  323|       |      }
  324|  1.51k|   }
_ZN3glz10comparitorIL_ZZNS_12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiELm7ERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT2_OT4_OT5_OT6_DpOT3_E15KeyWithEndQuoteELm8EcEEbPKT1_:
  245|    729|   {
  246|       |      // pack() builds values in little-endian order (byte 0 in LSB position).
  247|       |      // On big-endian systems, memcpy produces native (big-endian) values,
  248|       |      // so we need to byteswap to match the packed representation.
  249|    729|      if constexpr (N == 8) {
  250|    729|         static constexpr auto packed = pack<Str, 8>();
  251|    729|         uint64_t in;
  252|    729|         std::memcpy(&in, other, 8);
  253|       |         if constexpr (std::endian::native == std::endian::big) {
  254|       |            in = std::byteswap(in);
  255|       |         }
  256|    729|         return (in == packed);
  257|       |      }
  258|       |      else if constexpr (N == 7) {
  259|       |         static constexpr auto packed = pack_buffered<Str, 8>();
  260|       |         uint64_t in{};
  261|       |         std::memcpy(&in, other, 7);
  262|       |         if constexpr (std::endian::native == std::endian::big) {
  263|       |            in = std::byteswap(in);
  264|       |         }
  265|       |         return (in == packed);
  266|       |      }
  267|       |      else if constexpr (N == 6) {
  268|       |         static constexpr auto packed = pack_buffered<Str, 8>();
  269|       |         uint64_t in{};
  270|       |         std::memcpy(&in, other, 6);
  271|       |         if constexpr (std::endian::native == std::endian::big) {
  272|       |            in = std::byteswap(in);
  273|       |         }
  274|       |         return (in == packed);
  275|       |      }
  276|       |      else if constexpr (N == 5) {
  277|       |         static constexpr auto packed = pack<Str, 4>();
  278|       |         uint32_t in;
  279|       |         std::memcpy(&in, other, 4);
  280|       |         if constexpr (std::endian::native == std::endian::big) {
  281|       |            in = std::byteswap(in);
  282|       |         }
  283|       |         return (in == packed) & (Str[4] == other[4]);
  284|       |      }
  285|       |      else if constexpr (N == 4) {
  286|       |         static constexpr auto packed = pack<Str, 4>();
  287|       |         uint32_t in;
  288|       |         std::memcpy(&in, other, 4);
  289|       |         if constexpr (std::endian::native == std::endian::big) {
  290|       |            in = std::byteswap(in);
  291|       |         }
  292|       |         return (in == packed);
  293|       |      }
  294|       |      else if constexpr (N == 3) {
  295|       |         static constexpr auto packed = pack<Str, 2>();
  296|       |         uint16_t in;
  297|       |         std::memcpy(&in, other, 2);
  298|       |         if constexpr (std::endian::native == std::endian::big) {
  299|       |            in = std::byteswap(in);
  300|       |         }
  301|       |         return (in == packed) & (Str[2] == other[2]);
  302|       |      }
  303|       |      else if constexpr (N == 2) {
  304|       |         static constexpr auto packed = pack<Str, 2>();
  305|       |         uint16_t in;
  306|       |         std::memcpy(&in, other, 2);
  307|       |         if constexpr (std::endian::native == std::endian::big) {
  308|       |            in = std::byteswap(in);
  309|       |         }
  310|       |         return (in == packed);
  311|       |      }
  312|       |      else if constexpr (N == 1) {
  313|       |         return Str[0] == other[0];
  314|       |      }
  315|       |      else if constexpr (N == 0) {
  316|       |         return true;
  317|       |      }
  318|       |      else {
  319|       |         // Clang and GCC optimize this extremely well for constexpr std::string_view
  320|       |         // Packing data can create more binary on GCC
  321|       |         // The other cases probably aren't needed as compiler explorer shows them optimized equally well as memcmp
  322|       |         return 0 == std::memcmp(Str.data(), other, N);
  323|       |      }
  324|    729|   }
_ZN3glz10comparitorIL_ZZNS_12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz6amountELm0ERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT2_OT4_OT5_OT6_DpOT3_E15KeyWithEndQuoteELm6EcEEbPKT1_:
  245|    366|   {
  246|       |      // pack() builds values in little-endian order (byte 0 in LSB position).
  247|       |      // On big-endian systems, memcpy produces native (big-endian) values,
  248|       |      // so we need to byteswap to match the packed representation.
  249|       |      if constexpr (N == 8) {
  250|       |         static constexpr auto packed = pack<Str, 8>();
  251|       |         uint64_t in;
  252|       |         std::memcpy(&in, other, 8);
  253|       |         if constexpr (std::endian::native == std::endian::big) {
  254|       |            in = std::byteswap(in);
  255|       |         }
  256|       |         return (in == packed);
  257|       |      }
  258|       |      else if constexpr (N == 7) {
  259|       |         static constexpr auto packed = pack_buffered<Str, 8>();
  260|       |         uint64_t in{};
  261|       |         std::memcpy(&in, other, 7);
  262|       |         if constexpr (std::endian::native == std::endian::big) {
  263|       |            in = std::byteswap(in);
  264|       |         }
  265|       |         return (in == packed);
  266|       |      }
  267|    366|      else if constexpr (N == 6) {
  268|    366|         static constexpr auto packed = pack_buffered<Str, 8>();
  269|    366|         uint64_t in{};
  270|    366|         std::memcpy(&in, other, 6);
  271|       |         if constexpr (std::endian::native == std::endian::big) {
  272|       |            in = std::byteswap(in);
  273|       |         }
  274|    366|         return (in == packed);
  275|       |      }
  276|       |      else if constexpr (N == 5) {
  277|       |         static constexpr auto packed = pack<Str, 4>();
  278|       |         uint32_t in;
  279|       |         std::memcpy(&in, other, 4);
  280|       |         if constexpr (std::endian::native == std::endian::big) {
  281|       |            in = std::byteswap(in);
  282|       |         }
  283|       |         return (in == packed) & (Str[4] == other[4]);
  284|       |      }
  285|       |      else if constexpr (N == 4) {
  286|       |         static constexpr auto packed = pack<Str, 4>();
  287|       |         uint32_t in;
  288|       |         std::memcpy(&in, other, 4);
  289|       |         if constexpr (std::endian::native == std::endian::big) {
  290|       |            in = std::byteswap(in);
  291|       |         }
  292|       |         return (in == packed);
  293|       |      }
  294|       |      else if constexpr (N == 3) {
  295|       |         static constexpr auto packed = pack<Str, 2>();
  296|       |         uint16_t in;
  297|       |         std::memcpy(&in, other, 2);
  298|       |         if constexpr (std::endian::native == std::endian::big) {
  299|       |            in = std::byteswap(in);
  300|       |         }
  301|       |         return (in == packed) & (Str[2] == other[2]);
  302|       |      }
  303|       |      else if constexpr (N == 2) {
  304|       |         static constexpr auto packed = pack<Str, 2>();
  305|       |         uint16_t in;
  306|       |         std::memcpy(&in, other, 2);
  307|       |         if constexpr (std::endian::native == std::endian::big) {
  308|       |            in = std::byteswap(in);
  309|       |         }
  310|       |         return (in == packed);
  311|       |      }
  312|       |      else if constexpr (N == 1) {
  313|       |         return Str[0] == other[0];
  314|       |      }
  315|       |      else if constexpr (N == 0) {
  316|       |         return true;
  317|       |      }
  318|       |      else {
  319|       |         // Clang and GCC optimize this extremely well for constexpr std::string_view
  320|       |         // Packing data can create more binary on GCC
  321|       |         // The other cases probably aren't needed as compiler explorer shows them optimized equally well as memcmp
  322|       |         return 0 == std::memcmp(Str.data(), other, N);
  323|       |      }
  324|    366|   }
_ZN3glz10comparitorIL_ZZNS_12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiELm8ERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT2_OT4_OT5_OT6_DpOT3_E15KeyWithEndQuoteELm8EcEEbPKT1_:
  245|    411|   {
  246|       |      // pack() builds values in little-endian order (byte 0 in LSB position).
  247|       |      // On big-endian systems, memcpy produces native (big-endian) values,
  248|       |      // so we need to byteswap to match the packed representation.
  249|    411|      if constexpr (N == 8) {
  250|    411|         static constexpr auto packed = pack<Str, 8>();
  251|    411|         uint64_t in;
  252|    411|         std::memcpy(&in, other, 8);
  253|       |         if constexpr (std::endian::native == std::endian::big) {
  254|       |            in = std::byteswap(in);
  255|       |         }
  256|    411|         return (in == packed);
  257|       |      }
  258|       |      else if constexpr (N == 7) {
  259|       |         static constexpr auto packed = pack_buffered<Str, 8>();
  260|       |         uint64_t in{};
  261|       |         std::memcpy(&in, other, 7);
  262|       |         if constexpr (std::endian::native == std::endian::big) {
  263|       |            in = std::byteswap(in);
  264|       |         }
  265|       |         return (in == packed);
  266|       |      }
  267|       |      else if constexpr (N == 6) {
  268|       |         static constexpr auto packed = pack_buffered<Str, 8>();
  269|       |         uint64_t in{};
  270|       |         std::memcpy(&in, other, 6);
  271|       |         if constexpr (std::endian::native == std::endian::big) {
  272|       |            in = std::byteswap(in);
  273|       |         }
  274|       |         return (in == packed);
  275|       |      }
  276|       |      else if constexpr (N == 5) {
  277|       |         static constexpr auto packed = pack<Str, 4>();
  278|       |         uint32_t in;
  279|       |         std::memcpy(&in, other, 4);
  280|       |         if constexpr (std::endian::native == std::endian::big) {
  281|       |            in = std::byteswap(in);
  282|       |         }
  283|       |         return (in == packed) & (Str[4] == other[4]);
  284|       |      }
  285|       |      else if constexpr (N == 4) {
  286|       |         static constexpr auto packed = pack<Str, 4>();
  287|       |         uint32_t in;
  288|       |         std::memcpy(&in, other, 4);
  289|       |         if constexpr (std::endian::native == std::endian::big) {
  290|       |            in = std::byteswap(in);
  291|       |         }
  292|       |         return (in == packed);
  293|       |      }
  294|       |      else if constexpr (N == 3) {
  295|       |         static constexpr auto packed = pack<Str, 2>();
  296|       |         uint16_t in;
  297|       |         std::memcpy(&in, other, 2);
  298|       |         if constexpr (std::endian::native == std::endian::big) {
  299|       |            in = std::byteswap(in);
  300|       |         }
  301|       |         return (in == packed) & (Str[2] == other[2]);
  302|       |      }
  303|       |      else if constexpr (N == 2) {
  304|       |         static constexpr auto packed = pack<Str, 2>();
  305|       |         uint16_t in;
  306|       |         std::memcpy(&in, other, 2);
  307|       |         if constexpr (std::endian::native == std::endian::big) {
  308|       |            in = std::byteswap(in);
  309|       |         }
  310|       |         return (in == packed);
  311|       |      }
  312|       |      else if constexpr (N == 1) {
  313|       |         return Str[0] == other[0];
  314|       |      }
  315|       |      else if constexpr (N == 0) {
  316|       |         return true;
  317|       |      }
  318|       |      else {
  319|       |         // Clang and GCC optimize this extremely well for constexpr std::string_view
  320|       |         // Packing data can create more binary on GCC
  321|       |         // The other cases probably aren't needed as compiler explorer shows them optimized equally well as memcmp
  322|       |         return 0 == std::memcmp(Str.data(), other, N);
  323|       |      }
  324|    411|   }
_ZN3glz10comparitorIL_ZZNS_12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiELm9ERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT2_OT4_OT5_OT6_DpOT3_E15KeyWithEndQuoteELm6EcEEbPKT1_:
  245|  8.22k|   {
  246|       |      // pack() builds values in little-endian order (byte 0 in LSB position).
  247|       |      // On big-endian systems, memcpy produces native (big-endian) values,
  248|       |      // so we need to byteswap to match the packed representation.
  249|       |      if constexpr (N == 8) {
  250|       |         static constexpr auto packed = pack<Str, 8>();
  251|       |         uint64_t in;
  252|       |         std::memcpy(&in, other, 8);
  253|       |         if constexpr (std::endian::native == std::endian::big) {
  254|       |            in = std::byteswap(in);
  255|       |         }
  256|       |         return (in == packed);
  257|       |      }
  258|       |      else if constexpr (N == 7) {
  259|       |         static constexpr auto packed = pack_buffered<Str, 8>();
  260|       |         uint64_t in{};
  261|       |         std::memcpy(&in, other, 7);
  262|       |         if constexpr (std::endian::native == std::endian::big) {
  263|       |            in = std::byteswap(in);
  264|       |         }
  265|       |         return (in == packed);
  266|       |      }
  267|  8.22k|      else if constexpr (N == 6) {
  268|  8.22k|         static constexpr auto packed = pack_buffered<Str, 8>();
  269|  8.22k|         uint64_t in{};
  270|  8.22k|         std::memcpy(&in, other, 6);
  271|       |         if constexpr (std::endian::native == std::endian::big) {
  272|       |            in = std::byteswap(in);
  273|       |         }
  274|  8.22k|         return (in == packed);
  275|       |      }
  276|       |      else if constexpr (N == 5) {
  277|       |         static constexpr auto packed = pack<Str, 4>();
  278|       |         uint32_t in;
  279|       |         std::memcpy(&in, other, 4);
  280|       |         if constexpr (std::endian::native == std::endian::big) {
  281|       |            in = std::byteswap(in);
  282|       |         }
  283|       |         return (in == packed) & (Str[4] == other[4]);
  284|       |      }
  285|       |      else if constexpr (N == 4) {
  286|       |         static constexpr auto packed = pack<Str, 4>();
  287|       |         uint32_t in;
  288|       |         std::memcpy(&in, other, 4);
  289|       |         if constexpr (std::endian::native == std::endian::big) {
  290|       |            in = std::byteswap(in);
  291|       |         }
  292|       |         return (in == packed);
  293|       |      }
  294|       |      else if constexpr (N == 3) {
  295|       |         static constexpr auto packed = pack<Str, 2>();
  296|       |         uint16_t in;
  297|       |         std::memcpy(&in, other, 2);
  298|       |         if constexpr (std::endian::native == std::endian::big) {
  299|       |            in = std::byteswap(in);
  300|       |         }
  301|       |         return (in == packed) & (Str[2] == other[2]);
  302|       |      }
  303|       |      else if constexpr (N == 2) {
  304|       |         static constexpr auto packed = pack<Str, 2>();
  305|       |         uint16_t in;
  306|       |         std::memcpy(&in, other, 2);
  307|       |         if constexpr (std::endian::native == std::endian::big) {
  308|       |            in = std::byteswap(in);
  309|       |         }
  310|       |         return (in == packed);
  311|       |      }
  312|       |      else if constexpr (N == 1) {
  313|       |         return Str[0] == other[0];
  314|       |      }
  315|       |      else if constexpr (N == 0) {
  316|       |         return true;
  317|       |      }
  318|       |      else {
  319|       |         // Clang and GCC optimize this extremely well for constexpr std::string_view
  320|       |         // Packing data can create more binary on GCC
  321|       |         // The other cases probably aren't needed as compiler explorer shows them optimized equally well as memcmp
  322|       |         return 0 == std::memcmp(Str.data(), other, N);
  323|       |      }
  324|  8.22k|   }
_ZN3glz10comparitorIL_ZZNS_12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiELm10ERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT2_OT4_OT5_OT6_DpOT3_E15KeyWithEndQuoteELm9EcEEbPKT1_:
  245|     97|   {
  246|       |      // pack() builds values in little-endian order (byte 0 in LSB position).
  247|       |      // On big-endian systems, memcpy produces native (big-endian) values,
  248|       |      // so we need to byteswap to match the packed representation.
  249|       |      if constexpr (N == 8) {
  250|       |         static constexpr auto packed = pack<Str, 8>();
  251|       |         uint64_t in;
  252|       |         std::memcpy(&in, other, 8);
  253|       |         if constexpr (std::endian::native == std::endian::big) {
  254|       |            in = std::byteswap(in);
  255|       |         }
  256|       |         return (in == packed);
  257|       |      }
  258|       |      else if constexpr (N == 7) {
  259|       |         static constexpr auto packed = pack_buffered<Str, 8>();
  260|       |         uint64_t in{};
  261|       |         std::memcpy(&in, other, 7);
  262|       |         if constexpr (std::endian::native == std::endian::big) {
  263|       |            in = std::byteswap(in);
  264|       |         }
  265|       |         return (in == packed);
  266|       |      }
  267|       |      else if constexpr (N == 6) {
  268|       |         static constexpr auto packed = pack_buffered<Str, 8>();
  269|       |         uint64_t in{};
  270|       |         std::memcpy(&in, other, 6);
  271|       |         if constexpr (std::endian::native == std::endian::big) {
  272|       |            in = std::byteswap(in);
  273|       |         }
  274|       |         return (in == packed);
  275|       |      }
  276|       |      else if constexpr (N == 5) {
  277|       |         static constexpr auto packed = pack<Str, 4>();
  278|       |         uint32_t in;
  279|       |         std::memcpy(&in, other, 4);
  280|       |         if constexpr (std::endian::native == std::endian::big) {
  281|       |            in = std::byteswap(in);
  282|       |         }
  283|       |         return (in == packed) & (Str[4] == other[4]);
  284|       |      }
  285|       |      else if constexpr (N == 4) {
  286|       |         static constexpr auto packed = pack<Str, 4>();
  287|       |         uint32_t in;
  288|       |         std::memcpy(&in, other, 4);
  289|       |         if constexpr (std::endian::native == std::endian::big) {
  290|       |            in = std::byteswap(in);
  291|       |         }
  292|       |         return (in == packed);
  293|       |      }
  294|       |      else if constexpr (N == 3) {
  295|       |         static constexpr auto packed = pack<Str, 2>();
  296|       |         uint16_t in;
  297|       |         std::memcpy(&in, other, 2);
  298|       |         if constexpr (std::endian::native == std::endian::big) {
  299|       |            in = std::byteswap(in);
  300|       |         }
  301|       |         return (in == packed) & (Str[2] == other[2]);
  302|       |      }
  303|       |      else if constexpr (N == 2) {
  304|       |         static constexpr auto packed = pack<Str, 2>();
  305|       |         uint16_t in;
  306|       |         std::memcpy(&in, other, 2);
  307|       |         if constexpr (std::endian::native == std::endian::big) {
  308|       |            in = std::byteswap(in);
  309|       |         }
  310|       |         return (in == packed);
  311|       |      }
  312|       |      else if constexpr (N == 1) {
  313|       |         return Str[0] == other[0];
  314|       |      }
  315|       |      else if constexpr (N == 0) {
  316|       |         return true;
  317|       |      }
  318|     97|      else {
  319|       |         // Clang and GCC optimize this extremely well for constexpr std::string_view
  320|       |         // Packing data can create more binary on GCC
  321|       |         // The other cases probably aren't needed as compiler explorer shows them optimized equally well as memcmp
  322|     97|         return 0 == std::memcmp(Str.data(), other, N);
  323|     97|      }
  324|     97|   }
_ZN3glz10comparitorIL_ZZNS_12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiELm11ERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT2_OT4_OT5_OT6_DpOT3_E15KeyWithEndQuoteELm6EcEEbPKT1_:
  245|     60|   {
  246|       |      // pack() builds values in little-endian order (byte 0 in LSB position).
  247|       |      // On big-endian systems, memcpy produces native (big-endian) values,
  248|       |      // so we need to byteswap to match the packed representation.
  249|       |      if constexpr (N == 8) {
  250|       |         static constexpr auto packed = pack<Str, 8>();
  251|       |         uint64_t in;
  252|       |         std::memcpy(&in, other, 8);
  253|       |         if constexpr (std::endian::native == std::endian::big) {
  254|       |            in = std::byteswap(in);
  255|       |         }
  256|       |         return (in == packed);
  257|       |      }
  258|       |      else if constexpr (N == 7) {
  259|       |         static constexpr auto packed = pack_buffered<Str, 8>();
  260|       |         uint64_t in{};
  261|       |         std::memcpy(&in, other, 7);
  262|       |         if constexpr (std::endian::native == std::endian::big) {
  263|       |            in = std::byteswap(in);
  264|       |         }
  265|       |         return (in == packed);
  266|       |      }
  267|     60|      else if constexpr (N == 6) {
  268|     60|         static constexpr auto packed = pack_buffered<Str, 8>();
  269|     60|         uint64_t in{};
  270|     60|         std::memcpy(&in, other, 6);
  271|       |         if constexpr (std::endian::native == std::endian::big) {
  272|       |            in = std::byteswap(in);
  273|       |         }
  274|     60|         return (in == packed);
  275|       |      }
  276|       |      else if constexpr (N == 5) {
  277|       |         static constexpr auto packed = pack<Str, 4>();
  278|       |         uint32_t in;
  279|       |         std::memcpy(&in, other, 4);
  280|       |         if constexpr (std::endian::native == std::endian::big) {
  281|       |            in = std::byteswap(in);
  282|       |         }
  283|       |         return (in == packed) & (Str[4] == other[4]);
  284|       |      }
  285|       |      else if constexpr (N == 4) {
  286|       |         static constexpr auto packed = pack<Str, 4>();
  287|       |         uint32_t in;
  288|       |         std::memcpy(&in, other, 4);
  289|       |         if constexpr (std::endian::native == std::endian::big) {
  290|       |            in = std::byteswap(in);
  291|       |         }
  292|       |         return (in == packed);
  293|       |      }
  294|       |      else if constexpr (N == 3) {
  295|       |         static constexpr auto packed = pack<Str, 2>();
  296|       |         uint16_t in;
  297|       |         std::memcpy(&in, other, 2);
  298|       |         if constexpr (std::endian::native == std::endian::big) {
  299|       |            in = std::byteswap(in);
  300|       |         }
  301|       |         return (in == packed) & (Str[2] == other[2]);
  302|       |      }
  303|       |      else if constexpr (N == 2) {
  304|       |         static constexpr auto packed = pack<Str, 2>();
  305|       |         uint16_t in;
  306|       |         std::memcpy(&in, other, 2);
  307|       |         if constexpr (std::endian::native == std::endian::big) {
  308|       |            in = std::byteswap(in);
  309|       |         }
  310|       |         return (in == packed);
  311|       |      }
  312|       |      else if constexpr (N == 1) {
  313|       |         return Str[0] == other[0];
  314|       |      }
  315|       |      else if constexpr (N == 0) {
  316|       |         return true;
  317|       |      }
  318|       |      else {
  319|       |         // Clang and GCC optimize this extremely well for constexpr std::string_view
  320|       |         // Packing data can create more binary on GCC
  321|       |         // The other cases probably aren't needed as compiler explorer shows them optimized equally well as memcmp
  322|       |         return 0 == std::memcmp(Str.data(), other, N);
  323|       |      }
  324|     60|   }
_ZN3glz10comparitorIL_ZZNS_12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiELm12ERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT2_OT4_OT5_OT6_DpOT3_E15KeyWithEndQuoteELm6EcEEbPKT1_:
  245|    160|   {
  246|       |      // pack() builds values in little-endian order (byte 0 in LSB position).
  247|       |      // On big-endian systems, memcpy produces native (big-endian) values,
  248|       |      // so we need to byteswap to match the packed representation.
  249|       |      if constexpr (N == 8) {
  250|       |         static constexpr auto packed = pack<Str, 8>();
  251|       |         uint64_t in;
  252|       |         std::memcpy(&in, other, 8);
  253|       |         if constexpr (std::endian::native == std::endian::big) {
  254|       |            in = std::byteswap(in);
  255|       |         }
  256|       |         return (in == packed);
  257|       |      }
  258|       |      else if constexpr (N == 7) {
  259|       |         static constexpr auto packed = pack_buffered<Str, 8>();
  260|       |         uint64_t in{};
  261|       |         std::memcpy(&in, other, 7);
  262|       |         if constexpr (std::endian::native == std::endian::big) {
  263|       |            in = std::byteswap(in);
  264|       |         }
  265|       |         return (in == packed);
  266|       |      }
  267|    160|      else if constexpr (N == 6) {
  268|    160|         static constexpr auto packed = pack_buffered<Str, 8>();
  269|    160|         uint64_t in{};
  270|    160|         std::memcpy(&in, other, 6);
  271|       |         if constexpr (std::endian::native == std::endian::big) {
  272|       |            in = std::byteswap(in);
  273|       |         }
  274|    160|         return (in == packed);
  275|       |      }
  276|       |      else if constexpr (N == 5) {
  277|       |         static constexpr auto packed = pack<Str, 4>();
  278|       |         uint32_t in;
  279|       |         std::memcpy(&in, other, 4);
  280|       |         if constexpr (std::endian::native == std::endian::big) {
  281|       |            in = std::byteswap(in);
  282|       |         }
  283|       |         return (in == packed) & (Str[4] == other[4]);
  284|       |      }
  285|       |      else if constexpr (N == 4) {
  286|       |         static constexpr auto packed = pack<Str, 4>();
  287|       |         uint32_t in;
  288|       |         std::memcpy(&in, other, 4);
  289|       |         if constexpr (std::endian::native == std::endian::big) {
  290|       |            in = std::byteswap(in);
  291|       |         }
  292|       |         return (in == packed);
  293|       |      }
  294|       |      else if constexpr (N == 3) {
  295|       |         static constexpr auto packed = pack<Str, 2>();
  296|       |         uint16_t in;
  297|       |         std::memcpy(&in, other, 2);
  298|       |         if constexpr (std::endian::native == std::endian::big) {
  299|       |            in = std::byteswap(in);
  300|       |         }
  301|       |         return (in == packed) & (Str[2] == other[2]);
  302|       |      }
  303|       |      else if constexpr (N == 2) {
  304|       |         static constexpr auto packed = pack<Str, 2>();
  305|       |         uint16_t in;
  306|       |         std::memcpy(&in, other, 2);
  307|       |         if constexpr (std::endian::native == std::endian::big) {
  308|       |            in = std::byteswap(in);
  309|       |         }
  310|       |         return (in == packed);
  311|       |      }
  312|       |      else if constexpr (N == 1) {
  313|       |         return Str[0] == other[0];
  314|       |      }
  315|       |      else if constexpr (N == 0) {
  316|       |         return true;
  317|       |      }
  318|       |      else {
  319|       |         // Clang and GCC optimize this extremely well for constexpr std::string_view
  320|       |         // Packing data can create more binary on GCC
  321|       |         // The other cases probably aren't needed as compiler explorer shows them optimized equally well as memcmp
  322|       |         return 0 == std::memcmp(Str.data(), other, N);
  323|       |      }
  324|    160|   }
_ZN3glz10comparitorIL_ZZNS_5matchITnNS_14string_literalEXtlNS2_ILm5EEEtlA5_cLc110ELc117ELc108ELc108EEEETnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEETkNS_10is_contextERNS_7contextERPKcS9_Qntcl15check_is_paddedT0_EEEvOT1_OT2_T3_E1SELm4EcEEbPKSB_:
  245|    692|   {
  246|       |      // pack() builds values in little-endian order (byte 0 in LSB position).
  247|       |      // On big-endian systems, memcpy produces native (big-endian) values,
  248|       |      // so we need to byteswap to match the packed representation.
  249|       |      if constexpr (N == 8) {
  250|       |         static constexpr auto packed = pack<Str, 8>();
  251|       |         uint64_t in;
  252|       |         std::memcpy(&in, other, 8);
  253|       |         if constexpr (std::endian::native == std::endian::big) {
  254|       |            in = std::byteswap(in);
  255|       |         }
  256|       |         return (in == packed);
  257|       |      }
  258|       |      else if constexpr (N == 7) {
  259|       |         static constexpr auto packed = pack_buffered<Str, 8>();
  260|       |         uint64_t in{};
  261|       |         std::memcpy(&in, other, 7);
  262|       |         if constexpr (std::endian::native == std::endian::big) {
  263|       |            in = std::byteswap(in);
  264|       |         }
  265|       |         return (in == packed);
  266|       |      }
  267|       |      else if constexpr (N == 6) {
  268|       |         static constexpr auto packed = pack_buffered<Str, 8>();
  269|       |         uint64_t in{};
  270|       |         std::memcpy(&in, other, 6);
  271|       |         if constexpr (std::endian::native == std::endian::big) {
  272|       |            in = std::byteswap(in);
  273|       |         }
  274|       |         return (in == packed);
  275|       |      }
  276|       |      else if constexpr (N == 5) {
  277|       |         static constexpr auto packed = pack<Str, 4>();
  278|       |         uint32_t in;
  279|       |         std::memcpy(&in, other, 4);
  280|       |         if constexpr (std::endian::native == std::endian::big) {
  281|       |            in = std::byteswap(in);
  282|       |         }
  283|       |         return (in == packed) & (Str[4] == other[4]);
  284|       |      }
  285|    692|      else if constexpr (N == 4) {
  286|    692|         static constexpr auto packed = pack<Str, 4>();
  287|    692|         uint32_t in;
  288|    692|         std::memcpy(&in, other, 4);
  289|       |         if constexpr (std::endian::native == std::endian::big) {
  290|       |            in = std::byteswap(in);
  291|       |         }
  292|    692|         return (in == packed);
  293|       |      }
  294|       |      else if constexpr (N == 3) {
  295|       |         static constexpr auto packed = pack<Str, 2>();
  296|       |         uint16_t in;
  297|       |         std::memcpy(&in, other, 2);
  298|       |         if constexpr (std::endian::native == std::endian::big) {
  299|       |            in = std::byteswap(in);
  300|       |         }
  301|       |         return (in == packed) & (Str[2] == other[2]);
  302|       |      }
  303|       |      else if constexpr (N == 2) {
  304|       |         static constexpr auto packed = pack<Str, 2>();
  305|       |         uint16_t in;
  306|       |         std::memcpy(&in, other, 2);
  307|       |         if constexpr (std::endian::native == std::endian::big) {
  308|       |            in = std::byteswap(in);
  309|       |         }
  310|       |         return (in == packed);
  311|       |      }
  312|       |      else if constexpr (N == 1) {
  313|       |         return Str[0] == other[0];
  314|       |      }
  315|       |      else if constexpr (N == 0) {
  316|       |         return true;
  317|       |      }
  318|       |      else {
  319|       |         // Clang and GCC optimize this extremely well for constexpr std::string_view
  320|       |         // Packing data can create more binary on GCC
  321|       |         // The other cases probably aren't needed as compiler explorer shows them optimized equally well as memcmp
  322|       |         return 0 == std::memcmp(Str.data(), other, N);
  323|       |      }
  324|    692|   }
_ZN3glz10comparitorIL_ZZNS_12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENS_3rpc18request_envelope_tELm0ERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT2_OT4_OT5_OT6_DpOT3_E15KeyWithEndQuoteELm8EcEEbPKT1_:
  245|  63.9k|   {
  246|       |      // pack() builds values in little-endian order (byte 0 in LSB position).
  247|       |      // On big-endian systems, memcpy produces native (big-endian) values,
  248|       |      // so we need to byteswap to match the packed representation.
  249|  63.9k|      if constexpr (N == 8) {
  250|  63.9k|         static constexpr auto packed = pack<Str, 8>();
  251|  63.9k|         uint64_t in;
  252|  63.9k|         std::memcpy(&in, other, 8);
  253|       |         if constexpr (std::endian::native == std::endian::big) {
  254|       |            in = std::byteswap(in);
  255|       |         }
  256|  63.9k|         return (in == packed);
  257|       |      }
  258|       |      else if constexpr (N == 7) {
  259|       |         static constexpr auto packed = pack_buffered<Str, 8>();
  260|       |         uint64_t in{};
  261|       |         std::memcpy(&in, other, 7);
  262|       |         if constexpr (std::endian::native == std::endian::big) {
  263|       |            in = std::byteswap(in);
  264|       |         }
  265|       |         return (in == packed);
  266|       |      }
  267|       |      else if constexpr (N == 6) {
  268|       |         static constexpr auto packed = pack_buffered<Str, 8>();
  269|       |         uint64_t in{};
  270|       |         std::memcpy(&in, other, 6);
  271|       |         if constexpr (std::endian::native == std::endian::big) {
  272|       |            in = std::byteswap(in);
  273|       |         }
  274|       |         return (in == packed);
  275|       |      }
  276|       |      else if constexpr (N == 5) {
  277|       |         static constexpr auto packed = pack<Str, 4>();
  278|       |         uint32_t in;
  279|       |         std::memcpy(&in, other, 4);
  280|       |         if constexpr (std::endian::native == std::endian::big) {
  281|       |            in = std::byteswap(in);
  282|       |         }
  283|       |         return (in == packed) & (Str[4] == other[4]);
  284|       |      }
  285|       |      else if constexpr (N == 4) {
  286|       |         static constexpr auto packed = pack<Str, 4>();
  287|       |         uint32_t in;
  288|       |         std::memcpy(&in, other, 4);
  289|       |         if constexpr (std::endian::native == std::endian::big) {
  290|       |            in = std::byteswap(in);
  291|       |         }
  292|       |         return (in == packed);
  293|       |      }
  294|       |      else if constexpr (N == 3) {
  295|       |         static constexpr auto packed = pack<Str, 2>();
  296|       |         uint16_t in;
  297|       |         std::memcpy(&in, other, 2);
  298|       |         if constexpr (std::endian::native == std::endian::big) {
  299|       |            in = std::byteswap(in);
  300|       |         }
  301|       |         return (in == packed) & (Str[2] == other[2]);
  302|       |      }
  303|       |      else if constexpr (N == 2) {
  304|       |         static constexpr auto packed = pack<Str, 2>();
  305|       |         uint16_t in;
  306|       |         std::memcpy(&in, other, 2);
  307|       |         if constexpr (std::endian::native == std::endian::big) {
  308|       |            in = std::byteswap(in);
  309|       |         }
  310|       |         return (in == packed);
  311|       |      }
  312|       |      else if constexpr (N == 1) {
  313|       |         return Str[0] == other[0];
  314|       |      }
  315|       |      else if constexpr (N == 0) {
  316|       |         return true;
  317|       |      }
  318|       |      else {
  319|       |         // Clang and GCC optimize this extremely well for constexpr std::string_view
  320|       |         // Packing data can create more binary on GCC
  321|       |         // The other cases probably aren't needed as compiler explorer shows them optimized equally well as memcmp
  322|       |         return 0 == std::memcmp(Str.data(), other, N);
  323|       |      }
  324|  63.9k|   }
_ZN3glz10comparitorIL_ZZNS_12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENS_3rpc18request_envelope_tELm1ERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT2_OT4_OT5_OT6_DpOT3_E15KeyWithEndQuoteELm7EcEEbPKT1_:
  245|  51.4k|   {
  246|       |      // pack() builds values in little-endian order (byte 0 in LSB position).
  247|       |      // On big-endian systems, memcpy produces native (big-endian) values,
  248|       |      // so we need to byteswap to match the packed representation.
  249|       |      if constexpr (N == 8) {
  250|       |         static constexpr auto packed = pack<Str, 8>();
  251|       |         uint64_t in;
  252|       |         std::memcpy(&in, other, 8);
  253|       |         if constexpr (std::endian::native == std::endian::big) {
  254|       |            in = std::byteswap(in);
  255|       |         }
  256|       |         return (in == packed);
  257|       |      }
  258|  51.4k|      else if constexpr (N == 7) {
  259|  51.4k|         static constexpr auto packed = pack_buffered<Str, 8>();
  260|  51.4k|         uint64_t in{};
  261|  51.4k|         std::memcpy(&in, other, 7);
  262|       |         if constexpr (std::endian::native == std::endian::big) {
  263|       |            in = std::byteswap(in);
  264|       |         }
  265|  51.4k|         return (in == packed);
  266|       |      }
  267|       |      else if constexpr (N == 6) {
  268|       |         static constexpr auto packed = pack_buffered<Str, 8>();
  269|       |         uint64_t in{};
  270|       |         std::memcpy(&in, other, 6);
  271|       |         if constexpr (std::endian::native == std::endian::big) {
  272|       |            in = std::byteswap(in);
  273|       |         }
  274|       |         return (in == packed);
  275|       |      }
  276|       |      else if constexpr (N == 5) {
  277|       |         static constexpr auto packed = pack<Str, 4>();
  278|       |         uint32_t in;
  279|       |         std::memcpy(&in, other, 4);
  280|       |         if constexpr (std::endian::native == std::endian::big) {
  281|       |            in = std::byteswap(in);
  282|       |         }
  283|       |         return (in == packed) & (Str[4] == other[4]);
  284|       |      }
  285|       |      else if constexpr (N == 4) {
  286|       |         static constexpr auto packed = pack<Str, 4>();
  287|       |         uint32_t in;
  288|       |         std::memcpy(&in, other, 4);
  289|       |         if constexpr (std::endian::native == std::endian::big) {
  290|       |            in = std::byteswap(in);
  291|       |         }
  292|       |         return (in == packed);
  293|       |      }
  294|       |      else if constexpr (N == 3) {
  295|       |         static constexpr auto packed = pack<Str, 2>();
  296|       |         uint16_t in;
  297|       |         std::memcpy(&in, other, 2);
  298|       |         if constexpr (std::endian::native == std::endian::big) {
  299|       |            in = std::byteswap(in);
  300|       |         }
  301|       |         return (in == packed) & (Str[2] == other[2]);
  302|       |      }
  303|       |      else if constexpr (N == 2) {
  304|       |         static constexpr auto packed = pack<Str, 2>();
  305|       |         uint16_t in;
  306|       |         std::memcpy(&in, other, 2);
  307|       |         if constexpr (std::endian::native == std::endian::big) {
  308|       |            in = std::byteswap(in);
  309|       |         }
  310|       |         return (in == packed);
  311|       |      }
  312|       |      else if constexpr (N == 1) {
  313|       |         return Str[0] == other[0];
  314|       |      }
  315|       |      else if constexpr (N == 0) {
  316|       |         return true;
  317|       |      }
  318|       |      else {
  319|       |         // Clang and GCC optimize this extremely well for constexpr std::string_view
  320|       |         // Packing data can create more binary on GCC
  321|       |         // The other cases probably aren't needed as compiler explorer shows them optimized equally well as memcmp
  322|       |         return 0 == std::memcmp(Str.data(), other, N);
  323|       |      }
  324|  51.4k|   }
_ZN3glz10comparitorIL_ZZNS_12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENS_3rpc18request_envelope_tELm2ERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT2_OT4_OT5_OT6_DpOT3_E15KeyWithEndQuoteELm7EcEEbPKT1_:
  245|  36.3k|   {
  246|       |      // pack() builds values in little-endian order (byte 0 in LSB position).
  247|       |      // On big-endian systems, memcpy produces native (big-endian) values,
  248|       |      // so we need to byteswap to match the packed representation.
  249|       |      if constexpr (N == 8) {
  250|       |         static constexpr auto packed = pack<Str, 8>();
  251|       |         uint64_t in;
  252|       |         std::memcpy(&in, other, 8);
  253|       |         if constexpr (std::endian::native == std::endian::big) {
  254|       |            in = std::byteswap(in);
  255|       |         }
  256|       |         return (in == packed);
  257|       |      }
  258|  36.3k|      else if constexpr (N == 7) {
  259|  36.3k|         static constexpr auto packed = pack_buffered<Str, 8>();
  260|  36.3k|         uint64_t in{};
  261|  36.3k|         std::memcpy(&in, other, 7);
  262|       |         if constexpr (std::endian::native == std::endian::big) {
  263|       |            in = std::byteswap(in);
  264|       |         }
  265|  36.3k|         return (in == packed);
  266|       |      }
  267|       |      else if constexpr (N == 6) {
  268|       |         static constexpr auto packed = pack_buffered<Str, 8>();
  269|       |         uint64_t in{};
  270|       |         std::memcpy(&in, other, 6);
  271|       |         if constexpr (std::endian::native == std::endian::big) {
  272|       |            in = std::byteswap(in);
  273|       |         }
  274|       |         return (in == packed);
  275|       |      }
  276|       |      else if constexpr (N == 5) {
  277|       |         static constexpr auto packed = pack<Str, 4>();
  278|       |         uint32_t in;
  279|       |         std::memcpy(&in, other, 4);
  280|       |         if constexpr (std::endian::native == std::endian::big) {
  281|       |            in = std::byteswap(in);
  282|       |         }
  283|       |         return (in == packed) & (Str[4] == other[4]);
  284|       |      }
  285|       |      else if constexpr (N == 4) {
  286|       |         static constexpr auto packed = pack<Str, 4>();
  287|       |         uint32_t in;
  288|       |         std::memcpy(&in, other, 4);
  289|       |         if constexpr (std::endian::native == std::endian::big) {
  290|       |            in = std::byteswap(in);
  291|       |         }
  292|       |         return (in == packed);
  293|       |      }
  294|       |      else if constexpr (N == 3) {
  295|       |         static constexpr auto packed = pack<Str, 2>();
  296|       |         uint16_t in;
  297|       |         std::memcpy(&in, other, 2);
  298|       |         if constexpr (std::endian::native == std::endian::big) {
  299|       |            in = std::byteswap(in);
  300|       |         }
  301|       |         return (in == packed) & (Str[2] == other[2]);
  302|       |      }
  303|       |      else if constexpr (N == 2) {
  304|       |         static constexpr auto packed = pack<Str, 2>();
  305|       |         uint16_t in;
  306|       |         std::memcpy(&in, other, 2);
  307|       |         if constexpr (std::endian::native == std::endian::big) {
  308|       |            in = std::byteswap(in);
  309|       |         }
  310|       |         return (in == packed);
  311|       |      }
  312|       |      else if constexpr (N == 1) {
  313|       |         return Str[0] == other[0];
  314|       |      }
  315|       |      else if constexpr (N == 0) {
  316|       |         return true;
  317|       |      }
  318|       |      else {
  319|       |         // Clang and GCC optimize this extremely well for constexpr std::string_view
  320|       |         // Packing data can create more binary on GCC
  321|       |         // The other cases probably aren't needed as compiler explorer shows them optimized equally well as memcmp
  322|       |         return 0 == std::memcmp(Str.data(), other, N);
  323|       |      }
  324|  36.3k|   }
_ZN3glz10comparitorIL_ZZNS_12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENS_3rpc18request_envelope_tELm3ERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT2_OT4_OT5_OT6_DpOT3_E15KeyWithEndQuoteELm3EcEEbPKT1_:
  245|  95.3k|   {
  246|       |      // pack() builds values in little-endian order (byte 0 in LSB position).
  247|       |      // On big-endian systems, memcpy produces native (big-endian) values,
  248|       |      // so we need to byteswap to match the packed representation.
  249|       |      if constexpr (N == 8) {
  250|       |         static constexpr auto packed = pack<Str, 8>();
  251|       |         uint64_t in;
  252|       |         std::memcpy(&in, other, 8);
  253|       |         if constexpr (std::endian::native == std::endian::big) {
  254|       |            in = std::byteswap(in);
  255|       |         }
  256|       |         return (in == packed);
  257|       |      }
  258|       |      else if constexpr (N == 7) {
  259|       |         static constexpr auto packed = pack_buffered<Str, 8>();
  260|       |         uint64_t in{};
  261|       |         std::memcpy(&in, other, 7);
  262|       |         if constexpr (std::endian::native == std::endian::big) {
  263|       |            in = std::byteswap(in);
  264|       |         }
  265|       |         return (in == packed);
  266|       |      }
  267|       |      else if constexpr (N == 6) {
  268|       |         static constexpr auto packed = pack_buffered<Str, 8>();
  269|       |         uint64_t in{};
  270|       |         std::memcpy(&in, other, 6);
  271|       |         if constexpr (std::endian::native == std::endian::big) {
  272|       |            in = std::byteswap(in);
  273|       |         }
  274|       |         return (in == packed);
  275|       |      }
  276|       |      else if constexpr (N == 5) {
  277|       |         static constexpr auto packed = pack<Str, 4>();
  278|       |         uint32_t in;
  279|       |         std::memcpy(&in, other, 4);
  280|       |         if constexpr (std::endian::native == std::endian::big) {
  281|       |            in = std::byteswap(in);
  282|       |         }
  283|       |         return (in == packed) & (Str[4] == other[4]);
  284|       |      }
  285|       |      else if constexpr (N == 4) {
  286|       |         static constexpr auto packed = pack<Str, 4>();
  287|       |         uint32_t in;
  288|       |         std::memcpy(&in, other, 4);
  289|       |         if constexpr (std::endian::native == std::endian::big) {
  290|       |            in = std::byteswap(in);
  291|       |         }
  292|       |         return (in == packed);
  293|       |      }
  294|  95.3k|      else if constexpr (N == 3) {
  295|  95.3k|         static constexpr auto packed = pack<Str, 2>();
  296|  95.3k|         uint16_t in;
  297|  95.3k|         std::memcpy(&in, other, 2);
  298|       |         if constexpr (std::endian::native == std::endian::big) {
  299|       |            in = std::byteswap(in);
  300|       |         }
  301|  95.3k|         return (in == packed) & (Str[2] == other[2]);
  302|       |      }
  303|       |      else if constexpr (N == 2) {
  304|       |         static constexpr auto packed = pack<Str, 2>();
  305|       |         uint16_t in;
  306|       |         std::memcpy(&in, other, 2);
  307|       |         if constexpr (std::endian::native == std::endian::big) {
  308|       |            in = std::byteswap(in);
  309|       |         }
  310|       |         return (in == packed);
  311|       |      }
  312|       |      else if constexpr (N == 1) {
  313|       |         return Str[0] == other[0];
  314|       |      }
  315|       |      else if constexpr (N == 0) {
  316|       |         return true;
  317|       |      }
  318|       |      else {
  319|       |         // Clang and GCC optimize this extremely well for constexpr std::string_view
  320|       |         // Packing data can create more binary on GCC
  321|       |         // The other cases probably aren't needed as compiler explorer shows them optimized equally well as memcmp
  322|       |         return 0 == std::memcmp(Str.data(), other, N);
  323|       |      }
  324|  95.3k|   }
_ZN3glz10comparitorIL_ZZNS_5matchITnNS_14string_literalEXtlNS2_ILm5EEEtlA5_cLc110ELc117ELc108ELc108EEEETnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETkNS_10is_contextERNS_7contextERPKcS9_Qntcl15check_is_paddedT0_EEEvOT1_OT2_T3_E1SELm4EcEEbPKSB_:
  245|   224k|   {
  246|       |      // pack() builds values in little-endian order (byte 0 in LSB position).
  247|       |      // On big-endian systems, memcpy produces native (big-endian) values,
  248|       |      // so we need to byteswap to match the packed representation.
  249|       |      if constexpr (N == 8) {
  250|       |         static constexpr auto packed = pack<Str, 8>();
  251|       |         uint64_t in;
  252|       |         std::memcpy(&in, other, 8);
  253|       |         if constexpr (std::endian::native == std::endian::big) {
  254|       |            in = std::byteswap(in);
  255|       |         }
  256|       |         return (in == packed);
  257|       |      }
  258|       |      else if constexpr (N == 7) {
  259|       |         static constexpr auto packed = pack_buffered<Str, 8>();
  260|       |         uint64_t in{};
  261|       |         std::memcpy(&in, other, 7);
  262|       |         if constexpr (std::endian::native == std::endian::big) {
  263|       |            in = std::byteswap(in);
  264|       |         }
  265|       |         return (in == packed);
  266|       |      }
  267|       |      else if constexpr (N == 6) {
  268|       |         static constexpr auto packed = pack_buffered<Str, 8>();
  269|       |         uint64_t in{};
  270|       |         std::memcpy(&in, other, 6);
  271|       |         if constexpr (std::endian::native == std::endian::big) {
  272|       |            in = std::byteswap(in);
  273|       |         }
  274|       |         return (in == packed);
  275|       |      }
  276|       |      else if constexpr (N == 5) {
  277|       |         static constexpr auto packed = pack<Str, 4>();
  278|       |         uint32_t in;
  279|       |         std::memcpy(&in, other, 4);
  280|       |         if constexpr (std::endian::native == std::endian::big) {
  281|       |            in = std::byteswap(in);
  282|       |         }
  283|       |         return (in == packed) & (Str[4] == other[4]);
  284|       |      }
  285|   224k|      else if constexpr (N == 4) {
  286|   224k|         static constexpr auto packed = pack<Str, 4>();
  287|   224k|         uint32_t in;
  288|   224k|         std::memcpy(&in, other, 4);
  289|       |         if constexpr (std::endian::native == std::endian::big) {
  290|       |            in = std::byteswap(in);
  291|       |         }
  292|   224k|         return (in == packed);
  293|       |      }
  294|       |      else if constexpr (N == 3) {
  295|       |         static constexpr auto packed = pack<Str, 2>();
  296|       |         uint16_t in;
  297|       |         std::memcpy(&in, other, 2);
  298|       |         if constexpr (std::endian::native == std::endian::big) {
  299|       |            in = std::byteswap(in);
  300|       |         }
  301|       |         return (in == packed) & (Str[2] == other[2]);
  302|       |      }
  303|       |      else if constexpr (N == 2) {
  304|       |         static constexpr auto packed = pack<Str, 2>();
  305|       |         uint16_t in;
  306|       |         std::memcpy(&in, other, 2);
  307|       |         if constexpr (std::endian::native == std::endian::big) {
  308|       |            in = std::byteswap(in);
  309|       |         }
  310|       |         return (in == packed);
  311|       |      }
  312|       |      else if constexpr (N == 1) {
  313|       |         return Str[0] == other[0];
  314|       |      }
  315|       |      else if constexpr (N == 0) {
  316|       |         return true;
  317|       |      }
  318|       |      else {
  319|       |         // Clang and GCC optimize this extremely well for constexpr std::string_view
  320|       |         // Packing data can create more binary on GCC
  321|       |         // The other cases probably aren't needed as compiler explorer shows them optimized equally well as memcmp
  322|       |         return 0 == std::memcmp(Str.data(), other, N);
  323|       |      }
  324|   224k|   }
_ZN3glz10comparitorIL_ZZNS_5matchITnNS_14string_literalEXtlNS2_ILm4EEEtlA4_cLc117ELc108ELc108EEEETnDaXtlNS_22registry_validate_optsIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEEEtlS6_Lj10ELb0ELb0ELb1ELb1EELb1ELb1EEETkNS_10is_contextERNS_7contextERPKcSB_Qntcl15check_is_paddedT0_EEEvOT1_OT2_T3_E1SELm3EcEEbPKSD_:
  245|  3.32k|   {
  246|       |      // pack() builds values in little-endian order (byte 0 in LSB position).
  247|       |      // On big-endian systems, memcpy produces native (big-endian) values,
  248|       |      // so we need to byteswap to match the packed representation.
  249|       |      if constexpr (N == 8) {
  250|       |         static constexpr auto packed = pack<Str, 8>();
  251|       |         uint64_t in;
  252|       |         std::memcpy(&in, other, 8);
  253|       |         if constexpr (std::endian::native == std::endian::big) {
  254|       |            in = std::byteswap(in);
  255|       |         }
  256|       |         return (in == packed);
  257|       |      }
  258|       |      else if constexpr (N == 7) {
  259|       |         static constexpr auto packed = pack_buffered<Str, 8>();
  260|       |         uint64_t in{};
  261|       |         std::memcpy(&in, other, 7);
  262|       |         if constexpr (std::endian::native == std::endian::big) {
  263|       |            in = std::byteswap(in);
  264|       |         }
  265|       |         return (in == packed);
  266|       |      }
  267|       |      else if constexpr (N == 6) {
  268|       |         static constexpr auto packed = pack_buffered<Str, 8>();
  269|       |         uint64_t in{};
  270|       |         std::memcpy(&in, other, 6);
  271|       |         if constexpr (std::endian::native == std::endian::big) {
  272|       |            in = std::byteswap(in);
  273|       |         }
  274|       |         return (in == packed);
  275|       |      }
  276|       |      else if constexpr (N == 5) {
  277|       |         static constexpr auto packed = pack<Str, 4>();
  278|       |         uint32_t in;
  279|       |         std::memcpy(&in, other, 4);
  280|       |         if constexpr (std::endian::native == std::endian::big) {
  281|       |            in = std::byteswap(in);
  282|       |         }
  283|       |         return (in == packed) & (Str[4] == other[4]);
  284|       |      }
  285|       |      else if constexpr (N == 4) {
  286|       |         static constexpr auto packed = pack<Str, 4>();
  287|       |         uint32_t in;
  288|       |         std::memcpy(&in, other, 4);
  289|       |         if constexpr (std::endian::native == std::endian::big) {
  290|       |            in = std::byteswap(in);
  291|       |         }
  292|       |         return (in == packed);
  293|       |      }
  294|  3.32k|      else if constexpr (N == 3) {
  295|  3.32k|         static constexpr auto packed = pack<Str, 2>();
  296|  3.32k|         uint16_t in;
  297|  3.32k|         std::memcpy(&in, other, 2);
  298|       |         if constexpr (std::endian::native == std::endian::big) {
  299|       |            in = std::byteswap(in);
  300|       |         }
  301|  3.32k|         return (in == packed) & (Str[2] == other[2]);
  302|       |      }
  303|       |      else if constexpr (N == 2) {
  304|       |         static constexpr auto packed = pack<Str, 2>();
  305|       |         uint16_t in;
  306|       |         std::memcpy(&in, other, 2);
  307|       |         if constexpr (std::endian::native == std::endian::big) {
  308|       |            in = std::byteswap(in);
  309|       |         }
  310|       |         return (in == packed);
  311|       |      }
  312|       |      else if constexpr (N == 1) {
  313|       |         return Str[0] == other[0];
  314|       |      }
  315|       |      else if constexpr (N == 0) {
  316|       |         return true;
  317|       |      }
  318|       |      else {
  319|       |         // Clang and GCC optimize this extremely well for constexpr std::string_view
  320|       |         // Packing data can create more binary on GCC
  321|       |         // The other cases probably aren't needed as compiler explorer shows them optimized equally well as memcmp
  322|       |         return 0 == std::memcmp(Str.data(), other, N);
  323|       |      }
  324|  3.32k|   }
_ZN3glz10comparitorIL_ZZNS_5matchITnNS_14string_literalEXtlNS2_ILm5EEEtlA5_cLc97ELc108ELc115ELc101EEEETnDaXtlNS_22registry_validate_optsIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEEEtlS6_Lj10ELb0ELb0ELb1ELb1EELb1ELb1EEETkNS_10is_contextERNS_7contextERPKcSB_Qntcl15check_is_paddedT0_EEEvOT1_OT2_T3_E1SELm4EcEEbPKSD_:
  245|  3.43k|   {
  246|       |      // pack() builds values in little-endian order (byte 0 in LSB position).
  247|       |      // On big-endian systems, memcpy produces native (big-endian) values,
  248|       |      // so we need to byteswap to match the packed representation.
  249|       |      if constexpr (N == 8) {
  250|       |         static constexpr auto packed = pack<Str, 8>();
  251|       |         uint64_t in;
  252|       |         std::memcpy(&in, other, 8);
  253|       |         if constexpr (std::endian::native == std::endian::big) {
  254|       |            in = std::byteswap(in);
  255|       |         }
  256|       |         return (in == packed);
  257|       |      }
  258|       |      else if constexpr (N == 7) {
  259|       |         static constexpr auto packed = pack_buffered<Str, 8>();
  260|       |         uint64_t in{};
  261|       |         std::memcpy(&in, other, 7);
  262|       |         if constexpr (std::endian::native == std::endian::big) {
  263|       |            in = std::byteswap(in);
  264|       |         }
  265|       |         return (in == packed);
  266|       |      }
  267|       |      else if constexpr (N == 6) {
  268|       |         static constexpr auto packed = pack_buffered<Str, 8>();
  269|       |         uint64_t in{};
  270|       |         std::memcpy(&in, other, 6);
  271|       |         if constexpr (std::endian::native == std::endian::big) {
  272|       |            in = std::byteswap(in);
  273|       |         }
  274|       |         return (in == packed);
  275|       |      }
  276|       |      else if constexpr (N == 5) {
  277|       |         static constexpr auto packed = pack<Str, 4>();
  278|       |         uint32_t in;
  279|       |         std::memcpy(&in, other, 4);
  280|       |         if constexpr (std::endian::native == std::endian::big) {
  281|       |            in = std::byteswap(in);
  282|       |         }
  283|       |         return (in == packed) & (Str[4] == other[4]);
  284|       |      }
  285|  3.43k|      else if constexpr (N == 4) {
  286|  3.43k|         static constexpr auto packed = pack<Str, 4>();
  287|  3.43k|         uint32_t in;
  288|  3.43k|         std::memcpy(&in, other, 4);
  289|       |         if constexpr (std::endian::native == std::endian::big) {
  290|       |            in = std::byteswap(in);
  291|       |         }
  292|  3.43k|         return (in == packed);
  293|       |      }
  294|       |      else if constexpr (N == 3) {
  295|       |         static constexpr auto packed = pack<Str, 2>();
  296|       |         uint16_t in;
  297|       |         std::memcpy(&in, other, 2);
  298|       |         if constexpr (std::endian::native == std::endian::big) {
  299|       |            in = std::byteswap(in);
  300|       |         }
  301|       |         return (in == packed) & (Str[2] == other[2]);
  302|       |      }
  303|       |      else if constexpr (N == 2) {
  304|       |         static constexpr auto packed = pack<Str, 2>();
  305|       |         uint16_t in;
  306|       |         std::memcpy(&in, other, 2);
  307|       |         if constexpr (std::endian::native == std::endian::big) {
  308|       |            in = std::byteswap(in);
  309|       |         }
  310|       |         return (in == packed);
  311|       |      }
  312|       |      else if constexpr (N == 1) {
  313|       |         return Str[0] == other[0];
  314|       |      }
  315|       |      else if constexpr (N == 0) {
  316|       |         return true;
  317|       |      }
  318|       |      else {
  319|       |         // Clang and GCC optimize this extremely well for constexpr std::string_view
  320|       |         // Packing data can create more binary on GCC
  321|       |         // The other cases probably aren't needed as compiler explorer shows them optimized equally well as memcmp
  322|       |         return 0 == std::memcmp(Str.data(), other, N);
  323|       |      }
  324|  3.43k|   }
_ZN3glz10comparitorIL_ZZNS_5matchITnNS_14string_literalEXtlNS2_ILm4EEEtlA4_cLc114ELc117ELc101EEEETnDaXtlNS_22registry_validate_optsIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEEEtlS6_Lj10ELb0ELb0ELb1ELb1EELb1ELb1EEETkNS_10is_contextERNS_7contextERPKcSB_Qntcl15check_is_paddedT0_EEEvOT1_OT2_T3_E1SELm3EcEEbPKSD_:
  245|  2.50k|   {
  246|       |      // pack() builds values in little-endian order (byte 0 in LSB position).
  247|       |      // On big-endian systems, memcpy produces native (big-endian) values,
  248|       |      // so we need to byteswap to match the packed representation.
  249|       |      if constexpr (N == 8) {
  250|       |         static constexpr auto packed = pack<Str, 8>();
  251|       |         uint64_t in;
  252|       |         std::memcpy(&in, other, 8);
  253|       |         if constexpr (std::endian::native == std::endian::big) {
  254|       |            in = std::byteswap(in);
  255|       |         }
  256|       |         return (in == packed);
  257|       |      }
  258|       |      else if constexpr (N == 7) {
  259|       |         static constexpr auto packed = pack_buffered<Str, 8>();
  260|       |         uint64_t in{};
  261|       |         std::memcpy(&in, other, 7);
  262|       |         if constexpr (std::endian::native == std::endian::big) {
  263|       |            in = std::byteswap(in);
  264|       |         }
  265|       |         return (in == packed);
  266|       |      }
  267|       |      else if constexpr (N == 6) {
  268|       |         static constexpr auto packed = pack_buffered<Str, 8>();
  269|       |         uint64_t in{};
  270|       |         std::memcpy(&in, other, 6);
  271|       |         if constexpr (std::endian::native == std::endian::big) {
  272|       |            in = std::byteswap(in);
  273|       |         }
  274|       |         return (in == packed);
  275|       |      }
  276|       |      else if constexpr (N == 5) {
  277|       |         static constexpr auto packed = pack<Str, 4>();
  278|       |         uint32_t in;
  279|       |         std::memcpy(&in, other, 4);
  280|       |         if constexpr (std::endian::native == std::endian::big) {
  281|       |            in = std::byteswap(in);
  282|       |         }
  283|       |         return (in == packed) & (Str[4] == other[4]);
  284|       |      }
  285|       |      else if constexpr (N == 4) {
  286|       |         static constexpr auto packed = pack<Str, 4>();
  287|       |         uint32_t in;
  288|       |         std::memcpy(&in, other, 4);
  289|       |         if constexpr (std::endian::native == std::endian::big) {
  290|       |            in = std::byteswap(in);
  291|       |         }
  292|       |         return (in == packed);
  293|       |      }
  294|  2.50k|      else if constexpr (N == 3) {
  295|  2.50k|         static constexpr auto packed = pack<Str, 2>();
  296|  2.50k|         uint16_t in;
  297|  2.50k|         std::memcpy(&in, other, 2);
  298|       |         if constexpr (std::endian::native == std::endian::big) {
  299|       |            in = std::byteswap(in);
  300|       |         }
  301|  2.50k|         return (in == packed) & (Str[2] == other[2]);
  302|       |      }
  303|       |      else if constexpr (N == 2) {
  304|       |         static constexpr auto packed = pack<Str, 2>();
  305|       |         uint16_t in;
  306|       |         std::memcpy(&in, other, 2);
  307|       |         if constexpr (std::endian::native == std::endian::big) {
  308|       |            in = std::byteswap(in);
  309|       |         }
  310|       |         return (in == packed);
  311|       |      }
  312|       |      else if constexpr (N == 1) {
  313|       |         return Str[0] == other[0];
  314|       |      }
  315|       |      else if constexpr (N == 0) {
  316|       |         return true;
  317|       |      }
  318|       |      else {
  319|       |         // Clang and GCC optimize this extremely well for constexpr std::string_view
  320|       |         // Packing data can create more binary on GCC
  321|       |         // The other cases probably aren't needed as compiler explorer shows them optimized equally well as memcmp
  322|       |         return 0 == std::memcmp(Str.data(), other, N);
  323|       |      }
  324|  2.50k|   }
_ZN3glz10comparitorIL_ZZZNS_13get_view_jsonITnNS_14string_literalEXtlNS2_ILm4EEEtlA4_cLc47ELc105ELc100EEEETnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETkNS_10contiguousERNSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEEEDaOT1_ENKUlTnmvE_clILm0EEEDavE3keyELm2EcEEbPKSC_:
  245|  21.8k|   {
  246|       |      // pack() builds values in little-endian order (byte 0 in LSB position).
  247|       |      // On big-endian systems, memcpy produces native (big-endian) values,
  248|       |      // so we need to byteswap to match the packed representation.
  249|       |      if constexpr (N == 8) {
  250|       |         static constexpr auto packed = pack<Str, 8>();
  251|       |         uint64_t in;
  252|       |         std::memcpy(&in, other, 8);
  253|       |         if constexpr (std::endian::native == std::endian::big) {
  254|       |            in = std::byteswap(in);
  255|       |         }
  256|       |         return (in == packed);
  257|       |      }
  258|       |      else if constexpr (N == 7) {
  259|       |         static constexpr auto packed = pack_buffered<Str, 8>();
  260|       |         uint64_t in{};
  261|       |         std::memcpy(&in, other, 7);
  262|       |         if constexpr (std::endian::native == std::endian::big) {
  263|       |            in = std::byteswap(in);
  264|       |         }
  265|       |         return (in == packed);
  266|       |      }
  267|       |      else if constexpr (N == 6) {
  268|       |         static constexpr auto packed = pack_buffered<Str, 8>();
  269|       |         uint64_t in{};
  270|       |         std::memcpy(&in, other, 6);
  271|       |         if constexpr (std::endian::native == std::endian::big) {
  272|       |            in = std::byteswap(in);
  273|       |         }
  274|       |         return (in == packed);
  275|       |      }
  276|       |      else if constexpr (N == 5) {
  277|       |         static constexpr auto packed = pack<Str, 4>();
  278|       |         uint32_t in;
  279|       |         std::memcpy(&in, other, 4);
  280|       |         if constexpr (std::endian::native == std::endian::big) {
  281|       |            in = std::byteswap(in);
  282|       |         }
  283|       |         return (in == packed) & (Str[4] == other[4]);
  284|       |      }
  285|       |      else if constexpr (N == 4) {
  286|       |         static constexpr auto packed = pack<Str, 4>();
  287|       |         uint32_t in;
  288|       |         std::memcpy(&in, other, 4);
  289|       |         if constexpr (std::endian::native == std::endian::big) {
  290|       |            in = std::byteswap(in);
  291|       |         }
  292|       |         return (in == packed);
  293|       |      }
  294|       |      else if constexpr (N == 3) {
  295|       |         static constexpr auto packed = pack<Str, 2>();
  296|       |         uint16_t in;
  297|       |         std::memcpy(&in, other, 2);
  298|       |         if constexpr (std::endian::native == std::endian::big) {
  299|       |            in = std::byteswap(in);
  300|       |         }
  301|       |         return (in == packed) & (Str[2] == other[2]);
  302|       |      }
  303|  21.8k|      else if constexpr (N == 2) {
  304|  21.8k|         static constexpr auto packed = pack<Str, 2>();
  305|  21.8k|         uint16_t in;
  306|  21.8k|         std::memcpy(&in, other, 2);
  307|       |         if constexpr (std::endian::native == std::endian::big) {
  308|       |            in = std::byteswap(in);
  309|       |         }
  310|  21.8k|         return (in == packed);
  311|       |      }
  312|       |      else if constexpr (N == 1) {
  313|       |         return Str[0] == other[0];
  314|       |      }
  315|       |      else if constexpr (N == 0) {
  316|       |         return true;
  317|       |      }
  318|       |      else {
  319|       |         // Clang and GCC optimize this extremely well for constexpr std::string_view
  320|       |         // Packing data can create more binary on GCC
  321|       |         // The other cases probably aren't needed as compiler explorer shows them optimized equally well as memcmp
  322|       |         return 0 == std::memcmp(Str.data(), other, N);
  323|       |      }
  324|  21.8k|   }
_ZN3glz10comparitorIL_ZZNS_5matchITnNS_14string_literalEXtlNS2_ILm4EEEtlA4_cLc117ELc108ELc108EEEETnDaXtlZNS_11parse_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETkNS_10is_contextERNS_7contextERPKcSA_EEDaOT0_OT1_T2_E21opts_validate_skippedtlS6_Lj10ELb0ELb0ELb1ELb1EELb1EEETkNS_10is_contextES8_SB_SA_Qntcl15check_is_paddedT0_EEEvSF_OSG_T3_E1SELm3EcEEbPKSE_:
  245|    543|   {
  246|       |      // pack() builds values in little-endian order (byte 0 in LSB position).
  247|       |      // On big-endian systems, memcpy produces native (big-endian) values,
  248|       |      // so we need to byteswap to match the packed representation.
  249|       |      if constexpr (N == 8) {
  250|       |         static constexpr auto packed = pack<Str, 8>();
  251|       |         uint64_t in;
  252|       |         std::memcpy(&in, other, 8);
  253|       |         if constexpr (std::endian::native == std::endian::big) {
  254|       |            in = std::byteswap(in);
  255|       |         }
  256|       |         return (in == packed);
  257|       |      }
  258|       |      else if constexpr (N == 7) {
  259|       |         static constexpr auto packed = pack_buffered<Str, 8>();
  260|       |         uint64_t in{};
  261|       |         std::memcpy(&in, other, 7);
  262|       |         if constexpr (std::endian::native == std::endian::big) {
  263|       |            in = std::byteswap(in);
  264|       |         }
  265|       |         return (in == packed);
  266|       |      }
  267|       |      else if constexpr (N == 6) {
  268|       |         static constexpr auto packed = pack_buffered<Str, 8>();
  269|       |         uint64_t in{};
  270|       |         std::memcpy(&in, other, 6);
  271|       |         if constexpr (std::endian::native == std::endian::big) {
  272|       |            in = std::byteswap(in);
  273|       |         }
  274|       |         return (in == packed);
  275|       |      }
  276|       |      else if constexpr (N == 5) {
  277|       |         static constexpr auto packed = pack<Str, 4>();
  278|       |         uint32_t in;
  279|       |         std::memcpy(&in, other, 4);
  280|       |         if constexpr (std::endian::native == std::endian::big) {
  281|       |            in = std::byteswap(in);
  282|       |         }
  283|       |         return (in == packed) & (Str[4] == other[4]);
  284|       |      }
  285|       |      else if constexpr (N == 4) {
  286|       |         static constexpr auto packed = pack<Str, 4>();
  287|       |         uint32_t in;
  288|       |         std::memcpy(&in, other, 4);
  289|       |         if constexpr (std::endian::native == std::endian::big) {
  290|       |            in = std::byteswap(in);
  291|       |         }
  292|       |         return (in == packed);
  293|       |      }
  294|    543|      else if constexpr (N == 3) {
  295|    543|         static constexpr auto packed = pack<Str, 2>();
  296|    543|         uint16_t in;
  297|    543|         std::memcpy(&in, other, 2);
  298|       |         if constexpr (std::endian::native == std::endian::big) {
  299|       |            in = std::byteswap(in);
  300|       |         }
  301|    543|         return (in == packed) & (Str[2] == other[2]);
  302|       |      }
  303|       |      else if constexpr (N == 2) {
  304|       |         static constexpr auto packed = pack<Str, 2>();
  305|       |         uint16_t in;
  306|       |         std::memcpy(&in, other, 2);
  307|       |         if constexpr (std::endian::native == std::endian::big) {
  308|       |            in = std::byteswap(in);
  309|       |         }
  310|       |         return (in == packed);
  311|       |      }
  312|       |      else if constexpr (N == 1) {
  313|       |         return Str[0] == other[0];
  314|       |      }
  315|       |      else if constexpr (N == 0) {
  316|       |         return true;
  317|       |      }
  318|       |      else {
  319|       |         // Clang and GCC optimize this extremely well for constexpr std::string_view
  320|       |         // Packing data can create more binary on GCC
  321|       |         // The other cases probably aren't needed as compiler explorer shows them optimized equally well as memcmp
  322|       |         return 0 == std::memcmp(Str.data(), other, N);
  323|       |      }
  324|    543|   }
_ZN3glz10comparitorIL_ZZNS_5matchITnNS_14string_literalEXtlNS2_ILm5EEEtlA5_cLc97ELc108ELc115ELc101EEEETnDaXtlZNS_11parse_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETkNS_10is_contextERNS_7contextERPKcSA_EEDaOT0_OT1_T2_E21opts_validate_skippedtlS6_Lj10ELb0ELb0ELb1ELb1EELb1EEETkNS_10is_contextES8_SB_SA_Qntcl15check_is_paddedT0_EEEvSF_OSG_T3_E1SELm4EcEEbPKSE_:
  245|  1.17k|   {
  246|       |      // pack() builds values in little-endian order (byte 0 in LSB position).
  247|       |      // On big-endian systems, memcpy produces native (big-endian) values,
  248|       |      // so we need to byteswap to match the packed representation.
  249|       |      if constexpr (N == 8) {
  250|       |         static constexpr auto packed = pack<Str, 8>();
  251|       |         uint64_t in;
  252|       |         std::memcpy(&in, other, 8);
  253|       |         if constexpr (std::endian::native == std::endian::big) {
  254|       |            in = std::byteswap(in);
  255|       |         }
  256|       |         return (in == packed);
  257|       |      }
  258|       |      else if constexpr (N == 7) {
  259|       |         static constexpr auto packed = pack_buffered<Str, 8>();
  260|       |         uint64_t in{};
  261|       |         std::memcpy(&in, other, 7);
  262|       |         if constexpr (std::endian::native == std::endian::big) {
  263|       |            in = std::byteswap(in);
  264|       |         }
  265|       |         return (in == packed);
  266|       |      }
  267|       |      else if constexpr (N == 6) {
  268|       |         static constexpr auto packed = pack_buffered<Str, 8>();
  269|       |         uint64_t in{};
  270|       |         std::memcpy(&in, other, 6);
  271|       |         if constexpr (std::endian::native == std::endian::big) {
  272|       |            in = std::byteswap(in);
  273|       |         }
  274|       |         return (in == packed);
  275|       |      }
  276|       |      else if constexpr (N == 5) {
  277|       |         static constexpr auto packed = pack<Str, 4>();
  278|       |         uint32_t in;
  279|       |         std::memcpy(&in, other, 4);
  280|       |         if constexpr (std::endian::native == std::endian::big) {
  281|       |            in = std::byteswap(in);
  282|       |         }
  283|       |         return (in == packed) & (Str[4] == other[4]);
  284|       |      }
  285|  1.17k|      else if constexpr (N == 4) {
  286|  1.17k|         static constexpr auto packed = pack<Str, 4>();
  287|  1.17k|         uint32_t in;
  288|  1.17k|         std::memcpy(&in, other, 4);
  289|       |         if constexpr (std::endian::native == std::endian::big) {
  290|       |            in = std::byteswap(in);
  291|       |         }
  292|  1.17k|         return (in == packed);
  293|       |      }
  294|       |      else if constexpr (N == 3) {
  295|       |         static constexpr auto packed = pack<Str, 2>();
  296|       |         uint16_t in;
  297|       |         std::memcpy(&in, other, 2);
  298|       |         if constexpr (std::endian::native == std::endian::big) {
  299|       |            in = std::byteswap(in);
  300|       |         }
  301|       |         return (in == packed) & (Str[2] == other[2]);
  302|       |      }
  303|       |      else if constexpr (N == 2) {
  304|       |         static constexpr auto packed = pack<Str, 2>();
  305|       |         uint16_t in;
  306|       |         std::memcpy(&in, other, 2);
  307|       |         if constexpr (std::endian::native == std::endian::big) {
  308|       |            in = std::byteswap(in);
  309|       |         }
  310|       |         return (in == packed);
  311|       |      }
  312|       |      else if constexpr (N == 1) {
  313|       |         return Str[0] == other[0];
  314|       |      }
  315|       |      else if constexpr (N == 0) {
  316|       |         return true;
  317|       |      }
  318|       |      else {
  319|       |         // Clang and GCC optimize this extremely well for constexpr std::string_view
  320|       |         // Packing data can create more binary on GCC
  321|       |         // The other cases probably aren't needed as compiler explorer shows them optimized equally well as memcmp
  322|       |         return 0 == std::memcmp(Str.data(), other, N);
  323|       |      }
  324|  1.17k|   }
_ZN3glz10comparitorIL_ZZNS_5matchITnNS_14string_literalEXtlNS2_ILm4EEEtlA4_cLc114ELc117ELc101EEEETnDaXtlZNS_11parse_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETkNS_10is_contextERNS_7contextERPKcSA_EEDaOT0_OT1_T2_E21opts_validate_skippedtlS6_Lj10ELb0ELb0ELb1ELb1EELb1EEETkNS_10is_contextES8_SB_SA_Qntcl15check_is_paddedT0_EEEvSF_OSG_T3_E1SELm3EcEEbPKSE_:
  245|    869|   {
  246|       |      // pack() builds values in little-endian order (byte 0 in LSB position).
  247|       |      // On big-endian systems, memcpy produces native (big-endian) values,
  248|       |      // so we need to byteswap to match the packed representation.
  249|       |      if constexpr (N == 8) {
  250|       |         static constexpr auto packed = pack<Str, 8>();
  251|       |         uint64_t in;
  252|       |         std::memcpy(&in, other, 8);
  253|       |         if constexpr (std::endian::native == std::endian::big) {
  254|       |            in = std::byteswap(in);
  255|       |         }
  256|       |         return (in == packed);
  257|       |      }
  258|       |      else if constexpr (N == 7) {
  259|       |         static constexpr auto packed = pack_buffered<Str, 8>();
  260|       |         uint64_t in{};
  261|       |         std::memcpy(&in, other, 7);
  262|       |         if constexpr (std::endian::native == std::endian::big) {
  263|       |            in = std::byteswap(in);
  264|       |         }
  265|       |         return (in == packed);
  266|       |      }
  267|       |      else if constexpr (N == 6) {
  268|       |         static constexpr auto packed = pack_buffered<Str, 8>();
  269|       |         uint64_t in{};
  270|       |         std::memcpy(&in, other, 6);
  271|       |         if constexpr (std::endian::native == std::endian::big) {
  272|       |            in = std::byteswap(in);
  273|       |         }
  274|       |         return (in == packed);
  275|       |      }
  276|       |      else if constexpr (N == 5) {
  277|       |         static constexpr auto packed = pack<Str, 4>();
  278|       |         uint32_t in;
  279|       |         std::memcpy(&in, other, 4);
  280|       |         if constexpr (std::endian::native == std::endian::big) {
  281|       |            in = std::byteswap(in);
  282|       |         }
  283|       |         return (in == packed) & (Str[4] == other[4]);
  284|       |      }
  285|       |      else if constexpr (N == 4) {
  286|       |         static constexpr auto packed = pack<Str, 4>();
  287|       |         uint32_t in;
  288|       |         std::memcpy(&in, other, 4);
  289|       |         if constexpr (std::endian::native == std::endian::big) {
  290|       |            in = std::byteswap(in);
  291|       |         }
  292|       |         return (in == packed);
  293|       |      }
  294|    869|      else if constexpr (N == 3) {
  295|    869|         static constexpr auto packed = pack<Str, 2>();
  296|    869|         uint16_t in;
  297|    869|         std::memcpy(&in, other, 2);
  298|       |         if constexpr (std::endian::native == std::endian::big) {
  299|       |            in = std::byteswap(in);
  300|       |         }
  301|    869|         return (in == packed) & (Str[2] == other[2]);
  302|       |      }
  303|       |      else if constexpr (N == 2) {
  304|       |         static constexpr auto packed = pack<Str, 2>();
  305|       |         uint16_t in;
  306|       |         std::memcpy(&in, other, 2);
  307|       |         if constexpr (std::endian::native == std::endian::big) {
  308|       |            in = std::byteswap(in);
  309|       |         }
  310|       |         return (in == packed);
  311|       |      }
  312|       |      else if constexpr (N == 1) {
  313|       |         return Str[0] == other[0];
  314|       |      }
  315|       |      else if constexpr (N == 0) {
  316|       |         return true;
  317|       |      }
  318|       |      else {
  319|       |         // Clang and GCC optimize this extremely well for constexpr std::string_view
  320|       |         // Packing data can create more binary on GCC
  321|       |         // The other cases probably aren't needed as compiler explorer shows them optimized equally well as memcmp
  322|       |         return 0 == std::memcmp(Str.data(), other, N);
  323|       |      }
  324|    869|   }

_ZN3glz4dumpILb1ENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEETkNS_10byte_sizedEcEEvT1_RT0_Rm:
   98|  1.14M|   {
   99|  1.14M|      if constexpr (Checked && vector_like<B>) {
  100|  1.14M|         if (ix == b.size()) [[unlikely]] {
  ------------------
  |  Branch (100:14): [True: 0, False: 1.14M]
  ------------------
  101|      0|            b.resize(b.size() == 0 ? 128 : b.size() * 2);
  ------------------
  |  Branch (101:22): [True: 0, False: 0]
  ------------------
  102|      0|         }
  103|  1.14M|      }
  104|  1.14M|      assign_maybe_cast(c, b, ix);
  105|  1.14M|      ++ix;
  106|  1.14M|   }
_ZN3glz17assign_maybe_castITkNS_10byte_sizedEcNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEvT_RT0_Rm:
   55|  1.14M|   {
   56|  1.14M|      using V = std::decay_t<decltype(b[0])>;
   57|  1.14M|      using C = std::decay_t<decltype(c)>;
   58|  1.14M|      if constexpr (std::same_as<V, C>) {
   59|  1.14M|         b[ix] = c;
   60|       |      }
   61|       |      else {
   62|       |         b[ix] = static_cast<V>(c);
   63|       |      }
   64|  1.14M|   }
_ZN3glz4dumpILb1ENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEvNS1_17basic_string_viewIcS4_EERT0_Rm:
  140|  8.60M|   {
  141|  8.60M|      const auto n = str.size();
  142|  8.60M|      if constexpr (vector_like<B>) {
  143|  8.60M|         if constexpr (Checked) {
  144|  8.60M|            const auto k = ix + n;
  145|  8.60M|            if (ix + n > b.size()) [[unlikely]] {
  ------------------
  |  Branch (145:17): [True: 0, False: 8.60M]
  ------------------
  146|      0|               b.resize(2 * k);
  147|      0|            }
  148|  8.60M|         }
  149|  8.60M|      }
  150|  8.60M|      std::memcpy(&b[ix], str.data(), n);
  151|  8.60M|      ix += n;
  152|  8.60M|   }
_ZN3glz16dump_maybe_emptyILb1ENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEvNS1_17basic_string_viewIcS4_EERT0_Rm:
  267|  4.49M|   {
  268|  4.49M|      const auto n = str.size();
  269|  4.49M|      if (n) {
  ------------------
  |  Branch (269:11): [True: 4.49M, False: 0]
  ------------------
  270|  4.49M|         if constexpr (vector_like<B>) {
  271|  4.49M|            if constexpr (Checked) {
  272|  4.49M|               const auto k = ix + n;
  273|  4.49M|               if (k > b.size()) [[unlikely]] {
  ------------------
  |  Branch (273:20): [True: 0, False: 4.49M]
  ------------------
  274|      0|                  b.resize(2 * k);
  275|      0|               }
  276|  4.49M|            }
  277|  4.49M|         }
  278|  4.49M|         std::memcpy(&b[ix], str.data(), n);
  279|  4.49M|         ix += n;
  280|  4.49M|      }
  281|  4.49M|   }
_ZN3glz5dumpnINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEETkNS_10byte_sizedEcEEvT0_mRT_Rm:
  170|   382k|   {
  171|   382k|      if constexpr (vector_like<B>) {
  172|   382k|         const auto k = ix + n;
  173|   382k|         if (k > b.size()) [[unlikely]] {
  ------------------
  |  Branch (173:14): [True: 0, False: 382k]
  ------------------
  174|      0|            b.resize(2 * k);
  175|      0|         }
  176|   382k|      }
  177|   382k|      std::memset(data_at(b, ix), c, n);
  178|   382k|      ix += n;
  179|   382k|   }
_ZN3glz7data_atINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEDaRT_m:
   71|   382k|   {
   72|       |      if constexpr (std::is_pointer_v<std::remove_cvref_t<B>>) {
   73|       |         return b + ix;
   74|       |      }
   75|   382k|      else {
   76|   382k|         static_assert(has_data<std::remove_cvref_t<B>>,
   77|   382k|                       "an output buffer must be contiguous: dump writes through memset and memcpy");
   78|   382k|         return b.data() + ix;
   79|   382k|      }
   80|   382k|   }
_ZN3glz4dumpILb0ENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEETkNS_10byte_sizedEcEEvT1_RT0_Rm:
   98|    423|   {
   99|       |      if constexpr (Checked && vector_like<B>) {
  100|       |         if (ix == b.size()) [[unlikely]] {
  101|       |            b.resize(b.size() == 0 ? 128 : b.size() * 2);
  102|       |         }
  103|       |      }
  104|    423|      assign_maybe_cast(c, b, ix);
  105|    423|      ++ix;
  106|    423|   }

_ZN3glz10fast_float4spanIKcEC2Ev:
  438|  1.82M|  constexpr span() : ptr(nullptr), length(0) {}
_ZN3glz10fast_float10is_integerIcEEbT_:
 1481|   738k|fastfloat_really_inline constexpr bool is_integer(UC c) noexcept {
 1482|   738k|  return !(c > UC('9') || c < UC('0'));
  ------------------
  |  Branch (1482:12): [True: 14, False: 738k]
  |  Branch (1482:27): [True: 25, False: 738k]
  ------------------
 1483|   738k|}
_ZN3glz10fast_float11digit_valueIcEEmT_:
 1489|  4.74M|fastfloat_really_inline constexpr uint64_t digit_value(UC c) noexcept {
 1490|  4.74M|  return uint64_t(uint8_t(c) - uint8_t('0'));
 1491|  4.74M|}
_ZN3glz10fast_float4spanIKcEC2EPS2_m:
  436|   945k|  constexpr span(T const *_ptr, size_t _length) : ptr(_ptr), length(_length) {}
_ZN3glz10fast_float26loop_parse_if_eight_digitsERPKcS2_Rm:
 1679|  32.8k|                           uint64_t &i) {
 1680|       |  // optimizes better than parse_if_eight_digits_unrolled() for UC = char.
 1681|  1.76M|  while ((std::distance(p, pend) >= 8) &&
  ------------------
  |  Branch (1681:10): [True: 1.76M, False: 1.70k]
  ------------------
 1682|  1.76M|         is_made_of_eight_digits_fast(read8_to_u64(p))) {
  ------------------
  |  Branch (1682:10): [True: 1.73M, False: 31.1k]
  ------------------
 1683|  1.73M|    i = i * 100000000 +
 1684|  1.73M|        parse_eight_digits_unrolled(read8_to_u64(
 1685|  1.73M|            p)); // in rare cases, this will overflow, but that's ok
 1686|  1.73M|    p += 8;
 1687|  1.73M|  }
 1688|  32.8k|}
_ZN3glz10fast_float28is_made_of_eight_digits_fastEm:
 1597|  1.76M|is_made_of_eight_digits_fast(uint64_t val) noexcept {
 1598|  1.76M|  return !((((val + 0x4646464646464646) | (val - 0x3030303030303030)) &
 1599|  1.76M|            0x8080808080808080));
 1600|  1.76M|}
_ZN3glz10fast_float12read8_to_u64IcEEmPKT_:
 1503|  3.86M|read8_to_u64(UC const *chars) {
 1504|  3.86M|  if (cpp20_and_in_constexpr() || !std::is_same<UC, char>::value) {
  ------------------
  |  Branch (1504:7): [Folded, False: 0]
  |  Branch (1504:35): [Folded, False: 0]
  ------------------
 1505|      0|    uint64_t val = 0;
 1506|      0|    for (int i = 0; i < 8; ++i) {
  ------------------
  |  Branch (1506:21): [True: 0, False: 0]
  ------------------
 1507|      0|      val |= uint64_t(uint8_t(*chars)) << (i * 8);
 1508|      0|      ++chars;
 1509|      0|    }
 1510|      0|    return val;
 1511|      0|  }
 1512|  3.86M|  uint64_t val;
 1513|  3.86M|  ::memcpy(&val, chars, sizeof(uint64_t));
 1514|       |#if GLZ_FASTFLOAT_IS_BIG_ENDIAN == 1
 1515|       |  // Need to read as-if the number was in little-endian order.
 1516|       |  val = byteswap(val);
 1517|       |#endif
 1518|  3.86M|  return val;
 1519|  3.86M|}
_ZN3glz10fast_float27parse_eight_digits_unrolledEm:
 1575|  2.10M|parse_eight_digits_unrolled(uint64_t val) {
 1576|  2.10M|  uint64_t const mask = 0x000000FF000000FF;
 1577|  2.10M|  uint64_t const mul1 = 0x000F424000000064; // 100 + (1000000ULL << 32)
 1578|  2.10M|  uint64_t const mul2 = 0x0000271000000001; // 1 + (10000ULL << 32)
 1579|  2.10M|  val -= 0x3030303030303030;
 1580|  2.10M|  val = (val * 10) + (val >> 8); // val = (val * 2561) >> 8;
 1581|  2.10M|  val = (((val & mask) * mul1) + (((val >> 16) & mask) * mul2)) >> 32;
 1582|  2.10M|  return uint32_t(val);
 1583|  2.10M|}
_ZNK3glz10fast_float4spanIKcE3lenEv:
  440|  82.9k|  constexpr size_t len() const noexcept { return length; }
_ZN3glz10fast_float19from_chars_advancedIdcEENS0_19from_chars_result_tIT0_EERNS0_22parsed_number_string_tIS3_EERT_:
 4249|   911k|from_chars_advanced(parsed_number_string_t<UC> &pns, T &value) noexcept {
 4250|       |
 4251|   911k|  static_assert(is_supported_float_type<T>::value,
 4252|   911k|                "only some floating-point types are supported");
 4253|   911k|  static_assert(is_supported_char_type<UC>::value,
 4254|   911k|                "only char, wchar_t, char16_t and char32_t are supported");
 4255|       |
 4256|   911k|  from_chars_result_t<UC> answer;
 4257|       |
 4258|   911k|  answer.ec = std::errc(); // be optimistic
 4259|   911k|  answer.ptr = pns.lastmatch;
 4260|       |  // The implementation of the Clinger's fast path is convoluted because
 4261|       |  // we want round-to-nearest in all cases, irrespective of the rounding mode
 4262|       |  // selected on the thread.
 4263|       |  // We proceed optimistically, assuming that detail::rounds_to_nearest()
 4264|       |  // returns true.
 4265|   911k|  if (binary_format<T>::min_exponent_fast_path() <= pns.exponent &&
  ------------------
  |  Branch (4265:7): [True: 906k, False: 5.45k]
  ------------------
 4266|   906k|      pns.exponent <= binary_format<T>::max_exponent_fast_path() &&
  ------------------
  |  Branch (4266:7): [True: 900k, False: 5.59k]
  ------------------
 4267|   900k|      !pns.too_many_digits) {
  ------------------
  |  Branch (4267:7): [True: 874k, False: 26.3k]
  ------------------
 4268|       |    // Unfortunately, the conventional Clinger's fast path is only possible
 4269|       |    // when the system rounds to the nearest float.
 4270|       |    //
 4271|       |    // We expect the next branch to almost always be selected.
 4272|       |    // We could check it first (before the previous branch), but
 4273|       |    // there might be performance advantages at having the check
 4274|       |    // be last.
 4275|   874k|    if (!cpp20_and_in_constexpr() && detail::rounds_to_nearest()) {
  ------------------
  |  Branch (4275:9): [True: 874k, Folded]
  |  Branch (4275:38): [True: 874k, False: 0]
  ------------------
 4276|       |      // We have that fegetround() == FE_TONEAREST.
 4277|       |      // Next is Clinger's fast path.
 4278|   874k|      if (pns.mantissa <= binary_format<T>::max_mantissa_fast_path()) {
  ------------------
  |  Branch (4278:11): [True: 871k, False: 2.50k]
  ------------------
 4279|   871k|        value = T(pns.mantissa);
 4280|   871k|        if (pns.exponent < 0) {
  ------------------
  |  Branch (4280:13): [True: 4.45k, False: 867k]
  ------------------
 4281|  4.45k|          value = value / binary_format<T>::exact_power_of_ten(-pns.exponent);
 4282|   867k|        } else {
 4283|   867k|          value = value * binary_format<T>::exact_power_of_ten(pns.exponent);
 4284|   867k|        }
 4285|   871k|        if (pns.negative) {
  ------------------
  |  Branch (4285:13): [True: 738k, False: 133k]
  ------------------
 4286|   738k|          value = -value;
 4287|   738k|        }
 4288|   871k|        return answer;
 4289|   871k|      }
 4290|   874k|    } else {
 4291|       |      // We do not have that fegetround() == FE_TONEAREST.
 4292|       |      // Next is a modified Clinger's fast path, inspired by Jakub Jelínek's
 4293|       |      // proposal
 4294|      0|      if (pns.exponent >= 0 &&
  ------------------
  |  Branch (4294:11): [True: 0, False: 0]
  ------------------
 4295|      0|          pns.mantissa <=
  ------------------
  |  Branch (4295:11): [True: 0, False: 0]
  ------------------
 4296|      0|              binary_format<T>::max_mantissa_fast_path(pns.exponent)) {
 4297|      0|#if defined(__clang__) || defined(GLZ_FASTFLOAT_32BIT)
 4298|       |        // Clang may map 0 to -0.0 when fegetround() == FE_DOWNWARD
 4299|      0|        if (pns.mantissa == 0) {
  ------------------
  |  Branch (4299:13): [True: 0, False: 0]
  ------------------
 4300|      0|          value = pns.negative ? T(-0.) : T(0.);
  ------------------
  |  Branch (4300:19): [True: 0, False: 0]
  ------------------
 4301|      0|          return answer;
 4302|      0|        }
 4303|      0|#endif
 4304|      0|        value = T(pns.mantissa) *
 4305|      0|                binary_format<T>::exact_power_of_ten(pns.exponent);
 4306|      0|        if (pns.negative) {
  ------------------
  |  Branch (4306:13): [True: 0, False: 0]
  ------------------
 4307|      0|          value = -value;
 4308|      0|        }
 4309|      0|        return answer;
 4310|      0|      }
 4311|      0|    }
 4312|   874k|  }
 4313|  39.8k|  adjusted_mantissa am =
 4314|  39.8k|      compute_float<binary_format<T>>(pns.exponent, pns.mantissa);
 4315|  39.8k|  if (pns.too_many_digits && am.power2 >= 0) {
  ------------------
  |  Branch (4315:7): [True: 32.6k, False: 7.22k]
  |  Branch (4315:30): [True: 32.6k, False: 0]
  ------------------
 4316|  32.6k|    if (am != compute_float<binary_format<T>>(pns.exponent, pns.mantissa + 1)) {
  ------------------
  |  Branch (4316:9): [True: 21.1k, False: 11.5k]
  ------------------
 4317|  21.1k|      am = compute_error<binary_format<T>>(pns.exponent, pns.mantissa);
 4318|  21.1k|    }
 4319|  32.6k|  }
 4320|       |  // If we called compute_float<binary_format<T>>(pns.exponent, pns.mantissa)
 4321|       |  // and we have an invalid power (am.power2 < 0), then we need to go the long
 4322|       |  // way around again. This is very uncommon.
 4323|  39.8k|  if (am.power2 < 0) {
  ------------------
  |  Branch (4323:7): [True: 21.1k, False: 18.7k]
  ------------------
 4324|  21.1k|    am = digit_comp<T>(pns, am);
 4325|  21.1k|  }
 4326|  39.8k|  to_float(pns.negative, am, value);
 4327|       |  // Test for over/underflow.
 4328|  39.8k|  if ((pns.mantissa != 0 && am.mantissa == 0 && am.power2 == 0) ||
  ------------------
  |  Branch (4328:8): [True: 39.5k, False: 332]
  |  Branch (4328:29): [True: 1.74k, False: 37.8k]
  |  Branch (4328:49): [True: 112, False: 1.63k]
  ------------------
 4329|  39.7k|      am.power2 == binary_format<T>::infinite_power()) {
  ------------------
  |  Branch (4329:7): [True: 203, False: 39.5k]
  ------------------
 4330|    315|    answer.ec = std::errc::result_out_of_range;
 4331|    315|  }
 4332|  39.8k|  return answer;
 4333|   911k|}
_ZN3glz10fast_float13binary_formatIdE22min_exponent_fast_pathEv:
  695|   911k|inline constexpr int binary_format<double>::min_exponent_fast_path() {
  696|       |#if (FLT_EVAL_METHOD != 1) && (FLT_EVAL_METHOD != 0)
  697|       |  return 0;
  698|       |#else
  699|   911k|  return -22;
  700|   911k|#endif
  701|   911k|}
_ZN3glz10fast_float13binary_formatIdE22max_exponent_fast_pathEv:
  767|   906k|inline constexpr int binary_format<double>::max_exponent_fast_path() {
  768|   906k|  return 22;
  769|   906k|}
_ZN3glz10fast_float6detail17rounds_to_nearestEv:
 4129|   874k|fastfloat_really_inline bool rounds_to_nearest() noexcept {
 4130|       |  // https://lemire.me/blog/2020/06/26/gcc-not-nearest/
 4131|       |#if (FLT_EVAL_METHOD != 1) && (FLT_EVAL_METHOD != 0)
 4132|       |  return false;
 4133|       |#endif
 4134|       |  // See
 4135|       |  // A fast function to check your floating-point rounding mode
 4136|       |  // https://lemire.me/blog/2022/11/16/a-fast-function-to-check-your-floating-point-rounding-mode/
 4137|       |  //
 4138|       |  // This function is meant to be equivalent to :
 4139|       |  // prior: #include <cfenv>
 4140|       |  //  return fegetround() == FE_TONEAREST;
 4141|       |  // However, it is expected to be much faster than the fegetround()
 4142|       |  // function call.
 4143|       |  //
 4144|       |  // The volatile keyword prevents the compiler from computing the function
 4145|       |  // at compile-time.
 4146|       |  // There might be other ways to prevent compile-time optimizations (e.g.,
 4147|       |  // asm). The value does not need to be std::numeric_limits<float>::min(), any
 4148|       |  // small value so that 1 + x should round to 1 would do (after accounting for
 4149|       |  // excess precision, as in 387 instructions).
 4150|   874k|  static float volatile fmin = (std::numeric_limits<float>::min)();
 4151|   874k|  float fmini = fmin; // we copy it so that it gets loaded at most once.
 4152|       |//
 4153|       |// Explanation:
 4154|       |// Only when fegetround() == FE_TONEAREST do we have that
 4155|       |// fmin + 1.0f == 1.0f - fmin.
 4156|       |//
 4157|       |// FE_UPWARD:
 4158|       |//  fmin + 1.0f > 1
 4159|       |//  1.0f - fmin == 1
 4160|       |//
 4161|       |// FE_DOWNWARD or  FE_TOWARDZERO:
 4162|       |//  fmin + 1.0f == 1
 4163|       |//  1.0f - fmin < 1
 4164|       |//
 4165|       |// Note: This may fail to be accurate if fast-math has been
 4166|       |// enabled, as rounding conventions may not apply.
 4167|       |#ifdef GLZ_FASTFLOAT_VISUAL_STUDIO
 4168|       |#pragma warning(push)
 4169|       |//  todo: is there a VS warning?
 4170|       |//  see
 4171|       |//  https://stackoverflow.com/questions/46079446/is-there-a-warning-for-floating-point-equality-checking-in-visual-studio-2013
 4172|       |#elif defined(__clang__)
 4173|       |#pragma clang diagnostic push
 4174|   874k|#pragma clang diagnostic ignored "-Wfloat-equal"
 4175|       |#elif defined(__GNUC__)
 4176|       |#pragma GCC diagnostic push
 4177|       |#pragma GCC diagnostic ignored "-Wfloat-equal"
 4178|       |#endif
 4179|   874k|  return (fmini + 1.0f == 1.0f - fmini);
 4180|       |#ifdef GLZ_FASTFLOAT_VISUAL_STUDIO
 4181|       |#pragma warning(pop)
 4182|       |#elif defined(__clang__)
 4183|       |#pragma clang diagnostic pop
 4184|       |#elif defined(__GNUC__)
 4185|       |#pragma GCC diagnostic pop
 4186|       |#endif
 4187|   874k|}
_ZN3glz10fast_float13binary_formatIdE22max_mantissa_fast_pathEv:
  777|   874k|inline constexpr uint64_t binary_format<double>::max_mantissa_fast_path() {
  778|   874k|  return uint64_t(2) << mantissa_explicit_bits();
  779|   874k|}
_ZN3glz10fast_float13binary_formatIdE22mantissa_explicit_bitsEv:
  713|  1.31M|inline constexpr int binary_format<double>::mantissa_explicit_bits() {
  714|  1.31M|  return 52;
  715|  1.31M|}
_ZN3glz10fast_float13binary_formatIdE18exact_power_of_tenEl:
 1057|   871k|binary_format<double>::exact_power_of_ten(int64_t power) {
 1058|       |  // Work around clang bug https://godbolt.org/z/zedh7rrhc
 1059|   871k|  return (void)powers_of_ten[0], powers_of_ten[power];
 1060|   871k|}
_ZN3glz10fast_float13compute_floatINS0_13binary_formatIdEEEENS0_17adjusted_mantissaElm:
 2852|  72.5k|compute_float(int64_t q, uint64_t w) noexcept {
 2853|  72.5k|  adjusted_mantissa answer;
 2854|  72.5k|  if ((w == 0) || (q < binary::smallest_power_of_ten())) {
  ------------------
  |  Branch (2854:7): [True: 332, False: 72.2k]
  |  Branch (2854:19): [True: 119, False: 72.1k]
  ------------------
 2855|    451|    answer.power2 = 0;
 2856|    451|    answer.mantissa = 0;
 2857|       |    // result should be zero
 2858|    451|    return answer;
 2859|    451|  }
 2860|  72.1k|  if (q > binary::largest_power_of_ten()) {
  ------------------
  |  Branch (2860:7): [True: 248, False: 71.8k]
  ------------------
 2861|       |    // we want to get infinity:
 2862|    248|    answer.power2 = binary::infinite_power();
 2863|    248|    answer.mantissa = 0;
 2864|    248|    return answer;
 2865|    248|  }
 2866|       |  // At this point in time q is in [powers::smallest_power_of_five,
 2867|       |  // powers::largest_power_of_five].
 2868|       |
 2869|       |  // We want the most significant bit of i to be 1. Shift if needed.
 2870|  71.8k|  int lz = leading_zeroes(w);
 2871|  71.8k|  w <<= lz;
 2872|       |
 2873|       |  // The required precision is binary::mantissa_explicit_bits() + 3 because
 2874|       |  // 1. We need the implicit bit
 2875|       |  // 2. We need an extra bit for rounding purposes
 2876|       |  // 3. We might lose a bit due to the "upperbit" routine (result too small,
 2877|       |  // requiring a shift)
 2878|       |
 2879|  71.8k|  value128 product =
 2880|  71.8k|      compute_product_approximation<binary::mantissa_explicit_bits() + 3>(q, w);
 2881|       |  // The computed 'product' is always sufficient.
 2882|       |  // Mathematical proof:
 2883|       |  // Noble Mushtak and Daniel Lemire, Fast Number Parsing Without Fallback (to
 2884|       |  // appear) See script/mushtak_lemire.py
 2885|       |
 2886|       |  // The "compute_product_approximation" function can be slightly slower than a
 2887|       |  // branchless approach: value128 product = compute_product(q, w); but in
 2888|       |  // practice, we can win big with the compute_product_approximation if its
 2889|       |  // additional branch is easily predicted. Which is best is data specific.
 2890|  71.8k|  int upperbit = int(product.high >> 63);
 2891|  71.8k|  int shift = upperbit + 64 - binary::mantissa_explicit_bits() - 3;
 2892|       |
 2893|  71.8k|  answer.mantissa = product.high >> shift;
 2894|       |
 2895|  71.8k|  answer.power2 = int32_t(detail::power(int32_t(q)) + upperbit - lz -
 2896|  71.8k|                          binary::minimum_exponent());
 2897|  71.8k|  if (answer.power2 <= 0) { // we have a subnormal?
  ------------------
  |  Branch (2897:7): [True: 3.02k, False: 68.8k]
  ------------------
 2898|       |    // Here have that answer.power2 <= 0 so -answer.power2 >= 0
 2899|  3.02k|    if (-answer.power2 + 1 >=
  ------------------
  |  Branch (2899:9): [True: 5, False: 3.02k]
  ------------------
 2900|  3.02k|        64) { // if we have more than 64 bits below the minimum exponent, you
 2901|       |              // have a zero for sure.
 2902|      5|      answer.power2 = 0;
 2903|      5|      answer.mantissa = 0;
 2904|       |      // result should be zero
 2905|      5|      return answer;
 2906|      5|    }
 2907|       |    // next line is safe because -answer.power2 + 1 < 64
 2908|  3.02k|    answer.mantissa >>= -answer.power2 + 1;
 2909|       |    // Thankfully, we can't have both "round-to-even" and subnormals because
 2910|       |    // "round-to-even" only occurs for powers close to 0 in the 32-bit and
 2911|       |    // and 64-bit case (with no more than 19 digits).
 2912|  3.02k|    answer.mantissa += (answer.mantissa & 1); // round up
 2913|  3.02k|    answer.mantissa >>= 1;
 2914|       |    // There is a weird scenario where we don't have a subnormal but just.
 2915|       |    // Suppose we start with 2.2250738585072013e-308, we end up
 2916|       |    // with 0x3fffffffffffff x 2^-1023-53 which is technically subnormal
 2917|       |    // whereas 0x40000000000000 x 2^-1023-53  is normal. Now, we need to round
 2918|       |    // up 0x3fffffffffffff x 2^-1023-53  and once we do, we are no longer
 2919|       |    // subnormal, but we can only know this after rounding.
 2920|       |    // So we only declare a subnormal if we are smaller than the threshold.
 2921|  3.02k|    answer.power2 =
 2922|  3.02k|        (answer.mantissa < (uint64_t(1) << binary::mantissa_explicit_bits()))
  ------------------
  |  Branch (2922:9): [True: 3.02k, False: 0]
  ------------------
 2923|  3.02k|            ? 0
 2924|  3.02k|            : 1;
 2925|  3.02k|    return answer;
 2926|  3.02k|  }
 2927|       |
 2928|       |  // usually, we round *up*, but if we fall right in between and and we have an
 2929|       |  // even basis, we need to round down
 2930|       |  // We are only concerned with the cases where 5**q fits in single 64-bit word.
 2931|  68.8k|  if ((product.low <= 1) && (q >= binary::min_exponent_round_to_even()) &&
  ------------------
  |  Branch (2931:7): [True: 31.8k, False: 36.9k]
  |  Branch (2931:29): [True: 31.0k, False: 761]
  ------------------
 2932|  31.0k|      (q <= binary::max_exponent_round_to_even()) &&
  ------------------
  |  Branch (2932:7): [True: 30.6k, False: 445]
  ------------------
 2933|  30.6k|      ((answer.mantissa & 3) == 1)) { // we may fall between two floats!
  ------------------
  |  Branch (2933:7): [True: 24.0k, False: 6.56k]
  ------------------
 2934|       |    // To be in-between two floats we need that in doing
 2935|       |    //   answer.mantissa = product.high >> (upperbit + 64 -
 2936|       |    //   binary::mantissa_explicit_bits() - 3);
 2937|       |    // ... we dropped out only zeroes. But if this happened, then we can go
 2938|       |    // back!!!
 2939|  24.0k|    if ((answer.mantissa << shift) == product.high) {
  ------------------
  |  Branch (2939:9): [True: 12.2k, False: 11.8k]
  ------------------
 2940|  12.2k|      answer.mantissa &= ~uint64_t(1); // flip it so that we do not round up
 2941|  12.2k|    }
 2942|  24.0k|  }
 2943|       |
 2944|  68.8k|  answer.mantissa += (answer.mantissa & 1); // round up
 2945|  68.8k|  answer.mantissa >>= 1;
 2946|  68.8k|  if (answer.mantissa >= (uint64_t(2) << binary::mantissa_explicit_bits())) {
  ------------------
  |  Branch (2946:7): [True: 1.47k, False: 67.3k]
  ------------------
 2947|  1.47k|    answer.mantissa = (uint64_t(1) << binary::mantissa_explicit_bits());
 2948|  1.47k|    answer.power2++; // undo previous addition
 2949|  1.47k|  }
 2950|       |
 2951|  68.8k|  answer.mantissa &= ~(uint64_t(1) << binary::mantissa_explicit_bits());
 2952|  68.8k|  if (answer.power2 >= binary::infinite_power()) { // infinity
  ------------------
  |  Branch (2952:7): [True: 12, False: 68.8k]
  ------------------
 2953|     12|    answer.power2 = binary::infinite_power();
 2954|     12|    answer.mantissa = 0;
 2955|     12|  }
 2956|  68.8k|  return answer;
 2957|  71.8k|}
_ZN3glz10fast_float17adjusted_mantissaC2Ev:
  568|   114k|  adjusted_mantissa() = default;
_ZN3glz10fast_float13binary_formatIdE21smallest_power_of_tenEv:
 1077|  72.2k|inline constexpr int binary_format<double>::smallest_power_of_ten() {
 1078|  72.2k|  return -342;
 1079|  72.2k|}
_ZN3glz10fast_float13binary_formatIdE20largest_power_of_tenEv:
 1068|  72.1k|template <> inline constexpr int binary_format<double>::largest_power_of_ten() {
 1069|  72.1k|  return 308;
 1070|  72.1k|}
_ZN3glz10fast_float14leading_zeroesEm:
  488|   100k|leading_zeroes(uint64_t input_num) {
  489|   100k|  assert(input_num > 0);
  ------------------
  |  Branch (489:3): [True: 100k, False: 0]
  ------------------
  490|   100k|  if (cpp20_and_in_constexpr()) {
  ------------------
  |  Branch (490:7): [Folded, False: 100k]
  ------------------
  491|      0|    return leading_zeroes_generic(input_num);
  492|      0|  }
  493|       |#ifdef GLZ_FASTFLOAT_VISUAL_STUDIO
  494|       |#if defined(_M_X64) || defined(_M_ARM64)
  495|       |  unsigned long leading_zero = 0;
  496|       |  // Search the mask data from most significant bit (MSB)
  497|       |  // to least significant bit (LSB) for a set bit (1).
  498|       |  _BitScanReverse64(&leading_zero, input_num);
  499|       |  return (int)(63 - leading_zero);
  500|       |#else
  501|       |  return leading_zeroes_generic(input_num);
  502|       |#endif
  503|       |#else
  504|   100k|  return __builtin_clzll(input_num);
  505|   100k|#endif
  506|   100k|}
_ZN3glz10fast_float29compute_product_approximationILi55EEENS0_8value128Elm:
 2771|  93.0k|compute_product_approximation(int64_t q, uint64_t w) {
 2772|  93.0k|  int const index = 2 * int(q - powers::smallest_power_of_five);
 2773|       |  // For small values of q, e.g., q in [0,27], the answer is always exact
 2774|       |  // because The line value128 firstproduct = full_multiplication(w,
 2775|       |  // power_of_five_128[index]); gives the exact answer.
 2776|  93.0k|  value128 firstproduct =
 2777|  93.0k|      full_multiplication(w, powers::power_of_five_128[index]);
 2778|  93.0k|  static_assert((bit_precision >= 0) && (bit_precision <= 64),
 2779|  93.0k|                " precision should  be in (0,64]");
 2780|  93.0k|  constexpr uint64_t precision_mask =
 2781|  93.0k|      (bit_precision < 64) ? (uint64_t(0xFFFFFFFFFFFFFFFF) >> bit_precision)
  ------------------
  |  Branch (2781:7): [True: 0, Folded]
  ------------------
 2782|  93.0k|                           : uint64_t(0xFFFFFFFFFFFFFFFF);
 2783|  93.0k|  if ((firstproduct.high & precision_mask) ==
  ------------------
  |  Branch (2783:7): [True: 8.55k, False: 84.4k]
  ------------------
 2784|  93.0k|      precision_mask) { // could further guard with  (lower + w < lower)
 2785|       |    // regarding the second product, we only need secondproduct.high, but our
 2786|       |    // expectation is that the compiler will optimize this extra work away if
 2787|       |    // needed.
 2788|  8.55k|    value128 secondproduct =
 2789|  8.55k|        full_multiplication(w, powers::power_of_five_128[index + 1]);
 2790|  8.55k|    firstproduct.low += secondproduct.high;
 2791|  8.55k|    if (secondproduct.high > firstproduct.low) {
  ------------------
  |  Branch (2791:9): [True: 3.36k, False: 5.18k]
  ------------------
 2792|  3.36k|      firstproduct.high++;
 2793|  3.36k|    }
 2794|  8.55k|  }
 2795|  93.0k|  return firstproduct;
 2796|  93.0k|}
_ZN3glz10fast_float19full_multiplicationEmm:
  540|   101k|full_multiplication(uint64_t a, uint64_t b) {
  541|   101k|  if (cpp20_and_in_constexpr()) {
  ------------------
  |  Branch (541:7): [Folded, False: 101k]
  ------------------
  542|      0|    value128 answer;
  543|      0|    answer.low = umul128_generic(a, b, &answer.high);
  544|      0|    return answer;
  545|      0|  }
  546|   101k|  value128 answer;
  547|       |#if defined(_M_ARM64) && !defined(__MINGW32__)
  548|       |  // ARM64 has native support for 64-bit multiplications, no need to emulate
  549|       |  // But MinGW on ARM64 doesn't have native support for 64-bit multiplications
  550|       |  answer.high = __umulh(a, b);
  551|       |  answer.low = a * b;
  552|       |#elif defined(GLZ_FASTFLOAT_32BIT) ||                                              \
  553|       |    (defined(_WIN64) && !defined(__clang__) && !defined(_M_ARM64))
  554|       |  answer.low = _umul128(a, b, &answer.high); // _umul128 not available on ARM64
  555|       |#elif defined(GLZ_FASTFLOAT_64BIT) && defined(__SIZEOF_INT128__)
  556|       |  __uint128_t r = ((__uint128_t)a) * b;
  557|   101k|  answer.low = uint64_t(r);
  558|   101k|  answer.high = uint64_t(r >> 64);
  559|       |#else
  560|       |  answer.low = umul128_generic(a, b, &answer.high);
  561|       |#endif
  562|   101k|  return answer;
  563|   101k|}
_ZN3glz10fast_float8value128C2Ev:
  454|   101k|  constexpr value128() : low(0), high(0) {}
_ZN3glz10fast_float6detail5powerEi:
 2814|  93.0k|constexpr fastfloat_really_inline int32_t power(int32_t q) noexcept {
 2815|  93.0k|  return (((152170 + 65536) * q) >> 16) + 63;
 2816|  93.0k|}
_ZN3glz10fast_float13binary_formatIdE16minimum_exponentEv:
  742|   114k|template <> inline constexpr int binary_format<double>::minimum_exponent() {
  743|   114k|  return -1023;
  744|   114k|}
_ZN3glz10fast_float13binary_formatIdE26min_exponent_round_to_evenEv:
  733|  31.8k|inline constexpr int binary_format<double>::min_exponent_round_to_even() {
  734|  31.8k|  return -4;
  735|  31.8k|}
_ZN3glz10fast_float13binary_formatIdE26max_exponent_round_to_evenEv:
  723|  31.0k|inline constexpr int binary_format<double>::max_exponent_round_to_even() {
  724|  31.0k|  return 23;
  725|  31.0k|}
_ZNK3glz10fast_float17adjusted_mantissaneERKS1_:
  574|  32.6k|  constexpr bool operator!=(adjusted_mantissa const &o) const {
  575|  32.6k|    return mantissa != o.mantissa || power2 != o.power2;
  ------------------
  |  Branch (575:12): [True: 21.1k, False: 11.5k]
  |  Branch (575:38): [True: 0, False: 11.5k]
  ------------------
  576|  32.6k|  }
_ZN3glz10fast_float13compute_errorINS0_13binary_formatIdEEEENS0_17adjusted_mantissaElm:
 2837|  21.1k|compute_error(int64_t q, uint64_t w) noexcept {
 2838|  21.1k|  int lz = leading_zeroes(w);
 2839|  21.1k|  w <<= lz;
 2840|  21.1k|  value128 product =
 2841|  21.1k|      compute_product_approximation<binary::mantissa_explicit_bits() + 3>(q, w);
 2842|  21.1k|  return compute_error_scaled<binary>(q, product.high, lz);
 2843|  21.1k|}
_ZN3glz10fast_float20compute_error_scaledINS0_13binary_formatIdEEEENS0_17adjusted_mantissaElmi:
 2823|  21.1k|compute_error_scaled(int64_t q, uint64_t w, int lz) noexcept {
 2824|  21.1k|  int hilz = int(w >> 63) ^ 1;
 2825|  21.1k|  adjusted_mantissa answer;
 2826|  21.1k|  answer.mantissa = w << hilz;
 2827|  21.1k|  int bias = binary::mantissa_explicit_bits() - binary::minimum_exponent();
 2828|  21.1k|  answer.power2 = int32_t(detail::power(int32_t(q)) + bias - hilz - lz - 62 +
 2829|  21.1k|                          invalid_am_bias);
 2830|  21.1k|  return answer;
 2831|  21.1k|}
_ZN3glz10fast_float10digit_compIdcEENS0_17adjusted_mantissaERNS0_22parsed_number_string_tIT0_EES2_:
 4034|  21.1k|digit_comp(parsed_number_string_t<UC> &num, adjusted_mantissa am) noexcept {
 4035|       |  // remove the invalid exponent bias
 4036|  21.1k|  am.power2 -= invalid_am_bias;
 4037|       |
 4038|  21.1k|  int32_t sci_exp = scientific_exponent(num);
 4039|  21.1k|  size_t max_digits = binary_format<T>::max_digits();
 4040|  21.1k|  size_t digits = 0;
 4041|  21.1k|  bigint bigmant;
 4042|  21.1k|  parse_mantissa(bigmant, num, max_digits, digits);
 4043|       |  // can't underflow, since digits is at most max_digits.
 4044|  21.1k|  int32_t exponent = sci_exp + 1 - int32_t(digits);
 4045|  21.1k|  if (exponent >= 0) {
  ------------------
  |  Branch (4045:7): [True: 3.91k, False: 17.2k]
  ------------------
 4046|  3.91k|    return positive_digit_comp<T>(bigmant, exponent);
 4047|  17.2k|  } else {
 4048|  17.2k|    return negative_digit_comp<T>(bigmant, am, exponent);
 4049|  17.2k|  }
 4050|  21.1k|}
_ZN3glz10fast_float19scientific_exponentIcEEiRNS0_22parsed_number_string_tIT_EE:
 3640|  21.1k|scientific_exponent(parsed_number_string_t<UC> &num) noexcept {
 3641|  21.1k|  uint64_t mantissa = num.mantissa;
 3642|  21.1k|  int32_t exponent = int32_t(num.exponent);
 3643|   105k|  while (mantissa >= 10000) {
  ------------------
  |  Branch (3643:10): [True: 84.5k, False: 21.1k]
  ------------------
 3644|  84.5k|    mantissa /= 10000;
 3645|  84.5k|    exponent += 4;
 3646|  84.5k|  }
 3647|  42.2k|  while (mantissa >= 100) {
  ------------------
  |  Branch (3647:10): [True: 21.1k, False: 21.1k]
  ------------------
 3648|  21.1k|    mantissa /= 100;
 3649|  21.1k|    exponent += 2;
 3650|  21.1k|  }
 3651|  21.1k|  while (mantissa >= 10) {
  ------------------
  |  Branch (3651:10): [True: 0, False: 21.1k]
  ------------------
 3652|      0|    mantissa /= 10;
 3653|      0|    exponent += 1;
 3654|      0|  }
 3655|  21.1k|  return exponent;
 3656|  21.1k|}
_ZN3glz10fast_float13binary_formatIdE10max_digitsEv:
 1085|  21.1k|template <> inline constexpr size_t binary_format<double>::max_digits() {
 1086|  21.1k|  return 769;
 1087|  21.1k|}
_ZN3glz10fast_float6bigintC2Ev:
 3399|  21.1k|  GLZ_FASTFLOAT_CONSTEXPR20 bigint() : vec() {}
_ZN3glz10fast_float8stackvecILt62EEC2Ev:
 3006|   126k|  stackvec() = default;
_ZN3glz10fast_float14parse_mantissaIcEEvRNS0_6bigintERNS0_22parsed_number_string_tIT_EEmRm:
 3859|  21.1k|               size_t max_digits, size_t &digits) noexcept {
 3860|       |  // try to minimize the number of big integer and scalar multiplication.
 3861|       |  // therefore, try to parse 8 digits at a time, and multiply by the largest
 3862|       |  // scalar value (9 or 19 digits) for each step.
 3863|  21.1k|  size_t counter = 0;
 3864|  21.1k|  digits = 0;
 3865|  21.1k|  limb value = 0;
 3866|  21.1k|#ifdef GLZ_FASTFLOAT_64BIT_LIMB
 3867|  21.1k|  size_t step = 19;
 3868|       |#else
 3869|       |  size_t step = 9;
 3870|       |#endif
 3871|       |
 3872|       |  // process all integer digits.
 3873|  21.1k|  UC const *p = num.integer.ptr;
 3874|  21.1k|  UC const *pend = p + num.integer.len();
 3875|  21.1k|  skip_zeros(p, pend);
 3876|       |  // process all digits, in increments of step per loop
 3877|  45.4k|  while (p != pend) {
  ------------------
  |  Branch (3877:10): [True: 24.3k, False: 21.1k]
  ------------------
 3878|  62.6k|    while ((std::distance(p, pend) >= 8) && (step - counter >= 8) &&
  ------------------
  |  Branch (3878:12): [True: 42.6k, False: 19.9k]
  |  Branch (3878:45): [True: 38.3k, False: 4.31k]
  ------------------
 3879|  38.3k|           (max_digits - digits >= 8)) {
  ------------------
  |  Branch (3879:12): [True: 38.3k, False: 0]
  ------------------
 3880|  38.3k|      parse_eight_digits(p, value, counter, digits);
 3881|  38.3k|    }
 3882|  92.0k|    while (counter < step && p != pend && digits < max_digits) {
  ------------------
  |  Branch (3882:12): [True: 75.2k, False: 16.8k]
  |  Branch (3882:30): [True: 67.7k, False: 7.45k]
  |  Branch (3882:43): [True: 67.7k, False: 0]
  ------------------
 3883|  67.7k|      parse_one_digit(p, value, counter, digits);
 3884|  67.7k|    }
 3885|  24.3k|    if (digits == max_digits) {
  ------------------
  |  Branch (3885:9): [True: 0, False: 24.3k]
  ------------------
 3886|       |      // add the temporary value, then check if we've truncated any digits
 3887|      0|      add_native(result, limb(powers_of_ten_uint64[counter]), value);
 3888|      0|      bool truncated = is_truncated(p, pend);
 3889|      0|      if (num.fraction.ptr != nullptr) {
  ------------------
  |  Branch (3889:11): [True: 0, False: 0]
  ------------------
 3890|      0|        truncated |= is_truncated(num.fraction);
 3891|      0|      }
 3892|      0|      if (truncated) {
  ------------------
  |  Branch (3892:11): [True: 0, False: 0]
  ------------------
 3893|      0|        round_up_bigint(result, digits);
 3894|      0|      }
 3895|      0|      return;
 3896|  24.3k|    } else {
 3897|  24.3k|      add_native(result, limb(powers_of_ten_uint64[counter]), value);
 3898|  24.3k|      counter = 0;
 3899|  24.3k|      value = 0;
 3900|  24.3k|    }
 3901|  24.3k|  }
 3902|       |
 3903|       |  // add our fraction digits, if they're available.
 3904|  21.1k|  if (num.fraction.ptr != nullptr) {
  ------------------
  |  Branch (3904:7): [True: 18.5k, False: 2.54k]
  ------------------
 3905|  18.5k|    p = num.fraction.ptr;
 3906|  18.5k|    pend = p + num.fraction.len();
 3907|  18.5k|    if (digits == 0) {
  ------------------
  |  Branch (3907:9): [True: 2.56k, False: 16.0k]
  ------------------
 3908|  2.56k|      skip_zeros(p, pend);
 3909|  2.56k|    }
 3910|       |    // process all digits, in increments of step per loop
 3911|   195k|    while (p != pend) {
  ------------------
  |  Branch (3911:12): [True: 179k, False: 15.8k]
  ------------------
 3912|   515k|      while ((std::distance(p, pend) >= 8) && (step - counter >= 8) &&
  ------------------
  |  Branch (3912:14): [True: 497k, False: 18.1k]
  |  Branch (3912:47): [True: 337k, False: 159k]
  ------------------
 3913|   337k|             (max_digits - digits >= 8)) {
  ------------------
  |  Branch (3913:14): [True: 335k, False: 1.94k]
  ------------------
 3914|   335k|        parse_eight_digits(p, value, counter, digits);
 3915|   335k|      }
 3916|   722k|      while (counter < step && p != pend && digits < max_digits) {
  ------------------
  |  Branch (3916:14): [True: 560k, False: 161k]
  |  Branch (3916:32): [True: 544k, False: 15.7k]
  |  Branch (3916:45): [True: 542k, False: 2.29k]
  ------------------
 3917|   542k|        parse_one_digit(p, value, counter, digits);
 3918|   542k|      }
 3919|   179k|      if (digits == max_digits) {
  ------------------
  |  Branch (3919:11): [True: 2.73k, False: 177k]
  ------------------
 3920|       |        // add the temporary value, then check if we've truncated any digits
 3921|  2.73k|        add_native(result, limb(powers_of_ten_uint64[counter]), value);
 3922|  2.73k|        bool truncated = is_truncated(p, pend);
 3923|  2.73k|        if (truncated) {
  ------------------
  |  Branch (3923:13): [True: 1.85k, False: 876]
  ------------------
 3924|  1.85k|          round_up_bigint(result, digits);
 3925|  1.85k|        }
 3926|  2.73k|        return;
 3927|   177k|      } else {
 3928|   177k|        add_native(result, limb(powers_of_ten_uint64[counter]), value);
 3929|   177k|        counter = 0;
 3930|   177k|        value = 0;
 3931|   177k|      }
 3932|   179k|    }
 3933|  18.5k|  }
 3934|       |
 3935|  18.4k|  if (counter != 0) {
  ------------------
  |  Branch (3935:7): [True: 0, False: 18.4k]
  ------------------
 3936|      0|    add_native(result, limb(powers_of_ten_uint64[counter]), value);
 3937|      0|  }
 3938|  18.4k|}
_ZN3glz10fast_float10skip_zerosIcEEvRPKT_S4_:
 3773|  23.7k|skip_zeros(UC const *&first, UC const *last) noexcept {
 3774|  23.7k|  uint64_t val;
 3775|  56.7k|  while (!cpp20_and_in_constexpr() &&
  ------------------
  |  Branch (3775:10): [True: 56.7k, Folded]
  ------------------
 3776|  56.7k|         std::distance(first, last) >= int_cmp_len<UC>()) {
  ------------------
  |  Branch (3776:10): [True: 52.4k, False: 4.26k]
  ------------------
 3777|  52.4k|    ::memcpy(&val, first, sizeof(uint64_t));
 3778|  52.4k|    if (val != int_cmp_zeros<UC>()) {
  ------------------
  |  Branch (3778:9): [True: 19.4k, False: 33.0k]
  ------------------
 3779|  19.4k|      break;
 3780|  19.4k|    }
 3781|  33.0k|    first += int_cmp_len<UC>();
 3782|  33.0k|  }
 3783|  30.6k|  while (first != last) {
  ------------------
  |  Branch (3783:10): [True: 28.0k, False: 2.56k]
  ------------------
 3784|  28.0k|    if (*first != UC('0')) {
  ------------------
  |  Branch (3784:9): [True: 21.1k, False: 6.93k]
  ------------------
 3785|  21.1k|      break;
 3786|  21.1k|    }
 3787|  6.93k|    first++;
 3788|  6.93k|  }
 3789|  23.7k|}
_ZN3glz10fast_float11int_cmp_lenIcEEiv:
 1180|   210k|template <typename UC> constexpr int int_cmp_len() {
 1181|   210k|  return sizeof(uint64_t) / sizeof(UC);
 1182|   210k|}
_ZN3glz10fast_float13int_cmp_zerosIcEEmv:
 1170|   112k|template <typename UC> constexpr uint64_t int_cmp_zeros() {
 1171|   112k|  static_assert((sizeof(UC) == 1) || (sizeof(UC) == 2) || (sizeof(UC) == 4),
 1172|   112k|                "Unsupported character size");
 1173|   112k|  return (sizeof(UC) == 1) ? 0x3030303030303030
  ------------------
  |  Branch (1173:10): [True: 112k, Folded]
  ------------------
 1174|   112k|         : (sizeof(UC) == 2)
  ------------------
  |  Branch (1174:12): [Folded, False: 0]
  ------------------
 1175|      0|             ? (uint64_t(UC('0')) << 48 | uint64_t(UC('0')) << 32 |
 1176|      0|                uint64_t(UC('0')) << 16 | UC('0'))
 1177|      0|             : (uint64_t(UC('0')) << 32 | UC('0'));
 1178|   112k|}
_ZN3glz10fast_float18parse_eight_digitsIcEEvRPKT_RmS6_S6_:
 3824|   374k|                   size_t &count) noexcept {
 3825|   374k|  value = value * 100000000 + parse_eight_digits_unrolled(p);
 3826|   374k|  p += 8;
 3827|   374k|  counter += 8;
 3828|   374k|  count += 8;
 3829|   374k|}
_ZN3glz10fast_float27parse_eight_digits_unrolledIcEEjPKT_:
 1588|   374k|parse_eight_digits_unrolled(UC const *chars) noexcept {
 1589|   374k|  if (cpp20_and_in_constexpr() || !has_simd_opt<UC>()) {
  ------------------
  |  Branch (1589:7): [Folded, False: 0]
  |  Branch (1589:35): [True: 0, Folded]
  ------------------
 1590|   374k|    return parse_eight_digits_unrolled(read8_to_u64(chars)); // truncation okay
 1591|   374k|  }
 1592|      0|  return parse_eight_digits_unrolled(simd_read8_to_u64(chars));
 1593|   374k|}
_ZN3glz10fast_float15parse_one_digitIcEEvRPKT_RmS6_S6_:
 3834|   609k|                size_t &count) noexcept {
 3835|   609k|  value = value * 10 + limb(*p - UC('0'));
 3836|   609k|  p++;
 3837|   609k|  counter++;
 3838|   609k|  count++;
 3839|   609k|}
_ZN3glz10fast_float10add_nativeERNS0_6bigintEmm:
 3842|   206k|add_native(bigint &big, limb power, limb value) noexcept {
 3843|   206k|  big.mul(power);
 3844|   206k|  big.add(value);
 3845|   206k|}
_ZN3glz10fast_float6bigint3mulEm:
 3552|   206k|  GLZ_FASTFLOAT_CONSTEXPR20 bool mul(limb y) noexcept { return small_mul(vec, y); }
_ZN3glz10fast_float9small_mulILt62EEEbRNS0_8stackvecIXT_EEEm:
 3249|   354k|                                            limb y) noexcept {
 3250|   354k|  limb carry = 0;
 3251|  4.62M|  for (size_t index = 0; index < vec.len(); index++) {
  ------------------
  |  Branch (3251:26): [True: 4.27M, False: 354k]
  ------------------
 3252|  4.27M|    vec[index] = scalar_mul(vec[index], y, carry);
 3253|  4.27M|  }
 3254|   354k|  if (carry != 0) {
  ------------------
  |  Branch (3254:7): [True: 317k, False: 37.5k]
  ------------------
 3255|   317k|    GLZ_FASTFLOAT_TRY(vec.try_push(carry));
  ------------------
  |  |  354|   317k|  {                                                                            \
  |  |  355|   317k|    if (!(x))                                                                  \
  |  |  ------------------
  |  |  |  Branch (355:9): [True: 0, False: 317k]
  |  |  ------------------
  |  |  356|   317k|      return false;                                                            \
  |  |  357|   317k|  }
  ------------------
 3256|   317k|  }
 3257|   354k|  return true;
 3258|   354k|}
_ZNK3glz10fast_float8stackvecILt62EE3lenEv:
 3039|  6.18M|  constexpr size_t len() const noexcept { return length; }
_ZN3glz10fast_float10scalar_mulEmmRm:
 3196|  4.27M|scalar_mul(limb x, limb y, limb &carry) noexcept {
 3197|  4.27M|#ifdef GLZ_FASTFLOAT_64BIT_LIMB
 3198|  4.27M|#if defined(__SIZEOF_INT128__)
 3199|       |  // GCC and clang both define it as an extension.
 3200|  4.27M|  __uint128_t z = __uint128_t(x) * __uint128_t(y) + __uint128_t(carry);
 3201|  4.27M|  carry = limb(z >> limb_bits);
 3202|  4.27M|  return limb(z);
 3203|       |#else
 3204|       |  // fallback, no native 128-bit integer multiplication with carry.
 3205|       |  // on msvc, this optimizes identically, somehow.
 3206|       |  value128 z = full_multiplication(x, y);
 3207|       |  bool overflow;
 3208|       |  z.low = scalar_add(z.low, carry, overflow);
 3209|       |  z.high += uint64_t(overflow); // cannot overflow
 3210|       |  carry = z.high;
 3211|       |  return z.low;
 3212|       |#endif
 3213|       |#else
 3214|       |  uint64_t z = uint64_t(x) * uint64_t(y) + uint64_t(carry);
 3215|       |  carry = limb(z >> limb_bits);
 3216|       |  return limb(z);
 3217|       |#endif
 3218|  4.27M|}
_ZN3glz10fast_float8stackvecILt62EEixEm:
 3017|  10.6M|  GLZ_FASTFLOAT_CONSTEXPR14 limb &operator[](size_t index) noexcept {
 3018|  10.6M|    GLZ_FASTFLOAT_DEBUG_ASSERT(index < length);
  ------------------
  |  |  349|  10.6M|  { ((void)(x)); }
  ------------------
 3019|  10.6M|    return data[index];
 3020|  10.6M|  }
_ZN3glz10fast_float8stackvecILt62EE8try_pushEm:
 3052|   344k|  GLZ_FASTFLOAT_CONSTEXPR14 bool try_push(limb value) noexcept {
 3053|   344k|    if (len() < capacity()) {
  ------------------
  |  Branch (3053:9): [True: 344k, False: 0]
  ------------------
 3054|   344k|      push_unchecked(value);
 3055|   344k|      return true;
 3056|   344k|    } else {
 3057|      0|      return false;
 3058|      0|    }
 3059|   344k|  }
_ZNK3glz10fast_float8stackvecILt62EE8capacityEv:
 3043|   549k|  constexpr size_t capacity() const noexcept { return size; }
_ZN3glz10fast_float8stackvecILt62EE14push_uncheckedEm:
 3046|   362k|  GLZ_FASTFLOAT_CONSTEXPR14 void push_unchecked(limb value) noexcept {
 3047|   362k|    data[length] = value;
 3048|   362k|    length++;
 3049|   362k|  }
_ZN3glz10fast_float6bigint3addEm:
 3554|   206k|  GLZ_FASTFLOAT_CONSTEXPR20 bool add(limb y) noexcept { return small_add(vec, y); }
_ZN3glz10fast_float9small_addILt62EEEbRNS0_8stackvecIXT_EEEm:
 3242|   206k|small_add(stackvec<size> &vec, limb y) noexcept {
 3243|   206k|  return small_add_from(vec, y, 0);
 3244|   206k|}
_ZN3glz10fast_float14small_add_fromILt62EEEbRNS0_8stackvecIXT_EEEmm:
 3224|   206k|                                                 size_t start) noexcept {
 3225|   206k|  size_t index = start;
 3226|   206k|  limb carry = y;
 3227|   206k|  bool overflow;
 3228|   267k|  while (carry != 0 && index < vec.len()) {
  ------------------
  |  Branch (3228:10): [True: 83.4k, False: 184k]
  |  Branch (3228:24): [True: 61.5k, False: 21.9k]
  ------------------
 3229|  61.5k|    vec[index] = scalar_add(vec[index], carry, overflow);
 3230|  61.5k|    carry = limb(overflow);
 3231|  61.5k|    index += 1;
 3232|  61.5k|  }
 3233|   206k|  if (carry != 0) {
  ------------------
  |  Branch (3233:7): [True: 21.9k, False: 184k]
  ------------------
 3234|  21.9k|    GLZ_FASTFLOAT_TRY(vec.try_push(carry));
  ------------------
  |  |  354|  21.9k|  {                                                                            \
  |  |  355|  21.9k|    if (!(x))                                                                  \
  |  |  ------------------
  |  |  |  Branch (355:9): [True: 0, False: 21.9k]
  |  |  ------------------
  |  |  356|  21.9k|      return false;                                                            \
  |  |  357|  21.9k|  }
  ------------------
 3235|  21.9k|  }
 3236|   206k|  return true;
 3237|   206k|}
_ZN3glz10fast_float10scalar_addEmmRb:
 3176|  1.23M|scalar_add(limb x, limb y, bool &overflow) noexcept {
 3177|  1.23M|  limb z;
 3178|       |// gcc and clang
 3179|  1.23M|#if defined(__has_builtin)
 3180|  1.23M|#if __has_builtin(__builtin_add_overflow)
 3181|  1.23M|  if (!cpp20_and_in_constexpr()) {
  ------------------
  |  Branch (3181:7): [True: 1.23M, Folded]
  ------------------
 3182|  1.23M|    overflow = __builtin_add_overflow(x, y, &z);
 3183|  1.23M|    return z;
 3184|  1.23M|  }
 3185|      0|#endif
 3186|      0|#endif
 3187|       |
 3188|       |  // generic, this still optimizes correctly on MSVC.
 3189|      0|  z = x + y;
 3190|      0|  overflow = z < x;
 3191|      0|  return z;
 3192|  1.23M|}
_ZN3glz10fast_float12is_truncatedIcEEbPKT_S4_:
 3795|  2.73k|is_truncated(UC const *first, UC const *last) noexcept {
 3796|       |  // do 8-bit optimizations, can just compare to 8 literal 0s.
 3797|  2.73k|  uint64_t val;
 3798|  61.5k|  while (!cpp20_and_in_constexpr() &&
  ------------------
  |  Branch (3798:10): [True: 61.5k, Folded]
  ------------------
 3799|  61.5k|         std::distance(first, last) >= int_cmp_len<UC>()) {
  ------------------
  |  Branch (3799:10): [True: 60.0k, False: 1.56k]
  ------------------
 3800|  60.0k|    ::memcpy(&val, first, sizeof(uint64_t));
 3801|  60.0k|    if (val != int_cmp_zeros<UC>()) {
  ------------------
  |  Branch (3801:9): [True: 1.17k, False: 58.8k]
  ------------------
 3802|  1.17k|      return true;
 3803|  1.17k|    }
 3804|  58.8k|    first += int_cmp_len<UC>();
 3805|  58.8k|  }
 3806|  4.73k|  while (first != last) {
  ------------------
  |  Branch (3806:10): [True: 3.86k, False: 876]
  ------------------
 3807|  3.86k|    if (*first != UC('0')) {
  ------------------
  |  Branch (3807:9): [True: 687, False: 3.17k]
  ------------------
 3808|    687|      return true;
 3809|    687|    }
 3810|  3.17k|    ++first;
 3811|  3.17k|  }
 3812|    876|  return false;
 3813|  1.56k|}
_ZN3glz10fast_float15round_up_bigintERNS0_6bigintERm:
 3848|  1.85k|round_up_bigint(bigint &big, size_t &count) noexcept {
 3849|       |  // need to round-up the digits, but need to avoid rounding
 3850|       |  // ....9999 to ...10000, which could cause a false halfway point.
 3851|  1.85k|  add_native(big, 10, 1);
 3852|  1.85k|  count++;
 3853|  1.85k|}
_ZN3glz10fast_float19positive_digit_compIdEENS0_17adjusted_mantissaERNS0_6bigintEi:
 3942|  3.91k|positive_digit_comp(bigint &bigmant, int32_t exponent) noexcept {
 3943|  3.91k|  GLZ_FASTFLOAT_ASSERT(bigmant.pow10(uint32_t(exponent)));
  ------------------
  |  |  344|  3.91k|  { ((void)(x)); }
  ------------------
 3944|  3.91k|  adjusted_mantissa answer;
 3945|  3.91k|  bool truncated;
 3946|  3.91k|  answer.mantissa = bigmant.hi64(truncated);
 3947|  3.91k|  int bias = binary_format<T>::mantissa_explicit_bits() -
 3948|  3.91k|             binary_format<T>::minimum_exponent();
 3949|  3.91k|  answer.power2 = bigmant.bit_length() - 64 + bias;
 3950|       |
 3951|  3.91k|  round<T>(answer, [truncated](adjusted_mantissa &a, int32_t shift) {
 3952|  3.91k|    round_nearest_tie_even(
 3953|  3.91k|        a, shift,
 3954|  3.91k|        [truncated](bool is_odd, bool is_halfway, bool is_above) -> bool {
 3955|  3.91k|          return is_above || (is_halfway && truncated) ||
 3956|  3.91k|                 (is_odd && is_halfway);
 3957|  3.91k|        });
 3958|  3.91k|  });
 3959|       |
 3960|  3.91k|  return answer;
 3961|  3.91k|}
_ZN3glz10fast_float6bigint5pow10Ej:
 3591|  3.91k|  GLZ_FASTFLOAT_CONSTEXPR20 bool pow10(uint32_t exp) noexcept {
 3592|  3.91k|    GLZ_FASTFLOAT_TRY(pow5(exp));
  ------------------
  |  |  354|  3.91k|  {                                                                            \
  |  |  355|  3.91k|    if (!(x))                                                                  \
  |  |  ------------------
  |  |  |  Branch (355:9): [True: 0, False: 3.91k]
  |  |  ------------------
  |  |  356|  3.91k|      return false;                                                            \
  |  |  357|  3.91k|  }
  ------------------
 3593|  3.91k|    return pow2(exp);
 3594|  3.91k|  }
_ZN3glz10fast_float6bigint4pow5Ej:
 3560|  21.1k|  GLZ_FASTFLOAT_CONSTEXPR20 bool pow5(uint32_t exp) noexcept {
 3561|       |    // multiply by a power of 5
 3562|  21.1k|    size_t large_length = sizeof(large_power_of_5) / sizeof(limb);
 3563|  21.1k|    limb_span large = limb_span(large_power_of_5, large_length);
 3564|  43.1k|    while (exp >= large_step) {
  ------------------
  |  Branch (3564:12): [True: 21.9k, False: 21.1k]
  ------------------
 3565|  21.9k|      GLZ_FASTFLOAT_TRY(large_mul(vec, large));
  ------------------
  |  |  354|  21.9k|  {                                                                            \
  |  |  355|  21.9k|    if (!(x))                                                                  \
  |  |  ------------------
  |  |  |  Branch (355:9): [True: 0, False: 21.9k]
  |  |  ------------------
  |  |  356|  21.9k|      return false;                                                            \
  |  |  357|  21.9k|  }
  ------------------
 3566|  21.9k|      exp -= large_step;
 3567|  21.9k|    }
 3568|  21.1k|#ifdef GLZ_FASTFLOAT_64BIT_LIMB
 3569|  21.1k|    uint32_t small_step = 27;
 3570|  21.1k|    limb max_native = 7450580596923828125UL;
 3571|       |#else
 3572|       |    uint32_t small_step = 13;
 3573|       |    limb max_native = 1220703125U;
 3574|       |#endif
 3575|  41.7k|    while (exp >= small_step) {
  ------------------
  |  Branch (3575:12): [True: 20.5k, False: 21.1k]
  ------------------
 3576|  20.5k|      GLZ_FASTFLOAT_TRY(small_mul(vec, max_native));
  ------------------
  |  |  354|  20.5k|  {                                                                            \
  |  |  355|  20.5k|    if (!(x))                                                                  \
  |  |  ------------------
  |  |  |  Branch (355:9): [True: 0, False: 20.5k]
  |  |  ------------------
  |  |  356|  20.5k|      return false;                                                            \
  |  |  357|  20.5k|  }
  ------------------
 3577|  20.5k|      exp -= small_step;
 3578|  20.5k|    }
 3579|  21.1k|    if (exp != 0) {
  ------------------
  |  Branch (3579:9): [True: 18.0k, False: 3.12k]
  ------------------
 3580|       |      // Work around clang bug https://godbolt.org/z/zedh7rrhc
 3581|       |      // This is similar to https://github.com/llvm/llvm-project/issues/47746,
 3582|       |      // except the workaround described there don't work here
 3583|  18.0k|      GLZ_FASTFLOAT_TRY(small_mul(
  ------------------
  |  |  354|  18.0k|  {                                                                            \
  |  |  355|  18.0k|    if (!(x))                                                                  \
  |  |  ------------------
  |  |  |  Branch (355:9): [True: 0, False: 18.0k]
  |  |  ------------------
  |  |  356|  18.0k|      return false;                                                            \
  |  |  357|  18.0k|  }
  ------------------
 3584|  18.0k|          vec, limb(((void)small_power_of_5[0], small_power_of_5[exp]))));
 3585|  18.0k|    }
 3586|       |
 3587|  21.1k|    return true;
 3588|  21.1k|  }
_ZN3glz10fast_float4spanImEC2EPKmm:
  436|   152k|  constexpr span(T const *_ptr, size_t _length) : ptr(_ptr), length(_length) {}
_ZN3glz10fast_float9large_mulILt62EEEbRNS0_8stackvecIXT_EEENS0_4spanImEE:
 3329|  21.9k|GLZ_FASTFLOAT_CONSTEXPR20 bool large_mul(stackvec<size> &x, limb_span y) noexcept {
 3330|  21.9k|  if (y.len() == 1) {
  ------------------
  |  Branch (3330:7): [True: 0, False: 21.9k]
  ------------------
 3331|      0|    GLZ_FASTFLOAT_TRY(small_mul(x, y[0]));
  ------------------
  |  |  354|      0|  {                                                                            \
  |  |  355|      0|    if (!(x))                                                                  \
  |  |  ------------------
  |  |  |  Branch (355:9): [True: 0, False: 0]
  |  |  ------------------
  |  |  356|      0|      return false;                                                            \
  |  |  357|      0|  }
  ------------------
 3332|  21.9k|  } else {
 3333|  21.9k|    GLZ_FASTFLOAT_TRY(long_mul(x, y));
  ------------------
  |  |  354|  21.9k|  {                                                                            \
  |  |  355|  21.9k|    if (!(x))                                                                  \
  |  |  ------------------
  |  |  |  Branch (355:9): [True: 0, False: 21.9k]
  |  |  ------------------
  |  |  356|  21.9k|      return false;                                                            \
  |  |  357|  21.9k|  }
  ------------------
 3334|  21.9k|  }
 3335|  21.9k|  return true;
 3336|  21.9k|}
_ZNK3glz10fast_float4spanImE3lenEv:
  440|  1.59M|  constexpr size_t len() const noexcept { return length; }
_ZNK3glz10fast_float4spanImEixEm:
  442|   955k|  GLZ_FASTFLOAT_CONSTEXPR14 const T &operator[](size_t index) const noexcept {
  443|   955k|    GLZ_FASTFLOAT_DEBUG_ASSERT(index < length);
  ------------------
  |  |  349|   955k|  { ((void)(x)); }
  ------------------
  444|   955k|    return ptr[index];
  445|   955k|  }
_ZN3glz10fast_float8long_mulILt62EEEbRNS0_8stackvecIXT_EEENS0_4spanImEE:
 3301|  21.9k|GLZ_FASTFLOAT_CONSTEXPR20 bool long_mul(stackvec<size> &x, limb_span y) noexcept {
 3302|  21.9k|  limb_span xs = limb_span(x.data, x.len());
 3303|  21.9k|  stackvec<size> z(xs);
 3304|  21.9k|  limb_span zs = limb_span(z.data, z.len());
 3305|       |
 3306|  21.9k|  if (y.len() != 0) {
  ------------------
  |  Branch (3306:7): [True: 21.9k, False: 0]
  ------------------
 3307|  21.9k|    limb y0 = y[0];
 3308|  21.9k|    GLZ_FASTFLOAT_TRY(small_mul(x, y0));
  ------------------
  |  |  354|  21.9k|  {                                                                            \
  |  |  355|  21.9k|    if (!(x))                                                                  \
  |  |  ------------------
  |  |  |  Branch (355:9): [True: 0, False: 21.9k]
  |  |  ------------------
  |  |  356|  21.9k|      return false;                                                            \
  |  |  357|  21.9k|  }
  ------------------
 3309|   109k|    for (size_t index = 1; index < y.len(); index++) {
  ------------------
  |  Branch (3309:28): [True: 87.9k, False: 21.9k]
  ------------------
 3310|  87.9k|      limb yi = y[index];
 3311|  87.9k|      stackvec<size> zi;
 3312|  87.9k|      if (yi != 0) {
  ------------------
  |  Branch (3312:11): [True: 87.9k, False: 0]
  ------------------
 3313|       |        // re-use the same buffer throughout
 3314|  87.9k|        zi.set_len(0);
 3315|  87.9k|        GLZ_FASTFLOAT_TRY(zi.try_extend(zs));
  ------------------
  |  |  354|  87.9k|  {                                                                            \
  |  |  355|  87.9k|    if (!(x))                                                                  \
  |  |  ------------------
  |  |  |  Branch (355:9): [True: 0, False: 87.9k]
  |  |  ------------------
  |  |  356|  87.9k|      return false;                                                            \
  |  |  357|  87.9k|  }
  ------------------
 3316|  87.9k|        GLZ_FASTFLOAT_TRY(small_mul(zi, yi));
  ------------------
  |  |  354|  87.9k|  {                                                                            \
  |  |  355|  87.9k|    if (!(x))                                                                  \
  |  |  ------------------
  |  |  |  Branch (355:9): [True: 0, False: 87.9k]
  |  |  ------------------
  |  |  356|  87.9k|      return false;                                                            \
  |  |  357|  87.9k|  }
  ------------------
 3317|  87.9k|        limb_span zis = limb_span(zi.data, zi.len());
 3318|  87.9k|        GLZ_FASTFLOAT_TRY(large_add_from(x, zis, index));
  ------------------
  |  |  354|  87.9k|  {                                                                            \
  |  |  355|  87.9k|    if (!(x))                                                                  \
  |  |  ------------------
  |  |  |  Branch (355:9): [True: 0, False: 87.9k]
  |  |  ------------------
  |  |  356|  87.9k|      return false;                                                            \
  |  |  357|  87.9k|  }
  ------------------
 3319|  87.9k|      }
 3320|  87.9k|    }
 3321|  21.9k|  }
 3322|       |
 3323|  21.9k|  x.normalize();
 3324|  21.9k|  return true;
 3325|  21.9k|}
_ZN3glz10fast_float8stackvecILt62EEC2ENS0_4spanImEE:
 3013|  21.9k|  GLZ_FASTFLOAT_CONSTEXPR20 stackvec(limb_span s) {
 3014|  21.9k|    GLZ_FASTFLOAT_ASSERT(try_extend(s));
  ------------------
  |  |  344|  21.9k|  { ((void)(x)); }
  ------------------
 3015|  21.9k|  }
_ZN3glz10fast_float8stackvecILt62EE7set_lenEm:
 3035|   292k|  GLZ_FASTFLOAT_CONSTEXPR14 void set_len(size_t len) noexcept {
 3036|   292k|    length = uint16_t(len);
 3037|   292k|  }
_ZN3glz10fast_float8stackvecILt62EE10try_extendENS0_4spanImEE:
 3069|   109k|  GLZ_FASTFLOAT_CONSTEXPR20 bool try_extend(limb_span s) noexcept {
 3070|   109k|    if (len() + s.len() <= capacity()) {
  ------------------
  |  Branch (3070:9): [True: 109k, False: 0]
  ------------------
 3071|   109k|      extend_unchecked(s);
 3072|   109k|      return true;
 3073|   109k|    } else {
 3074|      0|      return false;
 3075|      0|    }
 3076|   109k|  }
_ZN3glz10fast_float8stackvecILt62EE16extend_uncheckedENS0_4spanImEE:
 3062|   109k|  GLZ_FASTFLOAT_CONSTEXPR20 void extend_unchecked(limb_span s) noexcept {
 3063|   109k|    limb *ptr = data + length;
 3064|   109k|    std::copy_n(s.ptr, s.len(), ptr);
 3065|   109k|    set_len(len() + s.len());
 3066|   109k|  }
_ZN3glz10fast_float14large_add_fromILt62EEEbRNS0_8stackvecIXT_EEENS0_4spanImEEm:
 3264|  87.9k|                                          size_t start) noexcept {
 3265|       |  // the effective x buffer is from `xstart..x.len()`, so exit early
 3266|       |  // if we can't get that current range.
 3267|  87.9k|  if (x.len() < start || y.len() > x.len() - start) {
  ------------------
  |  Branch (3267:7): [True: 0, False: 87.9k]
  |  Branch (3267:26): [True: 86.9k, False: 965]
  ------------------
 3268|  86.9k|    GLZ_FASTFLOAT_TRY(x.try_resize(y.len() + start, 0));
  ------------------
  |  |  354|  86.9k|  {                                                                            \
  |  |  355|  86.9k|    if (!(x))                                                                  \
  |  |  ------------------
  |  |  |  Branch (355:9): [True: 0, False: 86.9k]
  |  |  ------------------
  |  |  356|  86.9k|      return false;                                                            \
  |  |  357|  86.9k|  }
  ------------------
 3269|  86.9k|  }
 3270|       |
 3271|  87.9k|  bool carry = false;
 3272|   933k|  for (size_t index = 0; index < y.len(); index++) {
  ------------------
  |  Branch (3272:26): [True: 845k, False: 87.9k]
  ------------------
 3273|   845k|    limb xi = x[index + start];
 3274|   845k|    limb yi = y[index];
 3275|   845k|    bool c1 = false;
 3276|   845k|    bool c2 = false;
 3277|   845k|    xi = scalar_add(xi, yi, c1);
 3278|   845k|    if (carry) {
  ------------------
  |  Branch (3278:9): [True: 327k, False: 518k]
  ------------------
 3279|   327k|      xi = scalar_add(xi, 1, c2);
 3280|   327k|    }
 3281|   845k|    x[index + start] = xi;
 3282|   845k|    carry = c1 | c2;
 3283|   845k|  }
 3284|       |
 3285|       |  // handle overflow
 3286|  87.9k|  if (carry) {
  ------------------
  |  Branch (3286:7): [True: 0, False: 87.9k]
  ------------------
 3287|      0|    GLZ_FASTFLOAT_TRY(small_add_from(x, 1, y.len() + start));
  ------------------
  |  |  354|      0|  {                                                                            \
  |  |  355|      0|    if (!(x))                                                                  \
  |  |  ------------------
  |  |  |  Branch (355:9): [True: 0, False: 0]
  |  |  ------------------
  |  |  356|      0|      return false;                                                            \
  |  |  357|      0|  }
  ------------------
 3288|      0|  }
 3289|  87.9k|  return true;
 3290|  87.9k|}
_ZN3glz10fast_float8stackvecILt62EE10try_resizeEmm:
 3095|  86.9k|  GLZ_FASTFLOAT_CONSTEXPR20 bool try_resize(size_t new_len, limb value) noexcept {
 3096|  86.9k|    if (new_len > capacity()) {
  ------------------
  |  Branch (3096:9): [True: 0, False: 86.9k]
  ------------------
 3097|      0|      return false;
 3098|  86.9k|    } else {
 3099|  86.9k|      resize_unchecked(new_len, value);
 3100|  86.9k|      return true;
 3101|  86.9k|    }
 3102|  86.9k|  }
_ZN3glz10fast_float8stackvecILt62EE16resize_uncheckedEmm:
 3082|  86.9k|  void resize_unchecked(size_t new_len, limb value) noexcept {
 3083|  86.9k|    if (new_len > len()) {
  ------------------
  |  Branch (3083:9): [True: 86.9k, False: 0]
  ------------------
 3084|  86.9k|      size_t count = new_len - len();
 3085|  86.9k|      limb *first = data + len();
 3086|  86.9k|      limb *last = first + count;
 3087|  86.9k|      ::std::fill(first, last, value);
 3088|  86.9k|      set_len(new_len);
 3089|  86.9k|    } else {
 3090|      0|      set_len(new_len);
 3091|      0|    }
 3092|  86.9k|  }
_ZN3glz10fast_float8stackvecILt62EE9normalizeEv:
 3118|  39.2k|  GLZ_FASTFLOAT_CONSTEXPR14 void normalize() noexcept {
 3119|  39.2k|    while (len() > 0 && rindex(0) == 0) {
  ------------------
  |  Branch (3119:12): [True: 39.2k, False: 0]
  |  Branch (3119:25): [True: 0, False: 39.2k]
  ------------------
 3120|      0|      length--;
 3121|      0|    }
 3122|  39.2k|  }
_ZNK3glz10fast_float8stackvecILt62EE6rindexEm:
 3028|  51.9k|  GLZ_FASTFLOAT_CONSTEXPR14 const limb &rindex(size_t index) const noexcept {
 3029|  51.9k|    GLZ_FASTFLOAT_DEBUG_ASSERT(index < length);
  ------------------
  |  |  349|  51.9k|  { ((void)(x)); }
  ------------------
 3030|  51.9k|    size_t rindex = length - index - 1;
 3031|  51.9k|    return data[rindex];
 3032|  51.9k|  }
_ZN3glz10fast_float6bigint4pow2Ej:
 3557|  20.9k|  GLZ_FASTFLOAT_CONSTEXPR20 bool pow2(uint32_t exp) noexcept { return shl(exp); }
_ZN3glz10fast_float6bigint3shlEm:
 3519|  20.9k|  GLZ_FASTFLOAT_CONSTEXPR20 bool shl(size_t n) noexcept {
 3520|  20.9k|    size_t rem = n % limb_bits;
 3521|  20.9k|    size_t div = n / limb_bits;
 3522|  20.9k|    if (rem != 0) {
  ------------------
  |  Branch (3522:9): [True: 18.1k, False: 2.83k]
  ------------------
 3523|  18.1k|      GLZ_FASTFLOAT_TRY(shl_bits(rem));
  ------------------
  |  |  354|  18.1k|  {                                                                            \
  |  |  355|  18.1k|    if (!(x))                                                                  \
  |  |  ------------------
  |  |  |  Branch (355:9): [True: 0, False: 18.1k]
  |  |  ------------------
  |  |  356|  18.1k|      return false;                                                            \
  |  |  357|  18.1k|  }
  ------------------
 3524|  18.1k|    }
 3525|  20.9k|    if (div != 0) {
  ------------------
  |  Branch (3525:9): [True: 8.21k, False: 12.7k]
  ------------------
 3526|  8.21k|      GLZ_FASTFLOAT_TRY(shl_limbs(div));
  ------------------
  |  |  354|  8.21k|  {                                                                            \
  |  |  355|  8.21k|    if (!(x))                                                                  \
  |  |  ------------------
  |  |  |  Branch (355:9): [True: 0, False: 8.21k]
  |  |  ------------------
  |  |  356|  8.21k|      return false;                                                            \
  |  |  357|  8.21k|  }
  ------------------
 3527|  8.21k|    }
 3528|  20.9k|    return true;
 3529|  20.9k|  }
_ZN3glz10fast_float6bigint8shl_bitsEm:
 3472|  18.1k|  GLZ_FASTFLOAT_CONSTEXPR20 bool shl_bits(size_t n) noexcept {
 3473|       |    // Internally, for each item, we shift left by n, and add the previous
 3474|       |    // right shifted limb-bits.
 3475|       |    // For example, we transform (for u8) shifted left 2, to:
 3476|       |    //      b10100100 b01000010
 3477|       |    //      b10 b10010001 b00001000
 3478|  18.1k|    GLZ_FASTFLOAT_DEBUG_ASSERT(n != 0);
  ------------------
  |  |  349|  18.1k|  { ((void)(x)); }
  ------------------
 3479|  18.1k|    GLZ_FASTFLOAT_DEBUG_ASSERT(n < sizeof(limb) * 8);
  ------------------
  |  |  349|  18.1k|  { ((void)(x)); }
  ------------------
 3480|       |
 3481|  18.1k|    size_t shl = n;
 3482|  18.1k|    size_t shr = limb_bits - shl;
 3483|  18.1k|    limb prev = 0;
 3484|   168k|    for (size_t index = 0; index < vec.len(); index++) {
  ------------------
  |  Branch (3484:28): [True: 150k, False: 18.1k]
  ------------------
 3485|   150k|      limb xi = vec[index];
 3486|   150k|      vec[index] = (xi << shl) | (prev >> shr);
 3487|   150k|      prev = xi;
 3488|   150k|    }
 3489|       |
 3490|  18.1k|    limb carry = prev >> shr;
 3491|  18.1k|    if (carry != 0) {
  ------------------
  |  Branch (3491:9): [True: 5.87k, False: 12.2k]
  ------------------
 3492|  5.87k|      return vec.try_push(carry);
 3493|  5.87k|    }
 3494|  12.2k|    return true;
 3495|  18.1k|  }
_ZN3glz10fast_float6bigint9shl_limbsEm:
 3498|  8.21k|  GLZ_FASTFLOAT_CONSTEXPR20 bool shl_limbs(size_t n) noexcept {
 3499|  8.21k|    GLZ_FASTFLOAT_DEBUG_ASSERT(n != 0);
  ------------------
  |  |  349|  8.21k|  { ((void)(x)); }
  ------------------
 3500|  8.21k|    if (n + vec.len() > vec.capacity()) {
  ------------------
  |  Branch (3500:9): [True: 0, False: 8.21k]
  ------------------
 3501|      0|      return false;
 3502|  8.21k|    } else if (!vec.is_empty()) {
  ------------------
  |  Branch (3502:16): [True: 8.21k, False: 0]
  ------------------
 3503|       |      // move limbs
 3504|  8.21k|      limb *dst = vec.data + n;
 3505|  8.21k|      limb const *src = vec.data;
 3506|  8.21k|      std::copy_backward(src, src + vec.len(), dst + vec.len());
 3507|       |      // fill in empty limbs
 3508|  8.21k|      limb *first = vec.data;
 3509|  8.21k|      limb *last = first + n;
 3510|  8.21k|      ::std::fill(first, last, 0);
 3511|  8.21k|      vec.set_len(n + vec.len());
 3512|  8.21k|      return true;
 3513|  8.21k|    } else {
 3514|      0|      return true;
 3515|      0|    }
 3516|  8.21k|  }
_ZNK3glz10fast_float8stackvecILt62EE8is_emptyEv:
 3041|  12.1k|  constexpr bool is_empty() const noexcept { return length == 0; }
_ZNK3glz10fast_float6bigint4hi64ERb:
 3418|  3.91k|  GLZ_FASTFLOAT_CONSTEXPR20 uint64_t hi64(bool &truncated) const noexcept {
 3419|  3.91k|#ifdef GLZ_FASTFLOAT_64BIT_LIMB
 3420|  3.91k|    if (vec.len() == 0) {
  ------------------
  |  Branch (3420:9): [True: 0, False: 3.91k]
  ------------------
 3421|      0|      return empty_hi64(truncated);
 3422|  3.91k|    } else if (vec.len() == 1) {
  ------------------
  |  Branch (3422:16): [True: 797, False: 3.11k]
  ------------------
 3423|    797|      return uint64_hi64(vec.rindex(0), truncated);
 3424|  3.11k|    } else {
 3425|  3.11k|      uint64_t result = uint64_hi64(vec.rindex(0), vec.rindex(1), truncated);
 3426|  3.11k|      truncated |= vec.nonzero(2);
 3427|  3.11k|      return result;
 3428|  3.11k|    }
 3429|       |#else
 3430|       |    if (vec.len() == 0) {
 3431|       |      return empty_hi64(truncated);
 3432|       |    } else if (vec.len() == 1) {
 3433|       |      return uint32_hi64(vec.rindex(0), truncated);
 3434|       |    } else if (vec.len() == 2) {
 3435|       |      return uint32_hi64(vec.rindex(0), vec.rindex(1), truncated);
 3436|       |    } else {
 3437|       |      uint64_t result =
 3438|       |          uint32_hi64(vec.rindex(0), vec.rindex(1), vec.rindex(2), truncated);
 3439|       |      truncated |= vec.nonzero(3);
 3440|       |      return result;
 3441|       |    }
 3442|       |#endif
 3443|  3.91k|  }
_ZN3glz10fast_float11uint64_hi64EmRb:
 3132|    797|uint64_hi64(uint64_t r0, bool &truncated) noexcept {
 3133|    797|  truncated = false;
 3134|    797|  int shl = leading_zeroes(r0);
 3135|    797|  return r0 << shl;
 3136|    797|}
_ZN3glz10fast_float11uint64_hi64EmmRb:
 3139|  3.11k|uint64_hi64(uint64_t r0, uint64_t r1, bool &truncated) noexcept {
 3140|  3.11k|  int shl = leading_zeroes(r0);
 3141|  3.11k|  if (shl == 0) {
  ------------------
  |  Branch (3141:7): [True: 265, False: 2.85k]
  ------------------
 3142|    265|    truncated = r1 != 0;
 3143|    265|    return r0;
 3144|  2.85k|  } else {
 3145|  2.85k|    int shr = 64 - shl;
 3146|  2.85k|    truncated = (r1 << shl) != 0;
 3147|  2.85k|    return (r0 << shl) | (r1 >> shr);
 3148|  2.85k|  }
 3149|  3.11k|}
_ZNK3glz10fast_float8stackvecILt62EE7nonzeroEm:
 3107|  3.11k|  GLZ_FASTFLOAT_CONSTEXPR14 bool nonzero(size_t index) const noexcept {
 3108|  3.11k|    while (index < len()) {
  ------------------
  |  Branch (3108:12): [True: 1.82k, False: 1.29k]
  ------------------
 3109|  1.82k|      if (rindex(index) != 0) {
  ------------------
  |  Branch (3109:11): [True: 1.81k, False: 2]
  ------------------
 3110|  1.81k|        return true;
 3111|  1.81k|      }
 3112|      2|      index++;
 3113|      2|    }
 3114|  1.29k|    return false;
 3115|  3.11k|  }
_ZNK3glz10fast_float6bigint10bit_lengthEv:
 3547|  3.91k|  GLZ_FASTFLOAT_CONSTEXPR20 int bit_length() const noexcept {
 3548|  3.91k|    int lz = ctlz();
 3549|  3.91k|    return int(limb_bits * vec.len()) - lz;
 3550|  3.91k|  }
_ZNK3glz10fast_float6bigint4ctlzEv:
 3532|  3.91k|  GLZ_FASTFLOAT_CONSTEXPR20 int ctlz() const noexcept {
 3533|  3.91k|    if (vec.is_empty()) {
  ------------------
  |  Branch (3533:9): [True: 0, False: 3.91k]
  ------------------
 3534|      0|      return 0;
 3535|  3.91k|    } else {
 3536|  3.91k|#ifdef GLZ_FASTFLOAT_64BIT_LIMB
 3537|  3.91k|      return leading_zeroes(vec.rindex(0));
 3538|       |#else
 3539|       |      // no use defining a specialized leading_zeroes for a 32-bit type.
 3540|       |      uint64_t r0 = vec.rindex(0);
 3541|       |      return leading_zeroes(r0 << 32);
 3542|       |#endif
 3543|  3.91k|    }
 3544|  3.91k|  }
_ZN3glz10fast_float5roundIdZNS0_19positive_digit_compIdEENS0_17adjusted_mantissaERNS0_6bigintEiEUlRS3_iE_EEvS6_T0_:
 3707|  3.91k|                                                         callback cb) noexcept {
 3708|  3.91k|  int32_t mantissa_shift = 64 - binary_format<T>::mantissa_explicit_bits() - 1;
 3709|  3.91k|  if (-am.power2 >= mantissa_shift) {
  ------------------
  |  Branch (3709:7): [True: 0, False: 3.91k]
  ------------------
 3710|       |    // have a denormal float
 3711|      0|    int32_t shift = -am.power2 + 1;
 3712|      0|    cb(am, (std::min<int32_t>)(shift, 64));
 3713|       |    // check for round-up: if rounding-nearest carried us to the hidden bit.
 3714|      0|    am.power2 = (am.mantissa <
  ------------------
  |  Branch (3714:17): [True: 0, False: 0]
  ------------------
 3715|      0|                 (uint64_t(1) << binary_format<T>::mantissa_explicit_bits()))
 3716|      0|                    ? 0
 3717|      0|                    : 1;
 3718|      0|    return;
 3719|      0|  }
 3720|       |
 3721|       |  // have a normal float, use the default shift.
 3722|  3.91k|  cb(am, mantissa_shift);
 3723|       |
 3724|       |  // check for carry
 3725|  3.91k|  if (am.mantissa >=
  ------------------
  |  Branch (3725:7): [True: 196, False: 3.71k]
  ------------------
 3726|  3.91k|      (uint64_t(2) << binary_format<T>::mantissa_explicit_bits())) {
 3727|    196|    am.mantissa = (uint64_t(1) << binary_format<T>::mantissa_explicit_bits());
 3728|    196|    am.power2++;
 3729|    196|  }
 3730|       |
 3731|       |  // check for infinite: we could have carried to an infinite power
 3732|  3.91k|  am.mantissa &= ~(uint64_t(1) << binary_format<T>::mantissa_explicit_bits());
 3733|  3.91k|  if (am.power2 >= binary_format<T>::infinite_power()) {
  ------------------
  |  Branch (3733:7): [True: 0, False: 3.91k]
  ------------------
 3734|      0|    am.power2 = binary_format<T>::infinite_power();
 3735|      0|    am.mantissa = 0;
 3736|      0|  }
 3737|  3.91k|}
_ZZN3glz10fast_float19positive_digit_compIdEENS0_17adjusted_mantissaERNS0_6bigintEiENKUlRS2_iE_clES5_i:
 3951|  3.91k|  round<T>(answer, [truncated](adjusted_mantissa &a, int32_t shift) {
 3952|  3.91k|    round_nearest_tie_even(
 3953|  3.91k|        a, shift,
 3954|  3.91k|        [truncated](bool is_odd, bool is_halfway, bool is_above) -> bool {
 3955|  3.91k|          return is_above || (is_halfway && truncated) ||
 3956|  3.91k|                 (is_odd && is_halfway);
 3957|  3.91k|        });
 3958|  3.91k|  });
_ZN3glz10fast_float22round_nearest_tie_evenIZZNS0_19positive_digit_compIdEENS0_17adjusted_mantissaERNS0_6bigintEiENKUlRS3_iE_clES6_iEUlbbbE_EEvS6_iT_:
 3742|  3.91k|                       callback cb) noexcept {
 3743|  3.91k|  uint64_t const mask = (shift == 64) ? UINT64_MAX : (uint64_t(1) << shift) - 1;
  ------------------
  |  Branch (3743:25): [True: 0, False: 3.91k]
  ------------------
 3744|  3.91k|  uint64_t const halfway = (shift == 0) ? 0 : uint64_t(1) << (shift - 1);
  ------------------
  |  Branch (3744:28): [True: 0, False: 3.91k]
  ------------------
 3745|  3.91k|  uint64_t truncated_bits = am.mantissa & mask;
 3746|  3.91k|  bool is_above = truncated_bits > halfway;
 3747|  3.91k|  bool is_halfway = truncated_bits == halfway;
 3748|       |
 3749|       |  // shift digits into position
 3750|  3.91k|  if (shift == 64) {
  ------------------
  |  Branch (3750:7): [True: 0, False: 3.91k]
  ------------------
 3751|      0|    am.mantissa = 0;
 3752|  3.91k|  } else {
 3753|  3.91k|    am.mantissa >>= shift;
 3754|  3.91k|  }
 3755|  3.91k|  am.power2 += shift;
 3756|       |
 3757|  3.91k|  bool is_odd = (am.mantissa & 1) == 1;
 3758|  3.91k|  am.mantissa += uint64_t(cb(is_odd, is_halfway, is_above));
 3759|  3.91k|}
_ZZZN3glz10fast_float19positive_digit_compIdEENS0_17adjusted_mantissaERNS0_6bigintEiENKUlRS2_iE_clES5_iENKUlbbbE_clEbbb:
 3954|  3.91k|        [truncated](bool is_odd, bool is_halfway, bool is_above) -> bool {
 3955|  3.91k|          return is_above || (is_halfway && truncated) ||
  ------------------
  |  Branch (3955:18): [True: 955, False: 2.95k]
  |  Branch (3955:31): [True: 560, False: 2.39k]
  |  Branch (3955:45): [True: 324, False: 236]
  ------------------
 3956|  2.63k|                 (is_odd && is_halfway);
  ------------------
  |  Branch (3956:19): [True: 426, False: 2.20k]
  |  Branch (3956:29): [True: 5, False: 421]
  ------------------
 3957|  3.91k|        });
_ZN3glz10fast_float19negative_digit_compIdEENS0_17adjusted_mantissaERNS0_6bigintES2_i:
 3970|  17.2k|    bigint &bigmant, adjusted_mantissa am, int32_t exponent) noexcept {
 3971|  17.2k|  bigint &real_digits = bigmant;
 3972|  17.2k|  int32_t real_exp = exponent;
 3973|       |
 3974|       |  // get the value of `b`, rounded down, and get a bigint representation of b+h
 3975|  17.2k|  adjusted_mantissa am_b = am;
 3976|       |  // gcc7 buf: use a lambda to remove the noexcept qualifier bug with
 3977|       |  // -Wnoexcept-type.
 3978|  17.2k|  round<T>(am_b,
 3979|  17.2k|           [](adjusted_mantissa &a, int32_t shift) { round_down(a, shift); });
 3980|  17.2k|  T b;
 3981|  17.2k|  to_float(false, am_b, b);
 3982|  17.2k|  adjusted_mantissa theor = to_extended_halfway(b);
 3983|  17.2k|  bigint theor_digits(theor.mantissa);
 3984|  17.2k|  int32_t theor_exp = theor.power2;
 3985|       |
 3986|       |  // scale real digits and theor digits to be same power.
 3987|  17.2k|  int32_t pow2_exp = theor_exp - real_exp;
 3988|  17.2k|  uint32_t pow5_exp = uint32_t(-real_exp);
 3989|  17.2k|  if (pow5_exp != 0) {
  ------------------
  |  Branch (3989:7): [True: 17.2k, False: 0]
  ------------------
 3990|  17.2k|    GLZ_FASTFLOAT_ASSERT(theor_digits.pow5(pow5_exp));
  ------------------
  |  |  344|  17.2k|  { ((void)(x)); }
  ------------------
 3991|  17.2k|  }
 3992|  17.2k|  if (pow2_exp > 0) {
  ------------------
  |  Branch (3992:7): [True: 13.7k, False: 3.52k]
  ------------------
 3993|  13.7k|    GLZ_FASTFLOAT_ASSERT(theor_digits.pow2(uint32_t(pow2_exp)));
  ------------------
  |  |  344|  13.7k|  { ((void)(x)); }
  ------------------
 3994|  13.7k|  } else if (pow2_exp < 0) {
  ------------------
  |  Branch (3994:14): [True: 3.32k, False: 199]
  ------------------
 3995|  3.32k|    GLZ_FASTFLOAT_ASSERT(real_digits.pow2(uint32_t(-pow2_exp)));
  ------------------
  |  |  344|  3.32k|  { ((void)(x)); }
  ------------------
 3996|  3.32k|  }
 3997|       |
 3998|       |  // compare digits, and use it to director rounding
 3999|  17.2k|  int ord = real_digits.compare(theor_digits);
 4000|  17.2k|  adjusted_mantissa answer = am;
 4001|  17.2k|  round<T>(answer, [ord](adjusted_mantissa &a, int32_t shift) {
 4002|  17.2k|    round_nearest_tie_even(
 4003|  17.2k|        a, shift, [ord](bool is_odd, bool _, bool __) -> bool {
 4004|  17.2k|          (void)_;  // not needed, since we've done our comparison
 4005|  17.2k|          (void)__; // not needed, since we've done our comparison
 4006|  17.2k|          if (ord > 0) {
 4007|  17.2k|            return true;
 4008|  17.2k|          } else if (ord < 0) {
 4009|  17.2k|            return false;
 4010|  17.2k|          } else {
 4011|  17.2k|            return is_odd;
 4012|  17.2k|          }
 4013|  17.2k|        });
 4014|  17.2k|  });
 4015|       |
 4016|  17.2k|  return answer;
 4017|  17.2k|}
_ZN3glz10fast_float5roundIdZNS0_19negative_digit_compIdEENS0_17adjusted_mantissaERNS0_6bigintES3_iEUlRS3_iE_EEvS6_T0_:
 3707|  17.2k|                                                         callback cb) noexcept {
 3708|  17.2k|  int32_t mantissa_shift = 64 - binary_format<T>::mantissa_explicit_bits() - 1;
 3709|  17.2k|  if (-am.power2 >= mantissa_shift) {
  ------------------
  |  Branch (3709:7): [True: 748, False: 16.4k]
  ------------------
 3710|       |    // have a denormal float
 3711|    748|    int32_t shift = -am.power2 + 1;
 3712|    748|    cb(am, (std::min<int32_t>)(shift, 64));
 3713|       |    // check for round-up: if rounding-nearest carried us to the hidden bit.
 3714|    748|    am.power2 = (am.mantissa <
  ------------------
  |  Branch (3714:17): [True: 748, False: 0]
  ------------------
 3715|    748|                 (uint64_t(1) << binary_format<T>::mantissa_explicit_bits()))
 3716|    748|                    ? 0
 3717|    748|                    : 1;
 3718|    748|    return;
 3719|    748|  }
 3720|       |
 3721|       |  // have a normal float, use the default shift.
 3722|  16.4k|  cb(am, mantissa_shift);
 3723|       |
 3724|       |  // check for carry
 3725|  16.4k|  if (am.mantissa >=
  ------------------
  |  Branch (3725:7): [True: 0, False: 16.4k]
  ------------------
 3726|  16.4k|      (uint64_t(2) << binary_format<T>::mantissa_explicit_bits())) {
 3727|      0|    am.mantissa = (uint64_t(1) << binary_format<T>::mantissa_explicit_bits());
 3728|      0|    am.power2++;
 3729|      0|  }
 3730|       |
 3731|       |  // check for infinite: we could have carried to an infinite power
 3732|  16.4k|  am.mantissa &= ~(uint64_t(1) << binary_format<T>::mantissa_explicit_bits());
 3733|  16.4k|  if (am.power2 >= binary_format<T>::infinite_power()) {
  ------------------
  |  Branch (3733:7): [True: 0, False: 16.4k]
  ------------------
 3734|      0|    am.power2 = binary_format<T>::infinite_power();
 3735|      0|    am.mantissa = 0;
 3736|      0|  }
 3737|  16.4k|}
_ZZN3glz10fast_float19negative_digit_compIdEENS0_17adjusted_mantissaERNS0_6bigintES2_iENKUlRS2_iE_clES5_i:
 3979|  17.2k|           [](adjusted_mantissa &a, int32_t shift) { round_down(a, shift); });
_ZN3glz10fast_float10round_downERNS0_17adjusted_mantissaEi:
 3762|  17.2k|round_down(adjusted_mantissa &am, int32_t shift) noexcept {
 3763|  17.2k|  if (shift == 64) {
  ------------------
  |  Branch (3763:7): [True: 0, False: 17.2k]
  ------------------
 3764|      0|    am.mantissa = 0;
 3765|  17.2k|  } else {
 3766|  17.2k|    am.mantissa >>= shift;
 3767|  17.2k|  }
 3768|  17.2k|  am.power2 += shift;
 3769|  17.2k|}
_ZN3glz10fast_float19to_extended_halfwayIdEENS0_17adjusted_mantissaET_:
 3696|  17.2k|to_extended_halfway(T value) noexcept {
 3697|  17.2k|  adjusted_mantissa am = to_extended(value);
 3698|  17.2k|  am.mantissa <<= 1;
 3699|  17.2k|  am.mantissa += 1;
 3700|  17.2k|  am.power2 -= 1;
 3701|  17.2k|  return am;
 3702|  17.2k|}
_ZN3glz10fast_float11to_extendedIdEENS0_17adjusted_mantissaET_:
 3661|  17.2k|to_extended(T value) noexcept {
 3662|  17.2k|  using equiv_uint = equiv_uint_t<T>;
 3663|  17.2k|  constexpr equiv_uint exponent_mask = binary_format<T>::exponent_mask();
 3664|  17.2k|  constexpr equiv_uint mantissa_mask = binary_format<T>::mantissa_mask();
 3665|  17.2k|  constexpr equiv_uint hidden_bit_mask = binary_format<T>::hidden_bit_mask();
 3666|       |
 3667|  17.2k|  adjusted_mantissa am;
 3668|  17.2k|  int32_t bias = binary_format<T>::mantissa_explicit_bits() -
 3669|  17.2k|                 binary_format<T>::minimum_exponent();
 3670|  17.2k|  equiv_uint bits;
 3671|  17.2k|#if GLZ_FASTFLOAT_HAS_BIT_CAST
 3672|  17.2k|  bits = std::bit_cast<equiv_uint>(value);
 3673|       |#else
 3674|       |  ::memcpy(&bits, &value, sizeof(T));
 3675|       |#endif
 3676|  17.2k|  if ((bits & exponent_mask) == 0) {
  ------------------
  |  Branch (3676:7): [True: 748, False: 16.4k]
  ------------------
 3677|       |    // denormal
 3678|    748|    am.power2 = 1 - bias;
 3679|    748|    am.mantissa = bits & mantissa_mask;
 3680|  16.4k|  } else {
 3681|       |    // normal
 3682|  16.4k|    am.power2 = int32_t((bits & exponent_mask) >>
 3683|  16.4k|                        binary_format<T>::mantissa_explicit_bits());
 3684|  16.4k|    am.power2 -= bias;
 3685|  16.4k|    am.mantissa = (bits & mantissa_mask) | hidden_bit_mask;
 3686|  16.4k|  }
 3687|       |
 3688|  17.2k|  return am;
 3689|  17.2k|}
_ZN3glz10fast_float6bigintC2Em:
 3406|  17.2k|  GLZ_FASTFLOAT_CONSTEXPR20 bigint(uint64_t value) : vec() {
 3407|  17.2k|#ifdef GLZ_FASTFLOAT_64BIT_LIMB
 3408|  17.2k|    vec.push_unchecked(value);
 3409|       |#else
 3410|       |    vec.push_unchecked(uint32_t(value));
 3411|       |    vec.push_unchecked(uint32_t(value >> 32));
 3412|       |#endif
 3413|  17.2k|    vec.normalize();
 3414|  17.2k|  }
_ZNK3glz10fast_float6bigint7compareERKS1_:
 3451|  17.2k|  GLZ_FASTFLOAT_CONSTEXPR20 int compare(bigint const &other) const noexcept {
 3452|  17.2k|    if (vec.len() > other.vec.len()) {
  ------------------
  |  Branch (3452:9): [True: 0, False: 17.2k]
  ------------------
 3453|      0|      return 1;
 3454|  17.2k|    } else if (vec.len() < other.vec.len()) {
  ------------------
  |  Branch (3454:16): [True: 0, False: 17.2k]
  ------------------
 3455|      0|      return -1;
 3456|  17.2k|    } else {
 3457|   127k|      for (size_t index = vec.len(); index > 0; index--) {
  ------------------
  |  Branch (3457:38): [True: 126k, False: 989]
  ------------------
 3458|   126k|        limb xi = vec[index - 1];
 3459|   126k|        limb yi = other.vec[index - 1];
 3460|   126k|        if (xi > yi) {
  ------------------
  |  Branch (3460:13): [True: 11.7k, False: 115k]
  ------------------
 3461|  11.7k|          return 1;
 3462|   115k|        } else if (xi < yi) {
  ------------------
  |  Branch (3462:20): [True: 4.51k, False: 110k]
  ------------------
 3463|  4.51k|          return -1;
 3464|  4.51k|        }
 3465|   126k|      }
 3466|    989|      return 0;
 3467|  17.2k|    }
 3468|  17.2k|  }
_ZNK3glz10fast_float8stackvecILt62EEixEm:
 3022|   253k|  GLZ_FASTFLOAT_CONSTEXPR14 const limb &operator[](size_t index) const noexcept {
 3023|   253k|    GLZ_FASTFLOAT_DEBUG_ASSERT(index < length);
  ------------------
  |  |  349|   253k|  { ((void)(x)); }
  ------------------
 3024|   253k|    return data[index];
 3025|   253k|  }
_ZN3glz10fast_float5roundIdZNS0_19negative_digit_compIdEENS0_17adjusted_mantissaERNS0_6bigintES3_iEUlRS3_iE0_EEvS6_T0_:
 3707|  17.2k|                                                         callback cb) noexcept {
 3708|  17.2k|  int32_t mantissa_shift = 64 - binary_format<T>::mantissa_explicit_bits() - 1;
 3709|  17.2k|  if (-am.power2 >= mantissa_shift) {
  ------------------
  |  Branch (3709:7): [True: 748, False: 16.4k]
  ------------------
 3710|       |    // have a denormal float
 3711|    748|    int32_t shift = -am.power2 + 1;
 3712|    748|    cb(am, (std::min<int32_t>)(shift, 64));
 3713|       |    // check for round-up: if rounding-nearest carried us to the hidden bit.
 3714|    748|    am.power2 = (am.mantissa <
  ------------------
  |  Branch (3714:17): [True: 748, False: 0]
  ------------------
 3715|    748|                 (uint64_t(1) << binary_format<T>::mantissa_explicit_bits()))
 3716|    748|                    ? 0
 3717|    748|                    : 1;
 3718|    748|    return;
 3719|    748|  }
 3720|       |
 3721|       |  // have a normal float, use the default shift.
 3722|  16.4k|  cb(am, mantissa_shift);
 3723|       |
 3724|       |  // check for carry
 3725|  16.4k|  if (am.mantissa >=
  ------------------
  |  Branch (3725:7): [True: 526, False: 15.9k]
  ------------------
 3726|  16.4k|      (uint64_t(2) << binary_format<T>::mantissa_explicit_bits())) {
 3727|    526|    am.mantissa = (uint64_t(1) << binary_format<T>::mantissa_explicit_bits());
 3728|    526|    am.power2++;
 3729|    526|  }
 3730|       |
 3731|       |  // check for infinite: we could have carried to an infinite power
 3732|  16.4k|  am.mantissa &= ~(uint64_t(1) << binary_format<T>::mantissa_explicit_bits());
 3733|  16.4k|  if (am.power2 >= binary_format<T>::infinite_power()) {
  ------------------
  |  Branch (3733:7): [True: 0, False: 16.4k]
  ------------------
 3734|      0|    am.power2 = binary_format<T>::infinite_power();
 3735|      0|    am.mantissa = 0;
 3736|      0|  }
 3737|  16.4k|}
_ZZN3glz10fast_float19negative_digit_compIdEENS0_17adjusted_mantissaERNS0_6bigintES2_iENKUlRS2_iE0_clES5_i:
 4001|  17.2k|  round<T>(answer, [ord](adjusted_mantissa &a, int32_t shift) {
 4002|  17.2k|    round_nearest_tie_even(
 4003|  17.2k|        a, shift, [ord](bool is_odd, bool _, bool __) -> bool {
 4004|  17.2k|          (void)_;  // not needed, since we've done our comparison
 4005|  17.2k|          (void)__; // not needed, since we've done our comparison
 4006|  17.2k|          if (ord > 0) {
 4007|  17.2k|            return true;
 4008|  17.2k|          } else if (ord < 0) {
 4009|  17.2k|            return false;
 4010|  17.2k|          } else {
 4011|  17.2k|            return is_odd;
 4012|  17.2k|          }
 4013|  17.2k|        });
 4014|  17.2k|  });
_ZN3glz10fast_float22round_nearest_tie_evenIZZNS0_19negative_digit_compIdEENS0_17adjusted_mantissaERNS0_6bigintES3_iENKUlRS3_iE0_clES6_iEUlbbbE_EEvS6_iT_:
 3742|  17.2k|                       callback cb) noexcept {
 3743|  17.2k|  uint64_t const mask = (shift == 64) ? UINT64_MAX : (uint64_t(1) << shift) - 1;
  ------------------
  |  Branch (3743:25): [True: 0, False: 17.2k]
  ------------------
 3744|  17.2k|  uint64_t const halfway = (shift == 0) ? 0 : uint64_t(1) << (shift - 1);
  ------------------
  |  Branch (3744:28): [True: 0, False: 17.2k]
  ------------------
 3745|  17.2k|  uint64_t truncated_bits = am.mantissa & mask;
 3746|  17.2k|  bool is_above = truncated_bits > halfway;
 3747|  17.2k|  bool is_halfway = truncated_bits == halfway;
 3748|       |
 3749|       |  // shift digits into position
 3750|  17.2k|  if (shift == 64) {
  ------------------
  |  Branch (3750:7): [True: 0, False: 17.2k]
  ------------------
 3751|      0|    am.mantissa = 0;
 3752|  17.2k|  } else {
 3753|  17.2k|    am.mantissa >>= shift;
 3754|  17.2k|  }
 3755|  17.2k|  am.power2 += shift;
 3756|       |
 3757|  17.2k|  bool is_odd = (am.mantissa & 1) == 1;
 3758|  17.2k|  am.mantissa += uint64_t(cb(is_odd, is_halfway, is_above));
 3759|  17.2k|}
_ZZZN3glz10fast_float19negative_digit_compIdEENS0_17adjusted_mantissaERNS0_6bigintES2_iENKUlRS2_iE0_clES5_iENKUlbbbE_clEbbb:
 4003|  17.2k|        a, shift, [ord](bool is_odd, bool _, bool __) -> bool {
 4004|  17.2k|          (void)_;  // not needed, since we've done our comparison
 4005|  17.2k|          (void)__; // not needed, since we've done our comparison
 4006|  17.2k|          if (ord > 0) {
  ------------------
  |  Branch (4006:15): [True: 11.7k, False: 5.50k]
  ------------------
 4007|  11.7k|            return true;
 4008|  11.7k|          } else if (ord < 0) {
  ------------------
  |  Branch (4008:22): [True: 4.51k, False: 989]
  ------------------
 4009|  4.51k|            return false;
 4010|  4.51k|          } else {
 4011|    989|            return is_odd;
 4012|    989|          }
 4013|  17.2k|        });
_ZN3glz10fast_float8to_floatIdEEvbNS0_17adjusted_mantissaERT_:
 1131|  57.1k|to_float(bool negative, adjusted_mantissa am, T &value) {
 1132|  57.1k|  using equiv_uint = equiv_uint_t<T>;
 1133|  57.1k|  equiv_uint word = equiv_uint(am.mantissa);
 1134|  57.1k|  word = equiv_uint(word | equiv_uint(am.power2)
 1135|  57.1k|                               << binary_format<T>::mantissa_explicit_bits());
 1136|  57.1k|  word =
 1137|  57.1k|      equiv_uint(word | equiv_uint(negative) << binary_format<T>::sign_index());
 1138|  57.1k|#if GLZ_FASTFLOAT_HAS_BIT_CAST
 1139|  57.1k|  value = std::bit_cast<T>(word);
 1140|       |#else
 1141|       |  ::memcpy(&value, &word, sizeof(T));
 1142|       |#endif
 1143|  57.1k|}
_ZN3glz10fast_float13binary_formatIdE10sign_indexEv:
  758|  57.1k|template <> inline constexpr int binary_format<double>::sign_index() {
  759|  57.1k|  return 63;
  760|  57.1k|}
_ZN3glz10fast_float13binary_formatIdE14infinite_powerEv:
  750|   145k|template <> inline constexpr int binary_format<double>::infinite_power() {
  751|   145k|  return 0x7FF;
  752|   145k|}

jsonrpc_registry.cpp:_ZN3glz8for_eachILm4EZNS_8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz10member_apiEL_ZNS5_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS8_EEEvRT0_EUlTnDavE_EEvOS9_:
   24|  61.1k|   {
   25|  61.1k|      if constexpr (N > 0) {
   26|       |         // Explicit sizes for small N to help the compiler and make debugging easier
   27|       |         // These generate less assembly with O0, but make no difference for higher optimization
   28|       |         if constexpr (N == 1) {
   29|       |            lambda.template operator()<0>();
   30|       |         }
   31|       |         else if constexpr (N == 2) {
   32|       |            lambda.template operator()<0>();
   33|       |            lambda.template operator()<1>();
   34|       |         }
   35|       |         else if constexpr (N == 3) {
   36|       |            lambda.template operator()<0>();
   37|       |            lambda.template operator()<1>();
   38|       |            lambda.template operator()<2>();
   39|       |         }
   40|  61.1k|         else if constexpr (N == 4) {
   41|  61.1k|            lambda.template operator()<0>();
   42|  61.1k|            lambda.template operator()<1>();
   43|  61.1k|            lambda.template operator()<2>();
   44|  61.1k|            lambda.template operator()<3>();
   45|       |         }
   46|       |         else {
   47|       |            [&]<size_t... I>(std::index_sequence<I...>) {
   48|       |               (void)(lambda.template operator()<I>(), ...);
   49|       |            }(std::make_index_sequence<N>{});
   50|       |         }
   51|  61.1k|      }
   52|  61.1k|   }
_ZN3glz8for_eachILm2EZNS_2toILj10EN12jsonrpc_fuzz5pointEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEES3_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_EUlTnmvE_EEvSK_:
   24|    161|   {
   25|    161|      if constexpr (N > 0) {
   26|       |         // Explicit sizes for small N to help the compiler and make debugging easier
   27|       |         // These generate less assembly with O0, but make no difference for higher optimization
   28|       |         if constexpr (N == 1) {
   29|       |            lambda.template operator()<0>();
   30|       |         }
   31|    161|         else if constexpr (N == 2) {
   32|    161|            lambda.template operator()<0>();
   33|    161|            lambda.template operator()<1>();
   34|       |         }
   35|       |         else if constexpr (N == 3) {
   36|       |            lambda.template operator()<0>();
   37|       |            lambda.template operator()<1>();
   38|       |            lambda.template operator()<2>();
   39|       |         }
   40|       |         else if constexpr (N == 4) {
   41|       |            lambda.template operator()<0>();
   42|       |            lambda.template operator()<1>();
   43|       |            lambda.template operator()<2>();
   44|       |            lambda.template operator()<3>();
   45|       |         }
   46|       |         else {
   47|       |            [&]<size_t... I>(std::index_sequence<I...>) {
   48|       |               (void)(lambda.template operator()<I>(), ...);
   49|       |            }(std::make_index_sequence<N>{});
   50|       |         }
   51|    161|      }
   52|    161|   }
_ZN3glz5visitILm13EZNS_16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT1_OT3_OT4_OT5_DpOT2_EUlTnmvE_EEvOSB_m:
   81|  28.4k|   {
   82|  28.4k|      if constexpr (N > 0) {
   83|       |         // Explicit sizes for small N to help the compiler and make debugging easier
   84|       |         if constexpr (N == 1) {
   85|       |            (void)index;
   86|       |            (void)(lambda.template operator()<0>());
   87|       |         }
   88|       |         else if constexpr (N == 2) {
   89|       |            switch (index) {
   90|       |            case 0:
   91|       |               lambda.template operator()<0>();
   92|       |               break;
   93|       |            case 1:
   94|       |               lambda.template operator()<1>();
   95|       |               break;
   96|       |            default:
   97|       |               std::unreachable();
   98|       |            }
   99|       |         }
  100|       |         else if constexpr (N == 3) {
  101|       |            switch (index) {
  102|       |            case 0:
  103|       |               lambda.template operator()<0>();
  104|       |               break;
  105|       |            case 1:
  106|       |               lambda.template operator()<1>();
  107|       |               break;
  108|       |            case 2:
  109|       |               lambda.template operator()<2>();
  110|       |               break;
  111|       |            default:
  112|       |               std::unreachable();
  113|       |            }
  114|       |         }
  115|       |         else if constexpr (N == 4) {
  116|       |            switch (index) {
  117|       |            case 0:
  118|       |               lambda.template operator()<0>();
  119|       |               break;
  120|       |            case 1:
  121|       |               lambda.template operator()<1>();
  122|       |               break;
  123|       |            case 2:
  124|       |               lambda.template operator()<2>();
  125|       |               break;
  126|       |            case 3:
  127|       |               lambda.template operator()<3>();
  128|       |               break;
  129|       |            default:
  130|       |               std::unreachable();
  131|       |            }
  132|       |         }
  133|       |         else if constexpr (N == 5) {
  134|       |            switch (index) {
  135|       |            case 0:
  136|       |               lambda.template operator()<0>();
  137|       |               break;
  138|       |            case 1:
  139|       |               lambda.template operator()<1>();
  140|       |               break;
  141|       |            case 2:
  142|       |               lambda.template operator()<2>();
  143|       |               break;
  144|       |            case 3:
  145|       |               lambda.template operator()<3>();
  146|       |               break;
  147|       |            case 4:
  148|       |               lambda.template operator()<4>();
  149|       |               break;
  150|       |            default:
  151|       |               std::unreachable();
  152|       |            }
  153|       |         }
  154|       |         else if constexpr (N == 6) {
  155|       |            switch (index) {
  156|       |            case 0:
  157|       |               lambda.template operator()<0>();
  158|       |               break;
  159|       |            case 1:
  160|       |               lambda.template operator()<1>();
  161|       |               break;
  162|       |            case 2:
  163|       |               lambda.template operator()<2>();
  164|       |               break;
  165|       |            case 3:
  166|       |               lambda.template operator()<3>();
  167|       |               break;
  168|       |            case 4:
  169|       |               lambda.template operator()<4>();
  170|       |               break;
  171|       |            case 5:
  172|       |               lambda.template operator()<5>();
  173|       |               break;
  174|       |            default:
  175|       |               std::unreachable();
  176|       |            }
  177|       |         }
  178|       |         else if constexpr (N == 7) {
  179|       |            switch (index) {
  180|       |            case 0:
  181|       |               lambda.template operator()<0>();
  182|       |               break;
  183|       |            case 1:
  184|       |               lambda.template operator()<1>();
  185|       |               break;
  186|       |            case 2:
  187|       |               lambda.template operator()<2>();
  188|       |               break;
  189|       |            case 3:
  190|       |               lambda.template operator()<3>();
  191|       |               break;
  192|       |            case 4:
  193|       |               lambda.template operator()<4>();
  194|       |               break;
  195|       |            case 5:
  196|       |               lambda.template operator()<5>();
  197|       |               break;
  198|       |            case 6:
  199|       |               lambda.template operator()<6>();
  200|       |               break;
  201|       |            default:
  202|       |               std::unreachable();
  203|       |            }
  204|       |         }
  205|       |         else if constexpr (N == 8) {
  206|       |            switch (index) {
  207|       |            case 0:
  208|       |               lambda.template operator()<0>();
  209|       |               break;
  210|       |            case 1:
  211|       |               lambda.template operator()<1>();
  212|       |               break;
  213|       |            case 2:
  214|       |               lambda.template operator()<2>();
  215|       |               break;
  216|       |            case 3:
  217|       |               lambda.template operator()<3>();
  218|       |               break;
  219|       |            case 4:
  220|       |               lambda.template operator()<4>();
  221|       |               break;
  222|       |            case 5:
  223|       |               lambda.template operator()<5>();
  224|       |               break;
  225|       |            case 6:
  226|       |               lambda.template operator()<6>();
  227|       |               break;
  228|       |            case 7:
  229|       |               lambda.template operator()<7>();
  230|       |               break;
  231|       |            default:
  232|       |               std::unreachable();
  233|       |            }
  234|       |         }
  235|       |         else if constexpr (N == 9) {
  236|       |            switch (index) {
  237|       |            case 0:
  238|       |               lambda.template operator()<0>();
  239|       |               break;
  240|       |            case 1:
  241|       |               lambda.template operator()<1>();
  242|       |               break;
  243|       |            case 2:
  244|       |               lambda.template operator()<2>();
  245|       |               break;
  246|       |            case 3:
  247|       |               lambda.template operator()<3>();
  248|       |               break;
  249|       |            case 4:
  250|       |               lambda.template operator()<4>();
  251|       |               break;
  252|       |            case 5:
  253|       |               lambda.template operator()<5>();
  254|       |               break;
  255|       |            case 6:
  256|       |               lambda.template operator()<6>();
  257|       |               break;
  258|       |            case 7:
  259|       |               lambda.template operator()<7>();
  260|       |               break;
  261|       |            case 8:
  262|       |               lambda.template operator()<8>();
  263|       |               break;
  264|       |            default:
  265|       |               std::unreachable();
  266|       |            }
  267|       |         }
  268|       |         else if constexpr (N == 10) {
  269|       |            switch (index) {
  270|       |            case 0:
  271|       |               lambda.template operator()<0>();
  272|       |               break;
  273|       |            case 1:
  274|       |               lambda.template operator()<1>();
  275|       |               break;
  276|       |            case 2:
  277|       |               lambda.template operator()<2>();
  278|       |               break;
  279|       |            case 3:
  280|       |               lambda.template operator()<3>();
  281|       |               break;
  282|       |            case 4:
  283|       |               lambda.template operator()<4>();
  284|       |               break;
  285|       |            case 5:
  286|       |               lambda.template operator()<5>();
  287|       |               break;
  288|       |            case 6:
  289|       |               lambda.template operator()<6>();
  290|       |               break;
  291|       |            case 7:
  292|       |               lambda.template operator()<7>();
  293|       |               break;
  294|       |            case 8:
  295|       |               lambda.template operator()<8>();
  296|       |               break;
  297|       |            case 9:
  298|       |               lambda.template operator()<9>();
  299|       |               break;
  300|       |            default:
  301|       |               std::unreachable();
  302|       |            }
  303|       |         }
  304|  28.4k|         else {
  305|       |#ifdef _MSC_VER
  306|       |            using Lambda = std::decay_t<decltype(lambda)>;
  307|       |            static const auto jump_table = []<size_t... I>(std::index_sequence<I...>) {
  308|       |               return std::array{make_jump_function<I, Lambda>()...};
  309|       |            }(std::make_index_sequence<N>{});
  310|       |#else
  311|  28.4k|            static constexpr auto jump_table = []<size_t... I>(std::index_sequence<I...>) {
  312|  28.4k|               return std::array{+[](std::decay_t<decltype(lambda)>& l) { l.template operator()<I>(); }...};
  313|  28.4k|            }(std::make_index_sequence<N>{});
  314|  28.4k|#endif
  315|       |
  316|  28.4k|#if defined(__clang_major__) && (__clang_major__ >= 19)
  317|  28.4k|            [[assume(index < N)]];
  318|  28.4k|#endif
  319|  28.4k|            jump_table[index](lambda);
  320|       |
  321|       |            // This code runs significantly slower on Clang
  322|       |            // Simple tests with assembly show that this should be faster,
  323|       |            // but full Glaze assembly need to be looked into
  324|       |            /*[&, index]<size_t... I>(std::index_sequence<I...>) {
  325|       |               (void)((index == I ? lambda.template operator()<I>() : void()), ...);
  326|       |            }(std::make_index_sequence<N>{});*/
  327|  28.4k|         }
  328|  28.4k|      }
  329|  28.4k|   }
_ZZZN3glz5visitILm13EZNS_16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT1_OT3_OT4_OT5_DpOT2_EUlTnmvE_EEvOSB_mENKUlTpTnmNSt3__116integer_sequenceImJXspT_EEEEE_clIJLm0ELm1ELm2ELm3ELm4ELm5ELm6ELm7ELm8ELm9ELm10ELm11ELm12EEEEDaSR_ENKUlRSN_E_clESU_:
  312|  14.2k|               return std::array{+[](std::decay_t<decltype(lambda)>& l) { l.template operator()<I>(); }...};
_ZZZN3glz5visitILm13EZNS_16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT1_OT3_OT4_OT5_DpOT2_EUlTnmvE_EEvOSB_mENKUlTpTnmNSt3__116integer_sequenceImJXspT_EEEEE_clIJLm0ELm1ELm2ELm3ELm4ELm5ELm6ELm7ELm8ELm9ELm10ELm11ELm12EEEEDaSR_ENKUlRSN_E0_clESU_:
  312|    287|               return std::array{+[](std::decay_t<decltype(lambda)>& l) { l.template operator()<I>(); }...};
_ZZZN3glz5visitILm13EZNS_16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT1_OT3_OT4_OT5_DpOT2_EUlTnmvE_EEvOSB_mENKUlTpTnmNSt3__116integer_sequenceImJXspT_EEEEE_clIJLm0ELm1ELm2ELm3ELm4ELm5ELm6ELm7ELm8ELm9ELm10ELm11ELm12EEEEDaSR_ENKUlRSN_E1_clESU_:
  312|    728|               return std::array{+[](std::decay_t<decltype(lambda)>& l) { l.template operator()<I>(); }...};
_ZZZN3glz5visitILm13EZNS_16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT1_OT3_OT4_OT5_DpOT2_EUlTnmvE_EEvOSB_mENKUlTpTnmNSt3__116integer_sequenceImJXspT_EEEEE_clIJLm0ELm1ELm2ELm3ELm4ELm5ELm6ELm7ELm8ELm9ELm10ELm11ELm12EEEEDaSR_ENKUlRSN_E2_clESU_:
  312|    837|               return std::array{+[](std::decay_t<decltype(lambda)>& l) { l.template operator()<I>(); }...};
_ZZZN3glz5visitILm13EZNS_16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT1_OT3_OT4_OT5_DpOT2_EUlTnmvE_EEvOSB_mENKUlTpTnmNSt3__116integer_sequenceImJXspT_EEEEE_clIJLm0ELm1ELm2ELm3ELm4ELm5ELm6ELm7ELm8ELm9ELm10ELm11ELm12EEEEDaSR_ENKUlRSN_E3_clESU_:
  312|      8|               return std::array{+[](std::decay_t<decltype(lambda)>& l) { l.template operator()<I>(); }...};
_ZZZN3glz5visitILm13EZNS_16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT1_OT3_OT4_OT5_DpOT2_EUlTnmvE_EEvOSB_mENKUlTpTnmNSt3__116integer_sequenceImJXspT_EEEEE_clIJLm0ELm1ELm2ELm3ELm4ELm5ELm6ELm7ELm8ELm9ELm10ELm11ELm12EEEEDaSR_ENKUlRSN_E4_clESU_:
  312|  1.13k|               return std::array{+[](std::decay_t<decltype(lambda)>& l) { l.template operator()<I>(); }...};
_ZZZN3glz5visitILm13EZNS_16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT1_OT3_OT4_OT5_DpOT2_EUlTnmvE_EEvOSB_mENKUlTpTnmNSt3__116integer_sequenceImJXspT_EEEEE_clIJLm0ELm1ELm2ELm3ELm4ELm5ELm6ELm7ELm8ELm9ELm10ELm11ELm12EEEEDaSR_ENKUlRSN_E5_clESU_:
  312|  1.56k|               return std::array{+[](std::decay_t<decltype(lambda)>& l) { l.template operator()<I>(); }...};
_ZZZN3glz5visitILm13EZNS_16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT1_OT3_OT4_OT5_DpOT2_EUlTnmvE_EEvOSB_mENKUlTpTnmNSt3__116integer_sequenceImJXspT_EEEEE_clIJLm0ELm1ELm2ELm3ELm4ELm5ELm6ELm7ELm8ELm9ELm10ELm11ELm12EEEEDaSR_ENKUlRSN_E6_clESU_:
  312|    734|               return std::array{+[](std::decay_t<decltype(lambda)>& l) { l.template operator()<I>(); }...};
_ZN3glz8for_eachILm2EZNS_28process_variant_alternativesINSt3__17variantIJNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEN12jsonrpc_fuzz6amountEEEENS_14is_variant_strEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSC_TkNS_10is_contextERNS_7contextERPKcSL_EEvOT0_OT1_OT2_T3_EUlTnmvE_EEvSO_:
   24|  1.26k|   {
   25|  1.26k|      if constexpr (N > 0) {
   26|       |         // Explicit sizes for small N to help the compiler and make debugging easier
   27|       |         // These generate less assembly with O0, but make no difference for higher optimization
   28|       |         if constexpr (N == 1) {
   29|       |            lambda.template operator()<0>();
   30|       |         }
   31|  1.26k|         else if constexpr (N == 2) {
   32|  1.26k|            lambda.template operator()<0>();
   33|  1.26k|            lambda.template operator()<1>();
   34|       |         }
   35|       |         else if constexpr (N == 3) {
   36|       |            lambda.template operator()<0>();
   37|       |            lambda.template operator()<1>();
   38|       |            lambda.template operator()<2>();
   39|       |         }
   40|       |         else if constexpr (N == 4) {
   41|       |            lambda.template operator()<0>();
   42|       |            lambda.template operator()<1>();
   43|       |            lambda.template operator()<2>();
   44|       |            lambda.template operator()<3>();
   45|       |         }
   46|       |         else {
   47|       |            [&]<size_t... I>(std::index_sequence<I...>) {
   48|       |               (void)(lambda.template operator()<I>(), ...);
   49|       |            }(std::make_index_sequence<N>{});
   50|       |         }
   51|  1.26k|      }
   52|  1.26k|   }
_ZZZN3glz5visitILm13EZNS_16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT1_OT3_OT4_OT5_DpOT2_EUlTnmvE_EEvOSB_mENKUlTpTnmNSt3__116integer_sequenceImJXspT_EEEEE_clIJLm0ELm1ELm2ELm3ELm4ELm5ELm6ELm7ELm8ELm9ELm10ELm11ELm12EEEEDaSR_ENKUlRSN_E7_clESU_:
  312|    414|               return std::array{+[](std::decay_t<decltype(lambda)>& l) { l.template operator()<I>(); }...};
_ZZZN3glz5visitILm13EZNS_16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT1_OT3_OT4_OT5_DpOT2_EUlTnmvE_EEvOSB_mENKUlTpTnmNSt3__116integer_sequenceImJXspT_EEEEE_clIJLm0ELm1ELm2ELm3ELm4ELm5ELm6ELm7ELm8ELm9ELm10ELm11ELm12EEEEDaSR_ENKUlRSN_E8_clESU_:
  312|  8.22k|               return std::array{+[](std::decay_t<decltype(lambda)>& l) { l.template operator()<I>(); }...};
_ZZZN3glz5visitILm13EZNS_16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT1_OT3_OT4_OT5_DpOT2_EUlTnmvE_EEvOSB_mENKUlTpTnmNSt3__116integer_sequenceImJXspT_EEEEE_clIJLm0ELm1ELm2ELm3ELm4ELm5ELm6ELm7ELm8ELm9ELm10ELm11ELm12EEEEDaSR_ENKUlRSN_E9_clESU_:
  312|    102|               return std::array{+[](std::decay_t<decltype(lambda)>& l) { l.template operator()<I>(); }...};
_ZZZN3glz5visitILm13EZNS_16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT1_OT3_OT4_OT5_DpOT2_EUlTnmvE_EEvOSB_mENKUlTpTnmNSt3__116integer_sequenceImJXspT_EEEEE_clIJLm0ELm1ELm2ELm3ELm4ELm5ELm6ELm7ELm8ELm9ELm10ELm11ELm12EEEEDaSR_ENKUlRSN_E10_clESU_:
  312|     64|               return std::array{+[](std::decay_t<decltype(lambda)>& l) { l.template operator()<I>(); }...};
_ZZZN3glz5visitILm13EZNS_16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT1_OT3_OT4_OT5_DpOT2_EUlTnmvE_EEvOSB_mENKUlTpTnmNSt3__116integer_sequenceImJXspT_EEEEE_clIJLm0ELm1ELm2ELm3ELm4ELm5ELm6ELm7ELm8ELm9ELm10ELm11ELm12EEEEDaSR_ENKUlRSN_E11_clESU_:
  312|    163|               return std::array{+[](std::decay_t<decltype(lambda)>& l) { l.template operator()<I>(); }...};
_ZN3glz8for_eachILm13EZNS_2toILj10EN12jsonrpc_fuzz8fuzz_apiEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS3_RNSt3__112basic_stringIcNS8_11char_traitsIcEENS8_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_EUlTnmvE_EEvSL_:
   24|     43|   {
   25|     43|      if constexpr (N > 0) {
   26|       |         // Explicit sizes for small N to help the compiler and make debugging easier
   27|       |         // These generate less assembly with O0, but make no difference for higher optimization
   28|       |         if constexpr (N == 1) {
   29|       |            lambda.template operator()<0>();
   30|       |         }
   31|       |         else if constexpr (N == 2) {
   32|       |            lambda.template operator()<0>();
   33|       |            lambda.template operator()<1>();
   34|       |         }
   35|       |         else if constexpr (N == 3) {
   36|       |            lambda.template operator()<0>();
   37|       |            lambda.template operator()<1>();
   38|       |            lambda.template operator()<2>();
   39|       |         }
   40|       |         else if constexpr (N == 4) {
   41|       |            lambda.template operator()<0>();
   42|       |            lambda.template operator()<1>();
   43|       |            lambda.template operator()<2>();
   44|       |            lambda.template operator()<3>();
   45|       |         }
   46|     43|         else {
   47|     43|            [&]<size_t... I>(std::index_sequence<I...>) {
   48|     43|               (void)(lambda.template operator()<I>(), ...);
   49|     43|            }(std::make_index_sequence<N>{});
   50|     43|         }
   51|     43|      }
   52|     43|   }
_ZZN3glz8for_eachILm13EZNS_2toILj10EN12jsonrpc_fuzz8fuzz_apiEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS3_RNSt3__112basic_stringIcNS8_11char_traitsIcEENS8_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_EUlTnmvE_EEvSL_ENKUlTpTnmNS8_16integer_sequenceImJXspT_EEEEE_clIJLm0ELm1ELm2ELm3ELm4ELm5ELm6ELm7ELm8ELm9ELm10ELm11ELm12EEEEDaSU_:
   47|     43|            [&]<size_t... I>(std::index_sequence<I...>) {
   48|     43|               (void)(lambda.template operator()<I>(), ...);
   49|     43|            }(std::make_index_sequence<N>{});
_ZN3glz8for_eachILm2EZNS_2toILj10EN12jsonrpc_fuzz5pointEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS3_RNSt3__112basic_stringIcNS8_11char_traitsIcEENS8_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_EUlTnmvE_EEvSL_:
   24|    262|   {
   25|    262|      if constexpr (N > 0) {
   26|       |         // Explicit sizes for small N to help the compiler and make debugging easier
   27|       |         // These generate less assembly with O0, but make no difference for higher optimization
   28|       |         if constexpr (N == 1) {
   29|       |            lambda.template operator()<0>();
   30|       |         }
   31|    262|         else if constexpr (N == 2) {
   32|    262|            lambda.template operator()<0>();
   33|    262|            lambda.template operator()<1>();
   34|       |         }
   35|       |         else if constexpr (N == 3) {
   36|       |            lambda.template operator()<0>();
   37|       |            lambda.template operator()<1>();
   38|       |            lambda.template operator()<2>();
   39|       |         }
   40|       |         else if constexpr (N == 4) {
   41|       |            lambda.template operator()<0>();
   42|       |            lambda.template operator()<1>();
   43|       |            lambda.template operator()<2>();
   44|       |            lambda.template operator()<3>();
   45|       |         }
   46|       |         else {
   47|       |            [&]<size_t... I>(std::index_sequence<I...>) {
   48|       |               (void)(lambda.template operator()<I>(), ...);
   49|       |            }(std::make_index_sequence<N>{});
   50|       |         }
   51|    262|      }
   52|    262|   }
_ZN3glz8for_eachILm2EZNS_2toILj10EN12jsonrpc_fuzz6nestedEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS3_RNSt3__112basic_stringIcNS8_11char_traitsIcEENS8_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_EUlTnmvE_EEvSL_:
   24|     99|   {
   25|     99|      if constexpr (N > 0) {
   26|       |         // Explicit sizes for small N to help the compiler and make debugging easier
   27|       |         // These generate less assembly with O0, but make no difference for higher optimization
   28|       |         if constexpr (N == 1) {
   29|       |            lambda.template operator()<0>();
   30|       |         }
   31|     99|         else if constexpr (N == 2) {
   32|     99|            lambda.template operator()<0>();
   33|     99|            lambda.template operator()<1>();
   34|       |         }
   35|       |         else if constexpr (N == 3) {
   36|       |            lambda.template operator()<0>();
   37|       |            lambda.template operator()<1>();
   38|       |            lambda.template operator()<2>();
   39|       |         }
   40|       |         else if constexpr (N == 4) {
   41|       |            lambda.template operator()<0>();
   42|       |            lambda.template operator()<1>();
   43|       |            lambda.template operator()<2>();
   44|       |            lambda.template operator()<3>();
   45|       |         }
   46|       |         else {
   47|       |            [&]<size_t... I>(std::index_sequence<I...>) {
   48|       |               (void)(lambda.template operator()<I>(), ...);
   49|       |            }(std::make_index_sequence<N>{});
   50|       |         }
   51|     99|      }
   52|     99|   }
jsonrpc_registry.cpp:_ZN3glz8for_eachILm13EZNS_8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS5_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS8_EEEvRT0_EUlTnDavE_EEvOS9_:
   24|  61.1k|   {
   25|  61.1k|      if constexpr (N > 0) {
   26|       |         // Explicit sizes for small N to help the compiler and make debugging easier
   27|       |         // These generate less assembly with O0, but make no difference for higher optimization
   28|       |         if constexpr (N == 1) {
   29|       |            lambda.template operator()<0>();
   30|       |         }
   31|       |         else if constexpr (N == 2) {
   32|       |            lambda.template operator()<0>();
   33|       |            lambda.template operator()<1>();
   34|       |         }
   35|       |         else if constexpr (N == 3) {
   36|       |            lambda.template operator()<0>();
   37|       |            lambda.template operator()<1>();
   38|       |            lambda.template operator()<2>();
   39|       |         }
   40|       |         else if constexpr (N == 4) {
   41|       |            lambda.template operator()<0>();
   42|       |            lambda.template operator()<1>();
   43|       |            lambda.template operator()<2>();
   44|       |            lambda.template operator()<3>();
   45|       |         }
   46|  61.1k|         else {
   47|  61.1k|            [&]<size_t... I>(std::index_sequence<I...>) {
   48|  61.1k|               (void)(lambda.template operator()<I>(), ...);
   49|  61.1k|            }(std::make_index_sequence<N>{});
   50|  61.1k|         }
   51|  61.1k|      }
   52|  61.1k|   }
jsonrpc_registry.cpp:_ZZN3glz8for_eachILm13EZNS_8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS5_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS8_EEEvRT0_EUlTnDavE_EEvOS9_ENKUlTpTnmNSt3__116integer_sequenceImJXspT_EEEEE_clIJLm0ELm1ELm2ELm3ELm4ELm5ELm6ELm7ELm8ELm9ELm10ELm11ELm12EEEEDaSF_:
   47|  61.1k|            [&]<size_t... I>(std::index_sequence<I...>) {
   48|  61.1k|               (void)(lambda.template operator()<I>(), ...);
   49|  61.1k|            }(std::make_index_sequence<N>{});
jsonrpc_registry.cpp:_ZN3glz8for_eachILm2EZNS_8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz5pointEL_ZZZNS4_IL_ZNS5_L10empty_pathEENS6_8fuzz_apiEL_ZNS5_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS9_EEEvRT0_ENKUlTnDavE_clILm2EEEDavE8full_keyEQoo14glaze_object_tIS9_E11reflectableIS9_EEEvSB_EUlTnDavE_EEvOSA_:
   24|  61.1k|   {
   25|  61.1k|      if constexpr (N > 0) {
   26|       |         // Explicit sizes for small N to help the compiler and make debugging easier
   27|       |         // These generate less assembly with O0, but make no difference for higher optimization
   28|       |         if constexpr (N == 1) {
   29|       |            lambda.template operator()<0>();
   30|       |         }
   31|  61.1k|         else if constexpr (N == 2) {
   32|  61.1k|            lambda.template operator()<0>();
   33|  61.1k|            lambda.template operator()<1>();
   34|       |         }
   35|       |         else if constexpr (N == 3) {
   36|       |            lambda.template operator()<0>();
   37|       |            lambda.template operator()<1>();
   38|       |            lambda.template operator()<2>();
   39|       |         }
   40|       |         else if constexpr (N == 4) {
   41|       |            lambda.template operator()<0>();
   42|       |            lambda.template operator()<1>();
   43|       |            lambda.template operator()<2>();
   44|       |            lambda.template operator()<3>();
   45|       |         }
   46|       |         else {
   47|       |            [&]<size_t... I>(std::index_sequence<I...>) {
   48|       |               (void)(lambda.template operator()<I>(), ...);
   49|       |            }(std::make_index_sequence<N>{});
   50|       |         }
   51|  61.1k|      }
   52|  61.1k|   }
jsonrpc_registry.cpp:_ZN3glz8for_eachILm2EZNS_8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz6nestedEL_ZZZNS4_IL_ZNS5_L10empty_pathEENS6_8fuzz_apiEL_ZNS5_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS9_EEEvRT0_ENKUlTnDavE_clILm3EEEDavE8full_keyEQoo14glaze_object_tIS9_E11reflectableIS9_EEEvSB_EUlTnDavE_EEvOSA_:
   24|  61.1k|   {
   25|  61.1k|      if constexpr (N > 0) {
   26|       |         // Explicit sizes for small N to help the compiler and make debugging easier
   27|       |         // These generate less assembly with O0, but make no difference for higher optimization
   28|       |         if constexpr (N == 1) {
   29|       |            lambda.template operator()<0>();
   30|       |         }
   31|  61.1k|         else if constexpr (N == 2) {
   32|  61.1k|            lambda.template operator()<0>();
   33|  61.1k|            lambda.template operator()<1>();
   34|       |         }
   35|       |         else if constexpr (N == 3) {
   36|       |            lambda.template operator()<0>();
   37|       |            lambda.template operator()<1>();
   38|       |            lambda.template operator()<2>();
   39|       |         }
   40|       |         else if constexpr (N == 4) {
   41|       |            lambda.template operator()<0>();
   42|       |            lambda.template operator()<1>();
   43|       |            lambda.template operator()<2>();
   44|       |            lambda.template operator()<3>();
   45|       |         }
   46|       |         else {
   47|       |            [&]<size_t... I>(std::index_sequence<I...>) {
   48|       |               (void)(lambda.template operator()<I>(), ...);
   49|       |            }(std::make_index_sequence<N>{});
   50|       |         }
   51|  61.1k|      }
   52|  61.1k|   }
_ZN3glz5visitILm4EZNS_16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENS_3rpc18request_envelope_tERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT1_OT3_OT4_OT5_DpOT2_EUlTnmvE_EEvOSB_m:
   81|   248k|   {
   82|   248k|      if constexpr (N > 0) {
   83|       |         // Explicit sizes for small N to help the compiler and make debugging easier
   84|       |         if constexpr (N == 1) {
   85|       |            (void)index;
   86|       |            (void)(lambda.template operator()<0>());
   87|       |         }
   88|       |         else if constexpr (N == 2) {
   89|       |            switch (index) {
   90|       |            case 0:
   91|       |               lambda.template operator()<0>();
   92|       |               break;
   93|       |            case 1:
   94|       |               lambda.template operator()<1>();
   95|       |               break;
   96|       |            default:
   97|       |               std::unreachable();
   98|       |            }
   99|       |         }
  100|       |         else if constexpr (N == 3) {
  101|       |            switch (index) {
  102|       |            case 0:
  103|       |               lambda.template operator()<0>();
  104|       |               break;
  105|       |            case 1:
  106|       |               lambda.template operator()<1>();
  107|       |               break;
  108|       |            case 2:
  109|       |               lambda.template operator()<2>();
  110|       |               break;
  111|       |            default:
  112|       |               std::unreachable();
  113|       |            }
  114|       |         }
  115|   248k|         else if constexpr (N == 4) {
  116|   248k|            switch (index) {
  117|  64.3k|            case 0:
  ------------------
  |  Branch (117:13): [True: 64.3k, False: 184k]
  ------------------
  118|  64.3k|               lambda.template operator()<0>();
  119|  64.3k|               break;
  120|  52.1k|            case 1:
  ------------------
  |  Branch (120:13): [True: 52.1k, False: 196k]
  ------------------
  121|  52.1k|               lambda.template operator()<1>();
  122|  52.1k|               break;
  123|  36.6k|            case 2:
  ------------------
  |  Branch (123:13): [True: 36.6k, False: 212k]
  ------------------
  124|  36.6k|               lambda.template operator()<2>();
  125|  36.6k|               break;
  126|  95.5k|            case 3:
  ------------------
  |  Branch (126:13): [True: 95.5k, False: 153k]
  ------------------
  127|  95.5k|               lambda.template operator()<3>();
  128|  95.5k|               break;
  129|      0|            default:
  ------------------
  |  Branch (129:13): [True: 0, False: 248k]
  ------------------
  130|      0|               std::unreachable();
  131|   248k|            }
  132|       |         }
  133|       |         else if constexpr (N == 5) {
  134|       |            switch (index) {
  135|       |            case 0:
  136|       |               lambda.template operator()<0>();
  137|       |               break;
  138|       |            case 1:
  139|       |               lambda.template operator()<1>();
  140|       |               break;
  141|       |            case 2:
  142|       |               lambda.template operator()<2>();
  143|       |               break;
  144|       |            case 3:
  145|       |               lambda.template operator()<3>();
  146|       |               break;
  147|       |            case 4:
  148|       |               lambda.template operator()<4>();
  149|       |               break;
  150|       |            default:
  151|       |               std::unreachable();
  152|       |            }
  153|       |         }
  154|       |         else if constexpr (N == 6) {
  155|       |            switch (index) {
  156|       |            case 0:
  157|       |               lambda.template operator()<0>();
  158|       |               break;
  159|       |            case 1:
  160|       |               lambda.template operator()<1>();
  161|       |               break;
  162|       |            case 2:
  163|       |               lambda.template operator()<2>();
  164|       |               break;
  165|       |            case 3:
  166|       |               lambda.template operator()<3>();
  167|       |               break;
  168|       |            case 4:
  169|       |               lambda.template operator()<4>();
  170|       |               break;
  171|       |            case 5:
  172|       |               lambda.template operator()<5>();
  173|       |               break;
  174|       |            default:
  175|       |               std::unreachable();
  176|       |            }
  177|       |         }
  178|       |         else if constexpr (N == 7) {
  179|       |            switch (index) {
  180|       |            case 0:
  181|       |               lambda.template operator()<0>();
  182|       |               break;
  183|       |            case 1:
  184|       |               lambda.template operator()<1>();
  185|       |               break;
  186|       |            case 2:
  187|       |               lambda.template operator()<2>();
  188|       |               break;
  189|       |            case 3:
  190|       |               lambda.template operator()<3>();
  191|       |               break;
  192|       |            case 4:
  193|       |               lambda.template operator()<4>();
  194|       |               break;
  195|       |            case 5:
  196|       |               lambda.template operator()<5>();
  197|       |               break;
  198|       |            case 6:
  199|       |               lambda.template operator()<6>();
  200|       |               break;
  201|       |            default:
  202|       |               std::unreachable();
  203|       |            }
  204|       |         }
  205|       |         else if constexpr (N == 8) {
  206|       |            switch (index) {
  207|       |            case 0:
  208|       |               lambda.template operator()<0>();
  209|       |               break;
  210|       |            case 1:
  211|       |               lambda.template operator()<1>();
  212|       |               break;
  213|       |            case 2:
  214|       |               lambda.template operator()<2>();
  215|       |               break;
  216|       |            case 3:
  217|       |               lambda.template operator()<3>();
  218|       |               break;
  219|       |            case 4:
  220|       |               lambda.template operator()<4>();
  221|       |               break;
  222|       |            case 5:
  223|       |               lambda.template operator()<5>();
  224|       |               break;
  225|       |            case 6:
  226|       |               lambda.template operator()<6>();
  227|       |               break;
  228|       |            case 7:
  229|       |               lambda.template operator()<7>();
  230|       |               break;
  231|       |            default:
  232|       |               std::unreachable();
  233|       |            }
  234|       |         }
  235|       |         else if constexpr (N == 9) {
  236|       |            switch (index) {
  237|       |            case 0:
  238|       |               lambda.template operator()<0>();
  239|       |               break;
  240|       |            case 1:
  241|       |               lambda.template operator()<1>();
  242|       |               break;
  243|       |            case 2:
  244|       |               lambda.template operator()<2>();
  245|       |               break;
  246|       |            case 3:
  247|       |               lambda.template operator()<3>();
  248|       |               break;
  249|       |            case 4:
  250|       |               lambda.template operator()<4>();
  251|       |               break;
  252|       |            case 5:
  253|       |               lambda.template operator()<5>();
  254|       |               break;
  255|       |            case 6:
  256|       |               lambda.template operator()<6>();
  257|       |               break;
  258|       |            case 7:
  259|       |               lambda.template operator()<7>();
  260|       |               break;
  261|       |            case 8:
  262|       |               lambda.template operator()<8>();
  263|       |               break;
  264|       |            default:
  265|       |               std::unreachable();
  266|       |            }
  267|       |         }
  268|       |         else if constexpr (N == 10) {
  269|       |            switch (index) {
  270|       |            case 0:
  271|       |               lambda.template operator()<0>();
  272|       |               break;
  273|       |            case 1:
  274|       |               lambda.template operator()<1>();
  275|       |               break;
  276|       |            case 2:
  277|       |               lambda.template operator()<2>();
  278|       |               break;
  279|       |            case 3:
  280|       |               lambda.template operator()<3>();
  281|       |               break;
  282|       |            case 4:
  283|       |               lambda.template operator()<4>();
  284|       |               break;
  285|       |            case 5:
  286|       |               lambda.template operator()<5>();
  287|       |               break;
  288|       |            case 6:
  289|       |               lambda.template operator()<6>();
  290|       |               break;
  291|       |            case 7:
  292|       |               lambda.template operator()<7>();
  293|       |               break;
  294|       |            case 8:
  295|       |               lambda.template operator()<8>();
  296|       |               break;
  297|       |            case 9:
  298|       |               lambda.template operator()<9>();
  299|       |               break;
  300|       |            default:
  301|       |               std::unreachable();
  302|       |            }
  303|       |         }
  304|       |         else {
  305|       |#ifdef _MSC_VER
  306|       |            using Lambda = std::decay_t<decltype(lambda)>;
  307|       |            static const auto jump_table = []<size_t... I>(std::index_sequence<I...>) {
  308|       |               return std::array{make_jump_function<I, Lambda>()...};
  309|       |            }(std::make_index_sequence<N>{});
  310|       |#else
  311|       |            static constexpr auto jump_table = []<size_t... I>(std::index_sequence<I...>) {
  312|       |               return std::array{+[](std::decay_t<decltype(lambda)>& l) { l.template operator()<I>(); }...};
  313|       |            }(std::make_index_sequence<N>{});
  314|       |#endif
  315|       |
  316|       |#if defined(__clang_major__) && (__clang_major__ >= 19)
  317|       |            [[assume(index < N)]];
  318|       |#endif
  319|       |            jump_table[index](lambda);
  320|       |
  321|       |            // This code runs significantly slower on Clang
  322|       |            // Simple tests with assembly show that this should be faster,
  323|       |            // but full Glaze assembly need to be looked into
  324|       |            /*[&, index]<size_t... I>(std::index_sequence<I...>) {
  325|       |               (void)((index == I ? lambda.template operator()<I>() : void()), ...);
  326|       |            }(std::make_index_sequence<N>{});*/
  327|       |         }
  328|   248k|      }
  329|   248k|   }
_ZN3glz8for_eachILm3EZNS_28process_variant_alternativesINSt3__17variantIJDnNS2_17basic_string_viewIcNS2_11char_traitsIcEEEElEEENS_14is_variant_strEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS8_TkNS_10is_contextERNS_7contextERPKcSH_EEvOT0_OT1_OT2_T3_EUlTnmvE_EEvSK_:
   24|  9.00k|   {
   25|  9.00k|      if constexpr (N > 0) {
   26|       |         // Explicit sizes for small N to help the compiler and make debugging easier
   27|       |         // These generate less assembly with O0, but make no difference for higher optimization
   28|       |         if constexpr (N == 1) {
   29|       |            lambda.template operator()<0>();
   30|       |         }
   31|       |         else if constexpr (N == 2) {
   32|       |            lambda.template operator()<0>();
   33|       |            lambda.template operator()<1>();
   34|       |         }
   35|  9.00k|         else if constexpr (N == 3) {
   36|  9.00k|            lambda.template operator()<0>();
   37|  9.00k|            lambda.template operator()<1>();
   38|  9.00k|            lambda.template operator()<2>();
   39|       |         }
   40|       |         else if constexpr (N == 4) {
   41|       |            lambda.template operator()<0>();
   42|       |            lambda.template operator()<1>();
   43|       |            lambda.template operator()<2>();
   44|       |            lambda.template operator()<3>();
   45|       |         }
   46|       |         else {
   47|       |            [&]<size_t... I>(std::index_sequence<I...>) {
   48|       |               (void)(lambda.template operator()<I>(), ...);
   49|       |            }(std::make_index_sequence<N>{});
   50|       |         }
   51|  9.00k|      }
   52|  9.00k|   }
_ZN3glz8for_eachILm3EZNS_28process_variant_alternativesINSt3__17variantIJDnNS2_17basic_string_viewIcNS2_11char_traitsIcEEEElEEENS_14is_variant_numEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS8_TkNS_10is_contextERNS_7contextERPKcSH_EEvOT0_OT1_OT2_T3_EUlTnmvE_EEvSK_:
   24|  86.1k|   {
   25|  86.1k|      if constexpr (N > 0) {
   26|       |         // Explicit sizes for small N to help the compiler and make debugging easier
   27|       |         // These generate less assembly with O0, but make no difference for higher optimization
   28|       |         if constexpr (N == 1) {
   29|       |            lambda.template operator()<0>();
   30|       |         }
   31|       |         else if constexpr (N == 2) {
   32|       |            lambda.template operator()<0>();
   33|       |            lambda.template operator()<1>();
   34|       |         }
   35|  86.1k|         else if constexpr (N == 3) {
   36|  86.1k|            lambda.template operator()<0>();
   37|  86.1k|            lambda.template operator()<1>();
   38|  86.1k|            lambda.template operator()<2>();
   39|       |         }
   40|       |         else if constexpr (N == 4) {
   41|       |            lambda.template operator()<0>();
   42|       |            lambda.template operator()<1>();
   43|       |            lambda.template operator()<2>();
   44|       |            lambda.template operator()<3>();
   45|       |         }
   46|       |         else {
   47|       |            [&]<size_t... I>(std::index_sequence<I...>) {
   48|       |               (void)(lambda.template operator()<I>(), ...);
   49|       |            }(std::make_index_sequence<N>{});
   50|       |         }
   51|  86.1k|      }
   52|  86.1k|   }
_ZN3glz8for_eachILm1EZNS_13get_view_jsonITnNS_14string_literalEXtlNS2_ILm4EEEtlA4_cLc47ELc105ELc100EEEETnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETkNS_10contiguousERNSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEEEDaOT1_EUlTnmvE_EEvOT0_:
   24|   122k|   {
   25|   122k|      if constexpr (N > 0) {
   26|       |         // Explicit sizes for small N to help the compiler and make debugging easier
   27|       |         // These generate less assembly with O0, but make no difference for higher optimization
   28|   122k|         if constexpr (N == 1) {
   29|   122k|            lambda.template operator()<0>();
   30|       |         }
   31|       |         else if constexpr (N == 2) {
   32|       |            lambda.template operator()<0>();
   33|       |            lambda.template operator()<1>();
   34|       |         }
   35|       |         else if constexpr (N == 3) {
   36|       |            lambda.template operator()<0>();
   37|       |            lambda.template operator()<1>();
   38|       |            lambda.template operator()<2>();
   39|       |         }
   40|       |         else if constexpr (N == 4) {
   41|       |            lambda.template operator()<0>();
   42|       |            lambda.template operator()<1>();
   43|       |            lambda.template operator()<2>();
   44|       |            lambda.template operator()<3>();
   45|       |         }
   46|       |         else {
   47|       |            [&]<size_t... I>(std::index_sequence<I...>) {
   48|       |               (void)(lambda.template operator()<I>(), ...);
   49|       |            }(std::make_index_sequence<N>{});
   50|       |         }
   51|   122k|      }
   52|   122k|   }
_ZN3glz8for_eachILm6EZNS_28process_variant_alternativesINSt3__17variantIJDndNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEbNS2_6vectorINS_12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEENS7_ISE_EEEENSD_ISE_EEEEENS_16is_variant_arrayEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSI_TkNS_10is_contextERNS_7contextERPKcSR_EEvOT0_OT1_OT2_T3_EUlTnmvE_EEvSU_:
   24|  16.7k|   {
   25|  16.7k|      if constexpr (N > 0) {
   26|       |         // Explicit sizes for small N to help the compiler and make debugging easier
   27|       |         // These generate less assembly with O0, but make no difference for higher optimization
   28|       |         if constexpr (N == 1) {
   29|       |            lambda.template operator()<0>();
   30|       |         }
   31|       |         else if constexpr (N == 2) {
   32|       |            lambda.template operator()<0>();
   33|       |            lambda.template operator()<1>();
   34|       |         }
   35|       |         else if constexpr (N == 3) {
   36|       |            lambda.template operator()<0>();
   37|       |            lambda.template operator()<1>();
   38|       |            lambda.template operator()<2>();
   39|       |         }
   40|       |         else if constexpr (N == 4) {
   41|       |            lambda.template operator()<0>();
   42|       |            lambda.template operator()<1>();
   43|       |            lambda.template operator()<2>();
   44|       |            lambda.template operator()<3>();
   45|       |         }
   46|  16.7k|         else {
   47|  16.7k|            [&]<size_t... I>(std::index_sequence<I...>) {
   48|  16.7k|               (void)(lambda.template operator()<I>(), ...);
   49|  16.7k|            }(std::make_index_sequence<N>{});
   50|  16.7k|         }
   51|  16.7k|      }
   52|  16.7k|   }
_ZZN3glz8for_eachILm6EZNS_28process_variant_alternativesINSt3__17variantIJDndNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEbNS2_6vectorINS_12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEENS7_ISE_EEEENSD_ISE_EEEEENS_16is_variant_arrayEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSI_TkNS_10is_contextERNS_7contextERPKcSR_EEvOT0_OT1_OT2_T3_EUlTnmvE_EEvSU_ENKUlTpTnmNS2_16integer_sequenceImJXspT_EEEEE_clIJLm0ELm1ELm2ELm3ELm4ELm5EEEEDaS12_:
   47|  16.7k|            [&]<size_t... I>(std::index_sequence<I...>) {
   48|  16.7k|               (void)(lambda.template operator()<I>(), ...);
   49|  16.7k|            }(std::make_index_sequence<N>{});
_ZN3glz8for_eachILm6EZNS_28process_variant_alternativesINSt3__17variantIJDndNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEbNS2_6vectorINS_12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEENS7_ISE_EEEENSD_ISE_EEEEENS_14is_variant_strEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSI_TkNS_10is_contextERNS_7contextERPKcSR_EEvOT0_OT1_OT2_T3_EUlTnmvE_EEvSU_:
   24|   759k|   {
   25|   759k|      if constexpr (N > 0) {
   26|       |         // Explicit sizes for small N to help the compiler and make debugging easier
   27|       |         // These generate less assembly with O0, but make no difference for higher optimization
   28|       |         if constexpr (N == 1) {
   29|       |            lambda.template operator()<0>();
   30|       |         }
   31|       |         else if constexpr (N == 2) {
   32|       |            lambda.template operator()<0>();
   33|       |            lambda.template operator()<1>();
   34|       |         }
   35|       |         else if constexpr (N == 3) {
   36|       |            lambda.template operator()<0>();
   37|       |            lambda.template operator()<1>();
   38|       |            lambda.template operator()<2>();
   39|       |         }
   40|       |         else if constexpr (N == 4) {
   41|       |            lambda.template operator()<0>();
   42|       |            lambda.template operator()<1>();
   43|       |            lambda.template operator()<2>();
   44|       |            lambda.template operator()<3>();
   45|       |         }
   46|   759k|         else {
   47|   759k|            [&]<size_t... I>(std::index_sequence<I...>) {
   48|   759k|               (void)(lambda.template operator()<I>(), ...);
   49|   759k|            }(std::make_index_sequence<N>{});
   50|   759k|         }
   51|   759k|      }
   52|   759k|   }
_ZZN3glz8for_eachILm6EZNS_28process_variant_alternativesINSt3__17variantIJDndNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEbNS2_6vectorINS_12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEENS7_ISE_EEEENSD_ISE_EEEEENS_14is_variant_strEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSI_TkNS_10is_contextERNS_7contextERPKcSR_EEvOT0_OT1_OT2_T3_EUlTnmvE_EEvSU_ENKUlTpTnmNS2_16integer_sequenceImJXspT_EEEEE_clIJLm0ELm1ELm2ELm3ELm4ELm5EEEEDaS12_:
   47|   759k|            [&]<size_t... I>(std::index_sequence<I...>) {
   48|   759k|               (void)(lambda.template operator()<I>(), ...);
   49|   759k|            }(std::make_index_sequence<N>{});
_ZN3glz8for_eachILm6EZNS_28process_variant_alternativesINSt3__17variantIJDndNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEbNS2_6vectorINS_12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEENS7_ISE_EEEENSD_ISE_EEEEENS_14is_variant_numEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSI_TkNS_10is_contextERNS_7contextERPKcSR_EEvOT0_OT1_OT2_T3_EUlTnmvE_EEvSU_:
   24|   268k|   {
   25|   268k|      if constexpr (N > 0) {
   26|       |         // Explicit sizes for small N to help the compiler and make debugging easier
   27|       |         // These generate less assembly with O0, but make no difference for higher optimization
   28|       |         if constexpr (N == 1) {
   29|       |            lambda.template operator()<0>();
   30|       |         }
   31|       |         else if constexpr (N == 2) {
   32|       |            lambda.template operator()<0>();
   33|       |            lambda.template operator()<1>();
   34|       |         }
   35|       |         else if constexpr (N == 3) {
   36|       |            lambda.template operator()<0>();
   37|       |            lambda.template operator()<1>();
   38|       |            lambda.template operator()<2>();
   39|       |         }
   40|       |         else if constexpr (N == 4) {
   41|       |            lambda.template operator()<0>();
   42|       |            lambda.template operator()<1>();
   43|       |            lambda.template operator()<2>();
   44|       |            lambda.template operator()<3>();
   45|       |         }
   46|   268k|         else {
   47|   268k|            [&]<size_t... I>(std::index_sequence<I...>) {
   48|   268k|               (void)(lambda.template operator()<I>(), ...);
   49|   268k|            }(std::make_index_sequence<N>{});
   50|   268k|         }
   51|   268k|      }
   52|   268k|   }
_ZZN3glz8for_eachILm6EZNS_28process_variant_alternativesINSt3__17variantIJDndNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEbNS2_6vectorINS_12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEENS7_ISE_EEEENSD_ISE_EEEEENS_14is_variant_numEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSI_TkNS_10is_contextERNS_7contextERPKcSR_EEvOT0_OT1_OT2_T3_EUlTnmvE_EEvSU_ENKUlTpTnmNS2_16integer_sequenceImJXspT_EEEEE_clIJLm0ELm1ELm2ELm3ELm4ELm5EEEEDaS12_:
   47|   268k|            [&]<size_t... I>(std::index_sequence<I...>) {
   48|   268k|               (void)(lambda.template operator()<I>(), ...);
   49|   268k|            }(std::make_index_sequence<N>{});

_ZN3glz10from_charsILb0EdcEENS_10fast_float19from_chars_result_tIT1_EEPKS3_S6_RT0_:
  236|   912k|   {
  237|   912k|      using namespace glz::fast_float;
  238|   912k|      static_assert(is_supported_float_type<T>(), "only some floating-point types are supported");
  239|   912k|      static_assert(is_supported_char_type<UC>(), "only char, wchar_t, char16_t and char32_t are supported");
  240|       |
  241|   912k|      parsed_number_string_t<UC> pns = glz::parse_number_string<null_terminated, UC>(first, last);
  242|   912k|      if (!pns.valid) [[unlikely]] {
  ------------------
  |  Branch (242:11): [True: 1.38k, False: 911k]
  ------------------
  243|  1.38k|         return {.ptr = first, .ec = std::errc::invalid_argument};
  244|  1.38k|      }
  245|       |
  246|   911k|      return from_chars_advanced(pns, value);
  247|   912k|   }
_ZN3glz19parse_number_stringILb0EcEENS_10fast_float22parsed_number_string_tIT0_EEPKS3_S6_:
   18|   912k|   {
   19|   912k|      using namespace glz::fast_float;
   20|   912k|      static constexpr UC decimal_point = '.';
   21|       |
   22|   912k|      parsed_number_string_t<UC> answer;
   23|   912k|      answer.valid = false;
   24|   912k|      answer.too_many_digits = false;
   25|   912k|      answer.negative = (*p == UC('-'));
   26|   912k|      if (*p == UC('-')) { // C++17 20.19.3.(7.1) explicitly forbids '+' sign here
  ------------------
  |  Branch (26:11): [True: 738k, False: 174k]
  ------------------
   27|   738k|         ++p;
   28|       |
   29|   738k|         if constexpr (not null_terminated) {
   30|   738k|            if (p == pend) [[unlikely]] {
  ------------------
  |  Branch (30:17): [True: 3, False: 738k]
  ------------------
   31|      3|               return answer;
   32|      3|            }
   33|   738k|         }
   34|       |
   35|   738k|         if (!glz::fast_float::is_integer(*p)) [[unlikely]] { // a sign must be followed by an integer
  ------------------
  |  Branch (35:14): [True: 39, False: 738k]
  ------------------
   36|     39|            return answer;
   37|     39|         }
   38|   738k|      }
   39|   912k|      UC const* const start_digits = p;
   40|       |
   41|   912k|      uint64_t i = 0; // an unsigned int avoids signed overflows (which are bad)
   42|       |
   43|   912k|      uint64_t digit;
   44|       |      if constexpr (null_terminated) {
   45|       |         while ((digit = glz::fast_float::digit_value(*p)) <= 9) {
   46|       |            // a multiplication by 10 is cheaper than an arbitrary integer
   47|       |            // multiplication
   48|       |            i = 10 * i + digit; // might overflow, we will handle the overflow later
   49|       |            ++p;
   50|       |         }
   51|       |      }
   52|   912k|      else {
   53|  4.56M|         while ((p != pend) && (digit = glz::fast_float::digit_value(*p)) <= 9) {
  ------------------
  |  Branch (53:17): [True: 4.56M, False: 593]
  |  Branch (53:32): [True: 3.65M, False: 912k]
  ------------------
   54|       |            // a multiplication by 10 is cheaper than an arbitrary integer
   55|       |            // multiplication
   56|  3.65M|            i = 10 * i + digit; // might overflow, we will handle the overflow later
   57|  3.65M|            ++p;
   58|  3.65M|         }
   59|   912k|      }
   60|       |
   61|   912k|      UC const* const end_of_integer_part = p;
   62|   912k|      int64_t digit_count = int64_t(end_of_integer_part - start_digits);
   63|   912k|      answer.integer = glz::fast_float::span<const UC>(start_digits, size_t(digit_count));
   64|       |
   65|       |      // at least 1 digit in integer part, without leading zeros
   66|   912k|      if (digit_count == 0 || (start_digits[0] == UC('0') && digit_count > 1)) {
  ------------------
  |  Branch (66:11): [True: 1.25k, False: 911k]
  |  Branch (66:32): [True: 11.9k, False: 899k]
  |  Branch (66:62): [True: 56, False: 11.9k]
  ------------------
   67|  1.31k|         return answer;
   68|  1.31k|      }
   69|       |
   70|   911k|      int64_t exponent = 0;
   71|   911k|      const bool has_decimal_point = [&] {
   72|   911k|         if constexpr (null_terminated) {
   73|   911k|            return (*p == decimal_point);
   74|   911k|         }
   75|   911k|         else {
   76|   911k|            return (p != pend) && (*p == decimal_point);
   77|   911k|         }
   78|   911k|      }();
   79|   911k|      if (has_decimal_point) {
  ------------------
  |  Branch (79:11): [True: 32.8k, False: 878k]
  ------------------
   80|  32.8k|         ++p;
   81|  32.8k|         UC const* before = p;
   82|       |         // can occur at most twice without overflowing, but let it occur more, since
   83|       |         // for integers with many digits, digit parsing is the primary bottleneck.
   84|  32.8k|         loop_parse_if_eight_digits(p, pend, i);
   85|       |
   86|       |         if constexpr (null_terminated) {
   87|       |            while ((digit = glz::fast_float::digit_value(*p)) <= 9) {
   88|       |               ++p;
   89|       |               i = i * 10 + digit; // in rare cases, this will overflow, but that's ok
   90|       |            }
   91|       |         }
   92|  32.8k|         else {
   93|   154k|            while ((p != pend) && (digit = glz::fast_float::digit_value(*p)) <= 9) {
  ------------------
  |  Branch (93:20): [True: 153k, False: 936]
  |  Branch (93:35): [True: 121k, False: 31.9k]
  ------------------
   94|   121k|               ++p;
   95|   121k|               i = i * 10 + digit; // in rare cases, this will overflow, but that's ok
   96|   121k|            }
   97|  32.8k|         }
   98|  32.8k|         exponent = before - p;
   99|  32.8k|         answer.fraction = glz::fast_float::span<const UC>(before, size_t(p - before));
  100|  32.8k|         digit_count -= exponent;
  101|  32.8k|      }
  102|       |      // at least 1 digit in fractional part
  103|   911k|      if (has_decimal_point && exponent == 0) {
  ------------------
  |  Branch (103:11): [True: 32.8k, False: 878k]
  |  Branch (103:32): [True: 28, False: 32.8k]
  ------------------
  104|     28|         return answer;
  105|     28|      }
  106|       |
  107|   911k|      int64_t exp_number = 0; // explicit exponential part
  108|       |
  109|       |      if constexpr (null_terminated) {
  110|       |         if ((UC('e') == *p) || (UC('E') == *p)) {
  111|       |            UC const* location_of_e = p;
  112|       |            ++p;
  113|       |            bool neg_exp = false;
  114|       |            if (UC('-') == *p) {
  115|       |               neg_exp = true;
  116|       |               ++p;
  117|       |            }
  118|       |            else if (UC('+') == *p) { // '+' on exponent is allowed by C++17 20.19.3.(7.1)
  119|       |               ++p;
  120|       |            }
  121|       |            if ((digit = glz::fast_float::digit_value(*p)) > 9) {
  122|       |               // Otherwise, we will be ignoring the 'e'.
  123|       |               p = location_of_e;
  124|       |            }
  125|       |            else {
  126|       |               do {
  127|       |                  if (exp_number < 0x10000000) {
  128|       |                     exp_number = 10 * exp_number + digit;
  129|       |                  }
  130|       |                  ++p;
  131|       |               } while ((digit = glz::fast_float::digit_value(*p)) <= 9);
  132|       |               if (neg_exp) {
  133|       |                  exp_number = -exp_number;
  134|       |               }
  135|       |               exponent += exp_number;
  136|       |            }
  137|       |         }
  138|       |      }
  139|   911k|      else {
  140|   911k|         if ((p != pend) && ((UC('e') == *p) || (UC('E') == *p))) {
  ------------------
  |  Branch (140:14): [True: 910k, False: 1.51k]
  |  Branch (140:30): [True: 2.71k, False: 907k]
  |  Branch (140:49): [True: 6.68k, False: 900k]
  ------------------
  141|  9.39k|            UC const* location_of_e = p;
  142|  9.39k|            ++p;
  143|  9.39k|            bool neg_exp = false;
  144|  9.39k|            if ((p != pend) && (UC('-') == *p)) {
  ------------------
  |  Branch (144:17): [True: 9.38k, False: 14]
  |  Branch (144:32): [True: 1.78k, False: 7.60k]
  ------------------
  145|  1.78k|               neg_exp = true;
  146|  1.78k|               ++p;
  147|  1.78k|            }
  148|  7.61k|            else if ((p != pend) && (UC('+') == *p)) { // '+' on exponent is allowed by C++17 20.19.3.(7.1)
  ------------------
  |  Branch (148:22): [True: 7.60k, False: 14]
  |  Branch (148:37): [True: 214, False: 7.38k]
  ------------------
  149|    214|               ++p;
  150|    214|            }
  151|  9.39k|            if ((p == pend) || (digit = glz::fast_float::digit_value(*p)) > 9) {
  ------------------
  |  Branch (151:17): [True: 22, False: 9.37k]
  |  Branch (151:32): [True: 72, False: 9.30k]
  ------------------
  152|       |               // Otherwise, we will be ignoring the 'e'.
  153|     94|               p = location_of_e;
  154|     94|            }
  155|  9.30k|            else {
  156|  21.0k|               do {
  157|  21.0k|                  if (exp_number < 0x10000000) {
  ------------------
  |  Branch (157:23): [True: 20.1k, False: 928]
  ------------------
  158|  20.1k|                     exp_number = 10 * exp_number + digit;
  159|  20.1k|                  }
  160|  21.0k|                  ++p;
  161|  21.0k|               } while ((p != pend) && (digit = glz::fast_float::digit_value(*p)) <= 9);
  ------------------
  |  Branch (161:25): [True: 20.6k, False: 454]
  |  Branch (161:40): [True: 11.7k, False: 8.84k]
  ------------------
  162|  9.30k|               if (neg_exp) {
  ------------------
  |  Branch (162:20): [True: 1.77k, False: 7.52k]
  ------------------
  163|  1.77k|                  exp_number = -exp_number;
  164|  1.77k|               }
  165|  9.30k|               exponent += exp_number;
  166|  9.30k|            }
  167|  9.39k|         }
  168|   911k|      }
  169|       |
  170|   911k|      answer.lastmatch = p;
  171|   911k|      answer.valid = true;
  172|       |
  173|       |      // If we frequently had to deal with long strings of digits,
  174|       |      // we could extend our code by using a 128-bit integer instead
  175|       |      // of a 64-bit integer. However, this is uncommon.
  176|       |      //
  177|       |      // We can deal with up to 19 digits.
  178|   911k|      if (digit_count > 19) { // this is uncommon
  ------------------
  |  Branch (178:11): [True: 34.7k, False: 876k]
  ------------------
  179|       |         // It is possible that the integer had an overflow.
  180|       |         // We have to handle the case where we have 0.0000somenumber.
  181|       |         // We need to be mindful of the case where we only have zeroes...
  182|       |         // E.g., 0.000000000...000.
  183|  34.7k|         UC const* start = start_digits;
  184|       |         if constexpr (null_terminated) {
  185|       |            while ((*start == UC('0') || *start == decimal_point)) {
  186|       |               if (*start == UC('0')) {
  187|       |                  --digit_count;
  188|       |               }
  189|       |               ++start;
  190|       |            }
  191|       |         }
  192|  34.7k|         else {
  193|   589k|            while ((start != pend) && (*start == UC('0') || *start == decimal_point)) {
  ------------------
  |  Branch (193:20): [True: 589k, False: 22]
  |  Branch (193:40): [True: 547k, False: 41.7k]
  |  Branch (193:61): [True: 7.01k, False: 34.7k]
  ------------------
  194|   554k|               if (*start == UC('0')) {
  ------------------
  |  Branch (194:20): [True: 547k, False: 7.01k]
  ------------------
  195|   547k|                  --digit_count;
  196|   547k|               }
  197|   554k|               ++start;
  198|   554k|            }
  199|  34.7k|         }
  200|       |
  201|  34.7k|         if (digit_count > 19) {
  ------------------
  |  Branch (201:14): [True: 32.6k, False: 2.10k]
  ------------------
  202|  32.6k|            answer.too_many_digits = true;
  203|       |            // Let us start again, this time, avoiding overflows.
  204|       |            // We don't need to check if is_integer, since we use the
  205|       |            // pre-tokenized spans from above.
  206|  32.6k|            i = 0;
  207|  32.6k|            p = answer.integer.ptr;
  208|  32.6k|            UC const* int_end = p + answer.integer.len();
  209|  32.6k|            const uint64_t minimal_nineteen_digit_integer{1000000000000000000};
  210|   508k|            while ((i < minimal_nineteen_digit_integer) && (p != int_end)) {
  ------------------
  |  Branch (210:20): [True: 486k, False: 22.1k]
  |  Branch (210:60): [True: 475k, False: 10.5k]
  ------------------
  211|   475k|               i = i * 10 + uint64_t(*p - UC('0'));
  212|   475k|               ++p;
  213|   475k|            }
  214|  32.6k|            if (i >= minimal_nineteen_digit_integer) { // We have a big integers
  ------------------
  |  Branch (214:17): [True: 22.1k, False: 10.5k]
  ------------------
  215|  22.1k|               exponent = end_of_integer_part - p + exp_number;
  216|  22.1k|            }
  217|  10.5k|            else { // We have a value with a fractional component.
  218|  10.5k|               p = answer.fraction.ptr;
  219|  10.5k|               UC const* frac_end = p + answer.fraction.len();
  220|   528k|               while ((i < minimal_nineteen_digit_integer) && (p != frac_end)) {
  ------------------
  |  Branch (220:23): [True: 517k, False: 10.5k]
  |  Branch (220:63): [True: 517k, False: 0]
  ------------------
  221|   517k|                  i = i * 10 + uint64_t(*p - UC('0'));
  222|   517k|                  ++p;
  223|   517k|               }
  224|  10.5k|               exponent = answer.fraction.ptr - p + exp_number;
  225|  10.5k|            }
  226|       |            // We have now corrected both exponent and i, to a truncated value
  227|  32.6k|         }
  228|  34.7k|      }
  229|   911k|      answer.exponent = exponent;
  230|   911k|      answer.mantissa = i;
  231|   911k|      return answer;
  232|   911k|   }
_ZZN3glz19parse_number_stringILb0EcEENS_10fast_float22parsed_number_string_tIT0_EEPKS3_S6_ENKUlvE_clEv:
   71|   911k|      const bool has_decimal_point = [&] {
   72|       |         if constexpr (null_terminated) {
   73|       |            return (*p == decimal_point);
   74|       |         }
   75|   911k|         else {
   76|   911k|            return (p != pend) && (*p == decimal_point);
  ------------------
  |  Branch (76:20): [True: 911k, False: 579]
  |  Branch (76:35): [True: 32.8k, False: 878k]
  ------------------
   77|   911k|         }
   78|   911k|      }();

_ZN3glz8to_charsImQsr3stdE7same_asIu14__remove_cvrefIT_EmEEEPcS3_S1_:
  221|  4.49M|   {
  222|  4.49M|      using namespace itoa_impl;
  223|  4.49M|      if (val < 100000000) {
  ------------------
  |  Branch (223:11): [True: 4.49M, False: 0]
  ------------------
  224|  4.49M|         return u64_len_1_8(buf, uint32_t(val));
  225|  4.49M|      }
  226|      0|      else if (val < 10000000000000000ull) {
  ------------------
  |  Branch (226:16): [True: 0, False: 0]
  ------------------
  227|      0|         const uint64_t hgh = div_1e8(val);
  228|      0|         const uint32_t low = uint32_t(val - hgh * 100000000);
  229|      0|         buf = u64_len_1_8(buf, uint32_t(hgh));
  230|      0|         return u64_len_8(buf, low);
  231|      0|      }
  232|      0|      else {
  233|      0|         const uint64_t tmp = div_1e8(val);
  234|      0|         const uint32_t low = uint32_t(val - tmp * 100000000);
  235|      0|         const uint32_t hgh = uint32_t(tmp / 10000);
  236|      0|         const uint32_t mid = uint32_t(tmp - uint64_t(hgh) * 10000);
  237|      0|         buf = u64_len_5_8(buf, hgh);
  238|      0|         buf = u64_len_4(buf, mid);
  239|      0|         return u64_len_8(buf, low);
  240|      0|      }
  241|  4.49M|   }
_ZN3glz9itoa_impl11u64_len_1_8EPcj:
  157|  4.49M|      {
  158|  4.49M|         if (val < 100) {
  ------------------
  |  Branch (158:14): [True: 4.48M, False: 6.11k]
  ------------------
  159|  4.48M|            return u32_2(buf, val);
  160|  4.48M|         }
  161|  6.11k|         else if (val < 10000) {
  ------------------
  |  Branch (161:19): [True: 5.23k, False: 882]
  ------------------
  162|  5.23k|            return u32_4(buf, val);
  163|  5.23k|         }
  164|    882|         else if (val < 1000000) {
  ------------------
  |  Branch (164:19): [True: 834, False: 48]
  ------------------
  165|    834|            return u32_6(buf, val);
  166|    834|         }
  167|     48|         else {
  168|     48|            return u32_8(buf, val);
  169|     48|         }
  170|  4.49M|      }
_ZN3glz9itoa_impl5u32_2EPcj:
   74|  4.48M|      {
   75|  4.48M|         const uint32_t lz = val < 10;
   76|  4.48M|         std::memcpy(buf, char_table + ((val * 2) | lz), 2);
   77|  4.48M|         return buf + 2 - lz;
   78|  4.48M|      }
_ZN3glz9itoa_impl5u32_4EPcj:
   81|  5.23k|      {
   82|  5.23k|         const uint32_t aa = (val * 5243) >> 19; // val / 100
   83|  5.23k|         const uint32_t lz = aa < 10;
   84|  5.23k|         std::memcpy(buf, char_table + ((aa * 2) | lz), 2);
   85|  5.23k|         std::memcpy(buf + 2 - lz, &digit_pairs[val - aa * 100], 2);
   86|  5.23k|         return buf + 4 - lz;
   87|  5.23k|      }
_ZN3glz9itoa_impl5u32_6EPcj:
   90|    834|      {
   91|    834|         const uint32_t aa = uint32_t((uint64_t(val) * 429497) >> 32); // val / 10000
   92|    834|         const uint32_t bbcc = val - aa * 10000;
   93|    834|         const uint32_t bb = (bbcc * 5243) >> 19; // bbcc / 100
   94|    834|         const uint32_t lz = aa < 10;
   95|    834|         std::memcpy(buf, char_table + ((aa * 2) | lz), 2);
   96|    834|         std::memcpy(buf + 2 - lz, &digit_pairs[bb], 2);
   97|    834|         std::memcpy(buf + 4 - lz, &digit_pairs[bbcc - bb * 100], 2);
   98|    834|         return buf + 6 - lz;
   99|    834|      }
_ZN3glz9itoa_impl5u32_8EPcj:
  102|     48|      {
  103|     48|         const uint32_t aabb = uint32_t((uint64_t(val) * 109951163) >> 40); // val / 10000
  104|     48|         const uint32_t ccdd = val - aabb * 10000;
  105|     48|         const uint32_t aa = (aabb * 5243) >> 19; // aabb / 100
  106|     48|         const uint32_t cc = (ccdd * 5243) >> 19; // ccdd / 100
  107|     48|         const uint32_t lz = aa < 10;
  108|     48|         std::memcpy(buf, char_table + ((aa * 2) | lz), 2);
  109|     48|         std::memcpy(buf + 2 - lz, &digit_pairs[aabb - aa * 100], 2);
  110|     48|         std::memcpy(buf + 4 - lz, &digit_pairs[cc], 2);
  111|     48|         std::memcpy(buf + 6 - lz, &digit_pairs[ccdd - cc * 100], 2);
  112|     48|         return buf + 8 - lz;
  113|     48|      }

_ZN3glz13to_chars_40kbIlQsr3stdE7same_asIu14__remove_cvrefIT_ElEEEPcS3_S1_:
  328|  32.8k|   {
  329|  32.8k|      *buf = '-';
  330|  32.8k|      return to_chars_40kb(buf + (val < 0),
  331|  32.8k|                           static_cast<uint64_t>((static_cast<uint64_t>(val) ^ (val >> 63)) - (val >> 63)));
  332|  32.8k|   }
_ZN3glz13to_chars_40kbImQsr3stdE7same_asIu14__remove_cvrefIT_EmEEEPcS3_S1_:
  291|  32.8k|   {
  292|  32.8k|      using namespace itoa_40kb_impl;
  293|  32.8k|      if (val < 10000) {
  ------------------
  |  Branch (293:11): [True: 21.8k, False: 11.0k]
  ------------------
  294|  21.8k|         if (val < 100)
  ------------------
  |  Branch (294:14): [True: 21.1k, False: 712]
  ------------------
  295|  21.1k|            return u64_2(buf, val);
  296|    712|         else
  297|    712|            return u64_4(buf, val);
  298|  21.8k|      }
  299|  11.0k|      else if (val < 100000000) {
  ------------------
  |  Branch (299:16): [True: 949, False: 10.1k]
  ------------------
  300|    949|         if (val < 1000000)
  ------------------
  |  Branch (300:14): [True: 579, False: 370]
  ------------------
  301|    579|            return u64_6(buf, val);
  302|    370|         else
  303|    370|            return u64_8(buf, val);
  304|    949|      }
  305|  10.1k|      else if (val < 1000000000000ULL) {
  ------------------
  |  Branch (305:16): [True: 1.03k, False: 9.07k]
  ------------------
  306|  1.03k|         if (val < 10000000000ULL)
  ------------------
  |  Branch (306:14): [True: 369, False: 670]
  ------------------
  307|    369|            return u64_10(buf, val);
  308|    670|         else
  309|    670|            return u64_12(buf, val);
  310|  1.03k|      }
  311|  9.07k|      else if (val < 10000000000000000ULL) {
  ------------------
  |  Branch (311:16): [True: 994, False: 8.07k]
  ------------------
  312|    994|         if (val < 100000000000000ULL)
  ------------------
  |  Branch (312:14): [True: 567, False: 427]
  ------------------
  313|    567|            return u64_14(buf, val);
  314|    427|         else
  315|    427|            return u64_16(buf, val);
  316|    994|      }
  317|  8.07k|      else if (val < 1000000000000000000ULL) {
  ------------------
  |  Branch (317:16): [True: 7.74k, False: 328]
  ------------------
  318|  7.74k|         return u64_18(buf, val);
  319|  7.74k|      }
  320|    328|      else {
  321|    328|         return u64_20(buf, val);
  322|    328|      }
  323|  32.8k|   }
_ZN3glz14itoa_40kb_impl5u64_2EPcm:
  114|  21.1k|      {
  115|  21.1k|         const uint64_t lz = val < 10;
  116|  21.1k|         std::memcpy(buf, char_table + ((val * 2) | lz), 2);
  117|  21.1k|         return buf + 2 - lz;
  118|  21.1k|      }
_ZN3glz14itoa_40kb_impl5u64_4EPcm:
  121|    712|      {
  122|    712|         const uint64_t aa = (val * 5243ULL) >> 19;
  123|    712|         const uint64_t lz = val < 1000;
  124|    712|         std::memcpy(buf, char_table + ((aa * 2) | lz), 2);
  125|    712|         std::memcpy(buf + 2 - lz, &digit_pairs[val - aa * 100], 2);
  126|    712|         return buf + 4 - lz;
  127|    712|      }
_ZN3glz14itoa_40kb_impl5u64_6EPcm:
  130|    579|      {
  131|    579|         const uint64_t aa = (val * 429497ULL) >> 32;
  132|    579|         const uint64_t lz = val < 100000;
  133|    579|         std::memcpy(buf, char_table + ((aa * 2) | lz), 2);
  134|    579|         std::memcpy(buf + 2 - lz, &digit_quads[val - aa * 10000], 4);
  135|    579|         return buf + 6 - lz;
  136|    579|      }
_ZN3glz14itoa_40kb_impl5u64_8EPcm:
  139|    370|      {
  140|    370|         const uint64_t aabb = (val * 109951163ULL) >> 40;
  141|    370|         const uint64_t aa = (aabb * 5243ULL) >> 19;
  142|    370|         const uint64_t lz = val < 10000000;
  143|    370|         std::memcpy(buf, char_table + ((aa * 2) | lz), 2);
  144|    370|         std::memcpy(buf + 2 - lz, &digit_pairs[aabb - aa * 100], 2);
  145|    370|         std::memcpy(buf + 4 - lz, &digit_quads[val - aabb * 10000], 4);
  146|    370|         return buf + 8 - lz;
  147|    370|      }
_ZN3glz14itoa_40kb_impl6u64_10EPcm:
  150|    369|      {
  151|    369|         const uint64_t high = div_1e8(val);
  152|    369|         const uint64_t low = val - high * 100000000;
  153|    369|         const uint64_t lz = high < 10;
  154|    369|         std::memcpy(buf, char_table + ((high * 2) | lz), 2);
  155|    369|         const uint64_t aabb = (low * 109951163ULL) >> 40;
  156|    369|         const uint64_t ccdd = low - aabb * 10000;
  157|    369|         std::memcpy(buf + 2 - lz, &digit_quads[aabb], 4);
  158|    369|         std::memcpy(buf + 6 - lz, &digit_quads[ccdd], 4);
  159|    369|         return buf + 10 - lz;
  160|    369|      }
_ZN3glz14itoa_40kb_impl7div_1e8Em:
   50|  18.2k|      {
   51|  18.2k|         constexpr __uint128_t multiplier = 0xabcc77118461cefdULL;
   52|  18.2k|         constexpr uint64_t shift = 90;
   53|  18.2k|         return static_cast<uint64_t>((static_cast<__uint128_t>(value) * multiplier) >> shift);
   54|  18.2k|      }
_ZN3glz14itoa_40kb_impl6u64_12EPcm:
  163|    670|      {
  164|    670|         const uint64_t high = div_1e8(val);
  165|    670|         const uint64_t low = val - high * 100000000;
  166|    670|         const uint64_t aa = (high * 5243ULL) >> 19;
  167|    670|         const uint64_t lz = aa < 10;
  168|    670|         std::memcpy(buf, char_table + ((aa * 2) | lz), 2);
  169|    670|         std::memcpy(buf + 2 - lz, &digit_pairs[high - aa * 100], 2);
  170|    670|         const uint64_t aabb = (low * 109951163ULL) >> 40;
  171|    670|         const uint64_t ccdd = low - aabb * 10000;
  172|    670|         std::memcpy(buf + 4 - lz, &digit_quads[aabb], 4);
  173|    670|         std::memcpy(buf + 8 - lz, &digit_quads[ccdd], 4);
  174|    670|         return buf + 12 - lz;
  175|    670|      }
_ZN3glz14itoa_40kb_impl6u64_14EPcm:
  178|    567|      {
  179|    567|         const uint64_t high = div_1e8(val);
  180|    567|         const uint64_t low = val - high * 100000000;
  181|    567|         const uint64_t aa = (high * 429497ULL) >> 32;
  182|    567|         const uint64_t lz = aa < 10;
  183|    567|         const uint64_t bbcc = high - aa * 10000;
  184|    567|         std::memcpy(buf, char_table + ((aa * 2) | lz), 2);
  185|    567|         std::memcpy(buf + 2 - lz, &digit_quads[bbcc], 4);
  186|    567|         const uint64_t aabb = (low * 109951163ULL) >> 40;
  187|    567|         const uint64_t ccdd = low - aabb * 10000;
  188|    567|         std::memcpy(buf + 6 - lz, &digit_quads[aabb], 4);
  189|    567|         std::memcpy(buf + 10 - lz, &digit_quads[ccdd], 4);
  190|    567|         return buf + 14 - lz;
  191|    567|      }
_ZN3glz14itoa_40kb_impl6u64_16EPcm:
  194|    427|      {
  195|    427|         const uint64_t high = div_1e8(val);
  196|    427|         const uint64_t low = val - high * 100000000;
  197|    427|         uint64_t aabb = (high * 109951163ULL) >> 40;
  198|    427|         uint64_t ccdd = high - aabb * 10000;
  199|    427|         const uint64_t aa = (aabb * 5243ULL) >> 19;
  200|    427|         const uint64_t lz = aa < 10;
  201|    427|         const uint64_t bb = aabb - aa * 100;
  202|    427|         std::memcpy(buf, char_table + ((aa * 2) | lz), 2);
  203|    427|         std::memcpy(buf + 2 - lz, &digit_pairs[bb], 2);
  204|    427|         std::memcpy(buf + 4 - lz, &digit_quads[ccdd], 4);
  205|    427|         aabb = (low * 109951163ULL) >> 40;
  206|    427|         ccdd = low - aabb * 10000;
  207|    427|         std::memcpy(buf + 8 - lz, &digit_quads[aabb], 4);
  208|    427|         std::memcpy(buf + 12 - lz, &digit_quads[ccdd], 4);
  209|    427|         return buf + 16 - lz;
  210|    427|      }
_ZN3glz14itoa_40kb_impl6u64_18EPcm:
  213|  7.74k|      {
  214|  7.74k|         const uint64_t high = div_1e8(val);
  215|  7.74k|         const uint64_t low = val - high * 100000000;
  216|  7.74k|         const uint64_t high10 = div_1e8(high);
  217|  7.74k|         const uint64_t low10 = high - high10 * 100000000;
  218|  7.74k|         const uint64_t lz = high10 < 10;
  219|  7.74k|         std::memcpy(buf, char_table + ((high10 * 2) | lz), 2);
  220|  7.74k|         uint64_t aabb = (low10 * 109951163ULL) >> 40;
  221|  7.74k|         uint64_t ccdd = low10 - aabb * 10000;
  222|  7.74k|         std::memcpy(buf + 2 - lz, &digit_quads[aabb], 4);
  223|  7.74k|         std::memcpy(buf + 6 - lz, &digit_quads[ccdd], 4);
  224|  7.74k|         aabb = (low * 109951163ULL) >> 40;
  225|  7.74k|         ccdd = low - aabb * 10000;
  226|  7.74k|         std::memcpy(buf + 10 - lz, &digit_quads[aabb], 4);
  227|  7.74k|         std::memcpy(buf + 14 - lz, &digit_quads[ccdd], 4);
  228|  7.74k|         return buf + 18 - lz;
  229|  7.74k|      }
_ZN3glz14itoa_40kb_impl6u64_20EPcm:
  232|    328|      {
  233|    328|         const uint64_t high = div_1e8(val);
  234|    328|         const uint64_t low = val - high * 100000000;
  235|    328|         const uint64_t high12 = div_1e8(high);
  236|    328|         const uint64_t low12 = high - high12 * 100000000;
  237|    328|         const uint64_t aa = (high12 * 5243ULL) >> 19;
  238|    328|         const uint64_t lz = aa < 10;
  239|    328|         std::memcpy(buf, char_table + ((aa * 2) | lz), 2);
  240|    328|         std::memcpy(buf + 2 - lz, &digit_pairs[high12 - aa * 100], 2);
  241|    328|         uint64_t aabb = (low12 * 109951163ULL) >> 40;
  242|    328|         uint64_t ccdd = low12 - aabb * 10000;
  243|    328|         std::memcpy(buf + 4 - lz, &digit_quads[aabb], 4);
  244|    328|         std::memcpy(buf + 8 - lz, &digit_quads[ccdd], 4);
  245|    328|         aabb = (low * 109951163ULL) >> 40;
  246|    328|         ccdd = low - aabb * 10000;
  247|    328|         std::memcpy(buf + 12 - lz, &digit_quads[aabb], 4);
  248|    328|         std::memcpy(buf + 16 - lz, &digit_quads[ccdd], 4);
  249|    328|         return buf + 20 - lz;
  250|    328|      }
_ZN3glz13to_chars_40kbIiQsr3stdE7same_asIu14__remove_cvrefIT_EiEEEPcS3_S1_:
  282|    826|   {
  283|    826|      *buf = '-';
  284|    826|      return to_chars_40kb(buf + (val < 0),
  285|    826|                           static_cast<uint32_t>((static_cast<uint32_t>(val) ^ (val >> 31)) - (val >> 31)));
  286|    826|   }
_ZN3glz13to_chars_40kbIjQsr3stdE7same_asIu14__remove_cvrefIT_EjEEEPcS3_S1_:
  260|    826|   {
  261|    826|      using namespace itoa_40kb_impl;
  262|    826|      if (val < 10000) {
  ------------------
  |  Branch (262:11): [True: 476, False: 350]
  ------------------
  263|    476|         if (val < 100)
  ------------------
  |  Branch (263:14): [True: 395, False: 81]
  ------------------
  264|    395|            return u32_2(buf, val);
  265|     81|         else
  266|     81|            return u32_4(buf, val);
  267|    476|      }
  268|    350|      else if (val < 100000000) {
  ------------------
  |  Branch (268:16): [True: 275, False: 75]
  ------------------
  269|    275|         if (val < 1000000)
  ------------------
  |  Branch (269:14): [True: 117, False: 158]
  ------------------
  270|    117|            return u32_6(buf, val);
  271|    158|         else
  272|    158|            return u32_8(buf, val);
  273|    275|      }
  274|     75|      else {
  275|     75|         return u32_10(buf, val);
  276|     75|      }
  277|    826|   }
_ZN3glz14itoa_40kb_impl5u32_2EPcj:
   62|    395|      {
   63|    395|         const uint64_t lz = val < 10;
   64|       |         // Use OR since val*2 is always even (bit 0 is 0)
   65|    395|         std::memcpy(buf, char_table + ((val * 2) | lz), 2);
   66|    395|         return buf + 2 - lz;
   67|    395|      }
_ZN3glz14itoa_40kb_impl5u32_4EPcj:
   70|     81|      {
   71|     81|         const uint32_t aa = (val * 5243) >> 19;
   72|     81|         const uint64_t lz = val < 1000;
   73|     81|         std::memcpy(buf, char_table + ((aa * 2) | lz), 2);
   74|     81|         std::memcpy(buf + 2 - lz, &digit_pairs[val - aa * 100], 2);
   75|     81|         return buf + 4 - lz;
   76|     81|      }
_ZN3glz14itoa_40kb_impl5u32_6EPcj:
   79|    117|      {
   80|    117|         const uint32_t aa = static_cast<uint32_t>((static_cast<uint64_t>(val) * 429497ULL) >> 32);
   81|    117|         const uint64_t lz = val < 100000;
   82|    117|         std::memcpy(buf, char_table + ((aa * 2) | lz), 2);
   83|    117|         std::memcpy(buf + 2 - lz, &digit_quads[val - aa * 10000], 4);
   84|    117|         return buf + 6 - lz;
   85|    117|      }
_ZN3glz14itoa_40kb_impl5u32_8EPcj:
   88|    158|      {
   89|    158|         const uint64_t aabb = (static_cast<uint64_t>(val) * 109951163ULL) >> 40;
   90|    158|         const uint64_t aa = (aabb * 5243ULL) >> 19;
   91|    158|         const uint64_t lz = val < 10000000;
   92|    158|         std::memcpy(buf, char_table + ((aa * 2) | lz), 2);
   93|    158|         std::memcpy(buf + 2 - lz, &digit_pairs[aabb - aa * 100], 2);
   94|    158|         std::memcpy(buf + 4 - lz, &digit_quads[val - aabb * 10000], 4);
   95|    158|         return buf + 8 - lz;
   96|    158|      }
_ZN3glz14itoa_40kb_impl6u32_10EPcj:
   99|     75|      {
  100|     75|         const uint64_t high = div_1e8(val);
  101|     75|         const uint64_t low = val - high * 100000000;
  102|     75|         const uint64_t lz = high < 10;
  103|     75|         std::memcpy(buf, char_table + ((high * 2) | lz), 2);
  104|     75|         const uint64_t aabb = (low * 109951163ULL) >> 40;
  105|     75|         const uint64_t ccdd = low - aabb * 10000;
  106|     75|         std::memcpy(buf + 2 - lz, &digit_quads[aabb], 4);
  107|     75|         std::memcpy(buf + 6 - lz, &digit_quads[ccdd], 4);
  108|     75|         return buf + 10 - lz;
  109|     75|      }

_ZN3glz7skip_wsIXtlNS_7ws_optsEEETkNS_10is_contextERNS_7contextERPKcS5_EEbOT0_OT1_T2_:
  622|  24.3M|   {
  623|  24.3M|      using namespace glz::detail;
  624|       |
  625|  24.3M|      if constexpr (not Opts.minified) {
  626|       |         if constexpr (Opts.null_terminated) {
  627|       |            if constexpr (Opts.comments) {
  628|       |               while (whitespace_comment_table[uint8_t(*it)]) {
  629|       |                  if (*it == '/') [[unlikely]] {
  630|       |                     skip_comment(ctx, it, end);
  631|       |                     if (bool(ctx.error)) [[unlikely]] {
  632|       |                        return true;
  633|       |                     }
  634|       |                  }
  635|       |                  else [[likely]] {
  636|       |                     ++it;
  637|       |                  }
  638|       |               }
  639|       |            }
  640|       |            else {
  641|       |               while (whitespace_table[uint8_t(*it)]) {
  642|       |                  ++it;
  643|       |               }
  644|       |            }
  645|       |         }
  646|  24.3M|         else {
  647|       |            if constexpr (Opts.comments) {
  648|       |               while (it < end && whitespace_comment_table[uint8_t(*it)]) {
  649|       |                  if (*it == '/') [[unlikely]] {
  650|       |                     skip_comment(ctx, it, end);
  651|       |                     if (bool(ctx.error)) [[unlikely]] {
  652|       |                        return true;
  653|       |                     }
  654|       |                  }
  655|       |                  else [[likely]] {
  656|       |                     ++it;
  657|       |                  }
  658|       |               }
  659|       |               if (it == end) [[unlikely]] {
  660|       |                  ctx.error = error_code::end_reached;
  661|       |                  return true;
  662|       |               }
  663|       |            }
  664|  24.3M|            else {
  665|  53.9M|               while (it < end && whitespace_table[uint8_t(*it)]) {
  ------------------
  |  Branch (665:23): [True: 53.9M, False: 1.20k]
  |  Branch (665:35): [True: 29.5M, False: 24.3M]
  ------------------
  666|  29.5M|                  ++it;
  667|  29.5M|               }
  668|  24.3M|               if (it == end) [[unlikely]] {
  ------------------
  |  Branch (668:20): [True: 1.20k, False: 24.3M]
  ------------------
  669|  1.20k|                  ctx.error = error_code::end_reached;
  670|  1.20k|                  return true;
  671|  1.20k|               }
  672|  24.3M|            }
  673|  24.3M|         }
  674|       |      }
  675|       |      else if constexpr (not Opts.null_terminated) {
  676|       |         // Minified input has no whitespace to skip, but a non-null-terminated buffer can still
  677|       |         // be exhausted at this point. The non-minified branch above performs the same check; a
  678|       |         // null-terminated buffer relies on the trailing sentinel and keeps this a pure no-op.
  679|       |         if (it == end) [[unlikely]] {
  680|       |            ctx.error = error_code::end_reached;
  681|       |            return true;
  682|       |         }
  683|       |      }
  684|       |
  685|  24.3M|      return false;
  686|  24.3M|   }
_ZN3glz17match_invalid_endILc123EXtlNS_22match_invalid_end_optsEEETkNS_10is_contextENS_7contextERPKcS4_EEbRT1_OT2_T3_:
  411|   563k|   {
  412|   563k|      if (*it != C) [[unlikely]] {
  ------------------
  |  Branch (412:11): [True: 356k, False: 206k]
  ------------------
  413|       |         if constexpr (C == '"') {
  414|       |            ctx.error = error_code::expected_quote;
  415|       |         }
  416|       |         else if constexpr (C == ',') {
  417|       |            ctx.error = error_code::expected_comma;
  418|       |         }
  419|       |         else if constexpr (C == ':') {
  420|       |            ctx.error = error_code::expected_colon;
  421|       |         }
  422|       |         else if constexpr (C == '[' || C == ']') {
  423|       |            ctx.error = error_code::expected_bracket;
  424|       |         }
  425|   356k|         else if constexpr (C == '{' || C == '}') {
  426|   356k|            ctx.error = error_code::expected_brace;
  427|       |         }
  428|       |         else {
  429|       |            ctx.error = error_code::syntax_error;
  430|       |         }
  431|   356k|         return true;
  432|   356k|      }
  433|   206k|      else [[likely]] {
  434|   206k|         ++it;
  435|   206k|      }
  436|   206k|      if constexpr (not Opts.null_terminated) {
  437|   206k|         if (it == end) [[unlikely]] {
  ------------------
  |  Branch (437:14): [True: 1, False: 206k]
  ------------------
  438|      1|            ctx.error = error_code::unexpected_end;
  439|      1|            return true;
  440|      1|         }
  441|   206k|      }
  442|   206k|      return false;
  443|   563k|   }
_ZN3glz17match_invalid_endILc44EXtlNS_22match_invalid_end_optsEEETkNS_10is_contextENS_7contextERPKcS4_EEbRT1_OT2_T3_:
  411|  1.22M|   {
  412|  1.22M|      if (*it != C) [[unlikely]] {
  ------------------
  |  Branch (412:11): [True: 12.0k, False: 1.21M]
  ------------------
  413|       |         if constexpr (C == '"') {
  414|       |            ctx.error = error_code::expected_quote;
  415|       |         }
  416|  12.0k|         else if constexpr (C == ',') {
  417|  12.0k|            ctx.error = error_code::expected_comma;
  418|       |         }
  419|       |         else if constexpr (C == ':') {
  420|       |            ctx.error = error_code::expected_colon;
  421|       |         }
  422|       |         else if constexpr (C == '[' || C == ']') {
  423|       |            ctx.error = error_code::expected_bracket;
  424|       |         }
  425|       |         else if constexpr (C == '{' || C == '}') {
  426|       |            ctx.error = error_code::expected_brace;
  427|       |         }
  428|       |         else {
  429|       |            ctx.error = error_code::syntax_error;
  430|       |         }
  431|  12.0k|         return true;
  432|  12.0k|      }
  433|  1.21M|      else [[likely]] {
  434|  1.21M|         ++it;
  435|  1.21M|      }
  436|  1.21M|      if constexpr (not Opts.null_terminated) {
  437|  1.21M|         if (it == end) [[unlikely]] {
  ------------------
  |  Branch (437:14): [True: 1, False: 1.21M]
  ------------------
  438|      1|            ctx.error = error_code::unexpected_end;
  439|      1|            return true;
  440|      1|         }
  441|  1.21M|      }
  442|  1.21M|      return false;
  443|  1.22M|   }
_ZN3glz16skip_matching_wsIcRPKcEEvPKT_OT0_m:
  689|  1.00M|   {
  690|  1.00M|      if (length > 7) {
  ------------------
  |  Branch (690:11): [True: 725k, False: 276k]
  ------------------
  691|   725k|         uint64_t v[2];
  692|   742k|         while (length > 8) {
  ------------------
  |  Branch (692:17): [True: 188k, False: 553k]
  ------------------
  693|   188k|            std::memcpy(v, ws, 8);
  694|   188k|            std::memcpy(v + 1, it, 8);
  695|   188k|            if (v[0] != v[1]) {
  ------------------
  |  Branch (695:17): [True: 172k, False: 16.4k]
  ------------------
  696|   172k|               return;
  697|   172k|            }
  698|  16.4k|            length -= 8;
  699|  16.4k|            ws += 8;
  700|  16.4k|            it += 8;
  701|  16.4k|         }
  702|       |
  703|   553k|         const auto shift = 8 - length;
  704|   553k|         ws -= shift;
  705|   553k|         it -= shift;
  706|       |
  707|   553k|         std::memcpy(v, ws, 8);
  708|   553k|         std::memcpy(v + 1, it, 8);
  709|   553k|         if (v[0] != v[1]) {
  ------------------
  |  Branch (709:14): [True: 549k, False: 3.37k]
  ------------------
  710|   549k|            return;
  711|   549k|         }
  712|  3.37k|         it += 8;
  713|  3.37k|         return;
  714|   553k|      }
  715|   276k|      {
  716|   276k|         constexpr uint64_t n{sizeof(uint32_t)};
  717|   276k|         if (length >= n) {
  ------------------
  |  Branch (717:14): [True: 210k, False: 65.8k]
  ------------------
  718|   210k|            uint32_t v[2];
  719|   210k|            std::memcpy(v, ws, n);
  720|   210k|            std::memcpy(v + 1, it, n);
  721|   210k|            if (v[0] != v[1]) {
  ------------------
  |  Branch (721:17): [True: 205k, False: 4.68k]
  ------------------
  722|   205k|               return;
  723|   205k|            }
  724|  4.68k|            length -= n;
  725|  4.68k|            ws += n;
  726|  4.68k|            it += n;
  727|  4.68k|         }
  728|   276k|      }
  729|  70.5k|      {
  730|  70.5k|         constexpr uint64_t n{sizeof(uint16_t)};
  731|  70.5k|         if (length >= n) {
  ------------------
  |  Branch (731:14): [True: 62.5k, False: 8.04k]
  ------------------
  732|  62.5k|            uint16_t v[2];
  733|  62.5k|            std::memcpy(v, ws, n);
  734|  62.5k|            std::memcpy(v + 1, it, n);
  735|  62.5k|            if (v[0] != v[1]) {
  ------------------
  |  Branch (735:17): [True: 57.6k, False: 4.84k]
  ------------------
  736|  57.6k|               return;
  737|  57.6k|            }
  738|       |            // length -= n;
  739|       |            // ws += n;
  740|  4.84k|            it += n;
  741|  4.84k|         }
  742|  70.5k|      }
  743|       |      // We have to call a whitespace check after this function
  744|       |      // in case the whitespace is mismatching.
  745|       |      // So, we forgo this check as to not duplicate.
  746|       |      /*if (length && *ws == *it) {
  747|       |         ++it;
  748|       |      }*/
  749|  70.5k|   }
_ZN3glz17match_invalid_endILc58EXtlNS_22match_invalid_end_optsEEETkNS_10is_contextENS_7contextERPKcS4_EEbRT1_OT2_T3_:
  411|  2.00M|   {
  412|  2.00M|      if (*it != C) [[unlikely]] {
  ------------------
  |  Branch (412:11): [True: 13.4k, False: 1.98M]
  ------------------
  413|       |         if constexpr (C == '"') {
  414|       |            ctx.error = error_code::expected_quote;
  415|       |         }
  416|       |         else if constexpr (C == ',') {
  417|       |            ctx.error = error_code::expected_comma;
  418|       |         }
  419|  13.4k|         else if constexpr (C == ':') {
  420|  13.4k|            ctx.error = error_code::expected_colon;
  421|       |         }
  422|       |         else if constexpr (C == '[' || C == ']') {
  423|       |            ctx.error = error_code::expected_bracket;
  424|       |         }
  425|       |         else if constexpr (C == '{' || C == '}') {
  426|       |            ctx.error = error_code::expected_brace;
  427|       |         }
  428|       |         else {
  429|       |            ctx.error = error_code::syntax_error;
  430|       |         }
  431|  13.4k|         return true;
  432|  13.4k|      }
  433|  1.98M|      else [[likely]] {
  434|  1.98M|         ++it;
  435|  1.98M|      }
  436|  1.98M|      if constexpr (not Opts.null_terminated) {
  437|  1.98M|         if (it == end) [[unlikely]] {
  ------------------
  |  Branch (437:14): [True: 8, False: 1.98M]
  ------------------
  438|      8|            ctx.error = error_code::unexpected_end;
  439|      8|            return true;
  440|      8|         }
  441|  1.98M|      }
  442|  1.98M|      return false;
  443|  2.00M|   }
_ZN3glz17skip_until_closedIXtlNS_22skip_until_closed_optsELb0ELb0ELb1EEELc123ELc125ELm1ETkNS_10is_contextERNS_7contextERPKcS5_QaantdtT_6paddedntdtT_8commentsEEvOT3_OT4_T5_:
 1235|   176k|   {
 1236|   176k|      static constexpr bool opening_not_handled = false;
 1237|   176k|      static constexpr bool skip_validation = false;
 1238|       |      // skip_validation routes skip_string through the end-bounded skip_string_view path, which
 1239|       |      // stops on `end` rather than on a sentinel, so this flag has no effect from here.
 1240|   176k|      static constexpr bool null_terminated_unused = true;
 1241|       |
 1242|   176k|      size_t depth = Depth;
 1243|       |
 1244|  20.1M|      for (const auto fin = end - 7; it < fin;) {
  ------------------
  |  Branch (1244:38): [True: 20.1M, False: 17.2k]
  ------------------
 1245|  20.1M|         uint64_t chunk;
 1246|  20.1M|         std::memcpy(&chunk, it, 8);
 1247|       |         if constexpr (std::endian::native == std::endian::big) {
 1248|       |            chunk = std::byteswap(chunk);
 1249|       |         }
 1250|  20.1M|         const uint64_t test = has_quote(chunk) | has_char<open>(chunk) | has_char<close>(chunk);
 1251|  20.1M|         if (test) {
  ------------------
  |  Branch (1251:14): [True: 2.26M, False: 17.9M]
  ------------------
 1252|  2.26M|            it += (countr_zero(test) >> 3);
 1253|       |
 1254|  2.26M|            switch (*it) {
 1255|   646k|            case '"': {
  ------------------
  |  Branch (1255:13): [True: 646k, False: 1.62M]
  ------------------
 1256|   646k|               skip_string<skip_string_opts{Opts.padded, opening_not_handled, skip_validation, Opts.validate_utf8,
 1257|   646k|                                            null_terminated_unused}>(ctx, it, end);
 1258|   646k|               if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (1258:20): [True: 1.49k, False: 644k]
  ------------------
 1259|  1.49k|                  return;
 1260|  1.49k|               }
 1261|   644k|               break;
 1262|   646k|            }
 1263|  1.40M|            case open: {
  ------------------
  |  Branch (1263:13): [True: 1.40M, False: 860k]
  ------------------
 1264|  1.40M|               ++it;
 1265|  1.40M|               ++depth;
 1266|  1.40M|               break;
 1267|   646k|            }
 1268|   213k|            case close: {
  ------------------
  |  Branch (1268:13): [True: 213k, False: 2.05M]
  ------------------
 1269|   213k|               ++it;
 1270|   213k|               --depth;
 1271|   213k|               if (depth == 0) {
  ------------------
  |  Branch (1271:20): [True: 157k, False: 56.3k]
  ------------------
 1272|   157k|                  return;
 1273|   157k|               }
 1274|  56.3k|               break;
 1275|   213k|            }
 1276|  56.3k|            default: {
  ------------------
  |  Branch (1276:13): [True: 0, False: 2.26M]
  ------------------
 1277|      0|               ctx.error = error_code::unexpected_end;
 1278|      0|               return;
 1279|   213k|            }
 1280|  2.26M|            }
 1281|  2.26M|         }
 1282|  17.9M|         else {
 1283|  17.9M|            it += 8;
 1284|  17.9M|         }
 1285|  20.1M|      }
 1286|       |
 1287|       |      // Tail end of buffer. Should be rare we even get here
 1288|  27.1k|      while (it < end) {
  ------------------
  |  Branch (1288:14): [True: 26.4k, False: 651]
  ------------------
 1289|  26.4k|         switch (*it) {
 1290|  3.73k|         case '"': {
  ------------------
  |  Branch (1290:10): [True: 3.73k, False: 22.7k]
  ------------------
 1291|  3.73k|            skip_string<skip_string_opts{Opts.padded, opening_not_handled, skip_validation, Opts.validate_utf8,
 1292|  3.73k|                                         null_terminated_unused}>(ctx, it, end);
 1293|  3.73k|            if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (1293:17): [True: 383, False: 3.34k]
  ------------------
 1294|    383|               return;
 1295|    383|            }
 1296|  3.34k|            break;
 1297|  3.73k|         }
 1298|  3.34k|         case '/': {
  ------------------
  |  Branch (1298:10): [True: 105, False: 26.3k]
  ------------------
 1299|    105|            skip_comment(ctx, it, end);
 1300|    105|            if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (1300:17): [True: 48, False: 57]
  ------------------
 1301|     48|               return;
 1302|     48|            }
 1303|     57|            break;
 1304|    105|         }
 1305|    379|         case open: {
  ------------------
  |  Branch (1305:10): [True: 379, False: 26.1k]
  ------------------
 1306|    379|            ++it;
 1307|    379|            ++depth;
 1308|    379|            break;
 1309|    105|         }
 1310|  17.0k|         case close: {
  ------------------
  |  Branch (1310:10): [True: 17.0k, False: 9.45k]
  ------------------
 1311|  17.0k|            ++it;
 1312|  17.0k|            --depth;
 1313|  17.0k|            if (depth == 0) {
  ------------------
  |  Branch (1313:17): [True: 16.1k, False: 918]
  ------------------
 1314|  16.1k|               return;
 1315|  16.1k|            }
 1316|    918|            break;
 1317|  17.0k|         }
 1318|  5.23k|         default: {
  ------------------
  |  Branch (1318:10): [True: 5.23k, False: 21.2k]
  ------------------
 1319|  5.23k|            ++it;
 1320|  5.23k|         }
 1321|  26.4k|         }
 1322|  26.4k|      }
 1323|       |
 1324|    651|      ctx.error = error_code::unexpected_end;
 1325|    651|   }
_ZN3glz9has_quoteEm:
  534|  47.5M|   {
  535|  47.5M|      return has_zero(chunk ^ repeat_byte8('"'));
  536|  47.5M|   }
_ZN3glz8has_zeroEm:
  529|   112M|   {
  530|   112M|      return (((chunk - 0x0101010101010101u) & ~chunk) & 0x8080808080808080u);
  531|   112M|   }
_ZN3glz8has_charILc123EEEDam:
  550|  20.1M|   {
  551|  20.1M|      return has_zero(chunk ^ repeat_byte8(Char));
  552|  20.1M|   }
_ZN3glz8has_charILc125EEEDam:
  550|  20.1M|   {
  551|  20.1M|      return has_zero(chunk ^ repeat_byte8(Char));
  552|  20.1M|   }
_ZN3glz11skip_stringIXtlNS_16skip_string_optsELb0ELb0ELb0ELb1ELb1EEETkNS_10is_contextERNS_7contextERPKcS5_QntdtT_6paddedEEvOT0_OT1_T2_:
 1020|   773k|   {
 1021|   773k|      if constexpr (not Opts.opening_handled) {
 1022|   773k|         ++it;
 1023|   773k|      }
 1024|       |
 1025|   773k|      const auto* const utf8_start = it;
 1026|       |
 1027|       |      if constexpr (Opts.validate_skipped) {
 1028|       |         while (true) {
 1029|       |            // A null-terminated buffer terminates on the trailing '\0' (caught by the control
 1030|       |            // character check below); a non-null-terminated buffer has no sentinel, so bound the
 1031|       |            // scan before each dereference.
 1032|       |            if constexpr (not Opts.null_terminated) {
 1033|       |               if (it == end) [[unlikely]] {
 1034|       |                  ctx.error = error_code::unexpected_end;
 1035|       |                  return;
 1036|       |               }
 1037|       |            }
 1038|       |            if ((*it & 0b11100000) == 0) [[unlikely]] {
 1039|       |               ctx.error = error_code::syntax_error;
 1040|       |               return;
 1041|       |            }
 1042|       |
 1043|       |            switch (*it) {
 1044|       |            case '"': {
 1045|       |               validate_utf8_span<Opts>(ctx, utf8_start, it);
 1046|       |               ++it;
 1047|       |               return;
 1048|       |            }
 1049|       |            case '\\': {
 1050|       |               ++it;
 1051|       |               if constexpr (not Opts.null_terminated) {
 1052|       |                  if (it == end) [[unlikely]] {
 1053|       |                     ctx.error = error_code::unexpected_end;
 1054|       |                     return;
 1055|       |                  }
 1056|       |               }
 1057|       |               if (char_unescape_table[uint8_t(*it)]) {
 1058|       |                  ++it;
 1059|       |                  continue;
 1060|       |               }
 1061|       |               else if (*it == 'u') {
 1062|       |                  ++it;
 1063|       |                  if (skip_unicode_code_point(it, end)) [[likely]] {
 1064|       |                     continue;
 1065|       |                  }
 1066|       |                  else [[unlikely]] {
 1067|       |                     ctx.error = error_code::unicode_escape_conversion_failure;
 1068|       |                     return;
 1069|       |                  }
 1070|       |               }
 1071|       |               ctx.error = error_code::syntax_error;
 1072|       |               return;
 1073|       |            }
 1074|       |            }
 1075|       |            ++it;
 1076|       |         }
 1077|       |      }
 1078|   773k|      else {
 1079|   773k|         skip_string_view(ctx, it, end);
 1080|   773k|         if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (1080:14): [True: 1.04k, False: 772k]
  ------------------
 1081|  1.04k|            return;
 1082|  1.04k|         }
 1083|   772k|         if (validate_utf8_span<Opts>(ctx, utf8_start, it)) [[unlikely]] {
  ------------------
  |  Branch (1083:14): [True: 1.36k, False: 770k]
  ------------------
 1084|  1.36k|            return;
 1085|  1.36k|         }
 1086|   770k|         ++it; // skip the quote
 1087|   770k|      }
 1088|   773k|   }
_ZN3glz16skip_string_viewITkNS_10is_contextERNS_7contextERPKcS4_EEvOT_OT0_T1_:
  863|   954k|   {
  864|  1.02M|      while (it < end) [[likely]] {
  ------------------
  |  Branch (864:14): [True: 1.02M, False: 53]
  ------------------
  865|  1.02M|         const auto* pc = std::memchr(it, '"', size_t(end - it));
  866|  1.02M|         if (pc) [[likely]] {
  ------------------
  |  Branch (866:14): [True: 1.01M, False: 1.08k]
  ------------------
  867|  1.01M|            it = reinterpret_cast<std::decay_t<decltype(it)>>(pc);
  868|  1.01M|            auto* prev = it - 1;
  869|  1.26M|            while (*prev == '\\') {
  ------------------
  |  Branch (869:20): [True: 245k, False: 1.01M]
  ------------------
  870|   245k|               --prev;
  871|   245k|            }
  872|  1.01M|            if (size_t(it - prev) % 2) {
  ------------------
  |  Branch (872:17): [True: 953k, False: 66.1k]
  ------------------
  873|   953k|               return;
  874|   953k|            }
  875|  66.1k|            ++it; // skip the escaped quote
  876|  66.1k|         }
  877|  1.08k|         else [[unlikely]] {
  878|  1.08k|            break;
  879|  1.08k|         }
  880|  1.02M|      }
  881|       |
  882|  1.14k|      ctx.error = error_code::expected_quote;
  883|  1.14k|   }
_ZN3glz18validate_utf8_spanITnDaXtlNS_16skip_string_optsELb0ELb0ELb0ELb1ELb1EEETkNS_10is_contextERNS_7contextEccEEbOT0_PKT1_PKT2_m:
  832|   772k|   {
  833|       |      if constexpr (not check_validate_utf8(Opts)) {
  834|       |         // Everything the caller computed for us is dead, which lets its scan loop drop the
  835|       |         // accumulator entirely.
  836|       |         (void)ctx, (void)start, (void)fin, (void)ascii_acc;
  837|       |         return false;
  838|       |      }
  839|   772k|      else {
  840|   772k|         if ((ascii_acc & repeat_byte8(0b10000000)) == 0) {
  ------------------
  |  Branch (840:14): [True: 0, False: 772k]
  ------------------
  841|      0|            return false; // pure ASCII is trivially well formed UTF-8
  842|      0|         }
  843|   772k|         if (!validate_utf8(start, size_t(fin - start))) [[unlikely]] {
  ------------------
  |  Branch (843:14): [True: 1.36k, False: 770k]
  ------------------
  844|  1.36k|            ctx.error = error_code::invalid_utf8;
  845|  1.36k|            return true;
  846|  1.36k|         }
  847|   770k|         return false;
  848|   772k|      }
  849|   772k|   }
_ZN3glz13validate_utf8IcEEbPKT_m:
  801|  1.13M|   {
  802|  1.13M|      const uint8_t* it = reinterpret_cast<const uint8_t*>(str);
  803|  1.13M|      const uint8_t* const end = it + size;
  804|       |#if defined(GLZ_UTF8_SIMD)
  805|       |      // 16 is a measured compromise, not a register-size coincidence. The scalar path skips ASCII 8
  806|       |      // bytes at a time, so on ASCII it stays ahead of the vector path's fixed setup cost until the
  807|       |      // input is long enough for the 64 byte ASCII step to engage; on non-ASCII the vector path
  808|       |      // wins from roughly 8 bytes. Raising the threshold buys a few percent on short ASCII and
  809|       |      // costs up to 2.3x on mid length non-ASCII strings, so it stays low.
  810|       |      if (size >= 16) {
  811|       |         return detail::utf8_simd::validate(it, end);
  812|       |      }
  813|       |#endif
  814|  1.13M|      return validate_utf8_scalar(it, end);
  815|  1.13M|   }
_ZN3glz20validate_utf8_scalarEPKhS1_:
  752|  1.13M|   {
  753|  37.7M|      while (it < end) {
  ------------------
  |  Branch (753:14): [True: 36.5M, False: 1.11M]
  ------------------
  754|       |         // Optimistic SWAR check for ASCII
  755|  36.5M|         if (it + 8 <= end) {
  ------------------
  |  Branch (755:14): [True: 33.0M, False: 3.55M]
  ------------------
  756|  33.0M|            uint64_t chunk;
  757|  33.0M|            std::memcpy(&chunk, it, 8);
  758|  33.0M|            if ((chunk & glz::repeat_byte8(0x80)) == 0) {
  ------------------
  |  Branch (758:17): [True: 31.7M, False: 1.26M]
  ------------------
  759|  31.7M|               it += 8;
  760|  31.7M|               continue;
  761|  31.7M|            }
  762|  33.0M|         }
  763|       |
  764|       |         // Byte-by-byte validation (standard conformant)
  765|  4.82M|         uint8_t byte = *it;
  766|       |
  767|  4.82M|         if (byte < 0x80) {
  ------------------
  |  Branch (767:14): [True: 4.47M, False: 350k]
  ------------------
  768|  4.47M|            it++;
  769|  4.47M|         }
  770|   350k|         else if ((byte & 0xE0) == 0xC0) {
  ------------------
  |  Branch (770:19): [True: 210k, False: 139k]
  ------------------
  771|       |            // 2-byte sequence
  772|   210k|            if (it + 2 > end || (it[1] & 0xC0) != 0x80) return false;
  ------------------
  |  Branch (772:17): [True: 60, False: 210k]
  |  Branch (772:33): [True: 3.36k, False: 207k]
  ------------------
  773|   207k|            if (byte < 0xC2) return false; // Overlong
  ------------------
  |  Branch (773:17): [True: 172, False: 206k]
  ------------------
  774|   206k|            it += 2;
  775|   206k|         }
  776|   139k|         else if ((byte & 0xF0) == 0xE0) {
  ------------------
  |  Branch (776:19): [True: 69.8k, False: 69.8k]
  ------------------
  777|       |            // 3-byte sequence
  778|  69.8k|            if (it + 3 > end || (it[1] & 0xC0) != 0x80 || (it[2] & 0xC0) != 0x80) return false;
  ------------------
  |  Branch (778:17): [True: 60, False: 69.7k]
  |  Branch (778:33): [True: 949, False: 68.8k]
  |  Branch (778:59): [True: 263, False: 68.5k]
  ------------------
  779|  68.5k|            if (byte == 0xE0 && it[1] < 0xA0) return false; // Overlong
  ------------------
  |  Branch (779:17): [True: 19.8k, False: 48.6k]
  |  Branch (779:33): [True: 232, False: 19.6k]
  ------------------
  780|  68.3k|            if (byte == 0xED && it[1] >= 0xA0) return false; // Surrogate
  ------------------
  |  Branch (780:17): [True: 27.7k, False: 40.5k]
  |  Branch (780:33): [True: 114, False: 27.6k]
  ------------------
  781|  68.1k|            it += 3;
  782|  68.1k|         }
  783|  69.8k|         else if ((byte & 0xF8) == 0xF0) {
  ------------------
  |  Branch (783:19): [True: 62.1k, False: 7.63k]
  ------------------
  784|       |            // 4-byte sequence
  785|  62.1k|            if (it + 4 > end || (it[1] & 0xC0) != 0x80 || (it[2] & 0xC0) != 0x80 || (it[3] & 0xC0) != 0x80)
  ------------------
  |  Branch (785:17): [True: 69, False: 62.1k]
  |  Branch (785:33): [True: 1.93k, False: 60.1k]
  |  Branch (785:59): [True: 259, False: 59.9k]
  |  Branch (785:85): [True: 226, False: 59.6k]
  ------------------
  786|  2.49k|               return false;
  787|  59.6k|            if (byte == 0xF0 && it[1] < 0x90) return false; // Overlong
  ------------------
  |  Branch (787:17): [True: 23.8k, False: 35.8k]
  |  Branch (787:33): [True: 172, False: 23.6k]
  ------------------
  788|  59.5k|            if (byte == 0xF4 && it[1] >= 0x90) return false; // > U+10FFFF
  ------------------
  |  Branch (788:17): [True: 29.7k, False: 29.7k]
  |  Branch (788:33): [True: 124, False: 29.6k]
  ------------------
  789|  59.3k|            if (byte > 0xF4) return false; // > U+10FFFF
  ------------------
  |  Branch (789:17): [True: 132, False: 59.2k]
  ------------------
  790|  59.2k|            it += 4;
  791|  59.2k|         }
  792|  7.63k|         else {
  793|  7.63k|            return false;
  794|  7.63k|         }
  795|  4.82M|      }
  796|       |
  797|  1.11M|      return true;
  798|  1.13M|   }
_ZN3glz12skip_commentITkNS_10is_contextERNS_7contextERPKcS4_EEvOT_OT0_T1_:
  503|    175|   {
  504|    175|      ++it;
  505|    175|      if (it == end) [[unlikely]] {
  ------------------
  |  Branch (505:11): [True: 2, False: 173]
  ------------------
  506|      2|         ctx.error = error_code::unexpected_end;
  507|      2|      }
  508|    173|      else if (*it == '/') {
  ------------------
  |  Branch (508:16): [True: 43, False: 130]
  ------------------
  509|    111|         while (++it != end && *it != '\n');
  ------------------
  |  Branch (509:17): [True: 76, False: 35]
  |  Branch (509:32): [True: 68, False: 8]
  ------------------
  510|     43|      }
  511|    130|      else if (*it == '*') {
  ------------------
  |  Branch (511:16): [True: 67, False: 63]
  ------------------
  512|    226|         while (++it != end) {
  ------------------
  |  Branch (512:17): [True: 166, False: 60]
  ------------------
  513|    166|            if (*it == '*') [[unlikely]] {
  ------------------
  |  Branch (513:17): [True: 38, False: 128]
  ------------------
  514|     38|               if (++it == end) [[unlikely]]
  ------------------
  |  Branch (514:20): [True: 3, False: 35]
  ------------------
  515|      3|                  break;
  516|     35|               else if (*it == '/') [[likely]] {
  ------------------
  |  Branch (516:25): [True: 4, False: 31]
  ------------------
  517|      4|                  ++it;
  518|      4|                  break;
  519|      4|               }
  520|     38|            }
  521|    166|         }
  522|     67|      }
  523|     63|      else [[unlikely]] {
  524|     63|         ctx.error = error_code::expected_end_comment;
  525|     63|      }
  526|    175|   }
_ZN3glz17skip_until_closedIXtlNS_22skip_until_closed_optsELb0ELb0ELb1EEELc91ELc93ELm1ETkNS_10is_contextERNS_7contextERPKcS5_QaantdtT_6paddedntdtT_8commentsEEvOT3_OT4_T5_:
 1235|  17.6k|   {
 1236|  17.6k|      static constexpr bool opening_not_handled = false;
 1237|  17.6k|      static constexpr bool skip_validation = false;
 1238|       |      // skip_validation routes skip_string through the end-bounded skip_string_view path, which
 1239|       |      // stops on `end` rather than on a sentinel, so this flag has no effect from here.
 1240|  17.6k|      static constexpr bool null_terminated_unused = true;
 1241|       |
 1242|  17.6k|      size_t depth = Depth;
 1243|       |
 1244|  12.0M|      for (const auto fin = end - 7; it < fin;) {
  ------------------
  |  Branch (1244:38): [True: 12.0M, False: 7.68k]
  ------------------
 1245|  12.0M|         uint64_t chunk;
 1246|  12.0M|         std::memcpy(&chunk, it, 8);
 1247|       |         if constexpr (std::endian::native == std::endian::big) {
 1248|       |            chunk = std::byteswap(chunk);
 1249|       |         }
 1250|  12.0M|         const uint64_t test = has_quote(chunk) | has_char<open>(chunk) | has_char<close>(chunk);
 1251|  12.0M|         if (test) {
  ------------------
  |  Branch (1251:14): [True: 3.01M, False: 9.04M]
  ------------------
 1252|  3.01M|            it += (countr_zero(test) >> 3);
 1253|       |
 1254|  3.01M|            switch (*it) {
 1255|   119k|            case '"': {
  ------------------
  |  Branch (1255:13): [True: 119k, False: 2.89M]
  ------------------
 1256|   119k|               skip_string<skip_string_opts{Opts.padded, opening_not_handled, skip_validation, Opts.validate_utf8,
 1257|   119k|                                            null_terminated_unused}>(ctx, it, end);
 1258|   119k|               if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (1258:20): [True: 319, False: 118k]
  ------------------
 1259|    319|                  return;
 1260|    319|               }
 1261|   118k|               break;
 1262|   119k|            }
 1263|  2.85M|            case open: {
  ------------------
  |  Branch (1263:13): [True: 2.85M, False: 157k]
  ------------------
 1264|  2.85M|               ++it;
 1265|  2.85M|               ++depth;
 1266|  2.85M|               break;
 1267|   119k|            }
 1268|  38.7k|            case close: {
  ------------------
  |  Branch (1268:13): [True: 38.7k, False: 2.97M]
  ------------------
 1269|  38.7k|               ++it;
 1270|  38.7k|               --depth;
 1271|  38.7k|               if (depth == 0) {
  ------------------
  |  Branch (1271:20): [True: 9.66k, False: 29.0k]
  ------------------
 1272|  9.66k|                  return;
 1273|  9.66k|               }
 1274|  29.0k|               break;
 1275|  38.7k|            }
 1276|  29.0k|            default: {
  ------------------
  |  Branch (1276:13): [True: 0, False: 3.01M]
  ------------------
 1277|      0|               ctx.error = error_code::unexpected_end;
 1278|      0|               return;
 1279|  38.7k|            }
 1280|  3.01M|            }
 1281|  3.01M|         }
 1282|  9.04M|         else {
 1283|  9.04M|            it += 8;
 1284|  9.04M|         }
 1285|  12.0M|      }
 1286|       |
 1287|       |      // Tail end of buffer. Should be rare we even get here
 1288|  21.9k|      while (it < end) {
  ------------------
  |  Branch (1288:14): [True: 19.7k, False: 2.17k]
  ------------------
 1289|  19.7k|         switch (*it) {
 1290|  4.11k|         case '"': {
  ------------------
  |  Branch (1290:10): [True: 4.11k, False: 15.6k]
  ------------------
 1291|  4.11k|            skip_string<skip_string_opts{Opts.padded, opening_not_handled, skip_validation, Opts.validate_utf8,
 1292|  4.11k|                                         null_terminated_unused}>(ctx, it, end);
 1293|  4.11k|            if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (1293:17): [True: 224, False: 3.89k]
  ------------------
 1294|    224|               return;
 1295|    224|            }
 1296|  3.89k|            break;
 1297|  4.11k|         }
 1298|  3.89k|         case '/': {
  ------------------
  |  Branch (1298:10): [True: 70, False: 19.6k]
  ------------------
 1299|     70|            skip_comment(ctx, it, end);
 1300|     70|            if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (1300:17): [True: 17, False: 53]
  ------------------
 1301|     17|               return;
 1302|     17|            }
 1303|     53|            break;
 1304|     70|         }
 1305|    973|         case open: {
  ------------------
  |  Branch (1305:10): [True: 973, False: 18.7k]
  ------------------
 1306|    973|            ++it;
 1307|    973|            ++depth;
 1308|    973|            break;
 1309|     70|         }
 1310|  7.09k|         case close: {
  ------------------
  |  Branch (1310:10): [True: 7.09k, False: 12.6k]
  ------------------
 1311|  7.09k|            ++it;
 1312|  7.09k|            --depth;
 1313|  7.09k|            if (depth == 0) {
  ------------------
  |  Branch (1313:17): [True: 5.27k, False: 1.81k]
  ------------------
 1314|  5.27k|               return;
 1315|  5.27k|            }
 1316|  1.81k|            break;
 1317|  7.09k|         }
 1318|  7.48k|         default: {
  ------------------
  |  Branch (1318:10): [True: 7.48k, False: 12.2k]
  ------------------
 1319|  7.48k|            ++it;
 1320|  7.48k|         }
 1321|  19.7k|         }
 1322|  19.7k|      }
 1323|       |
 1324|  2.17k|      ctx.error = error_code::unexpected_end;
 1325|  2.17k|   }
_ZN3glz8has_charILc91EEEDam:
  550|  12.0M|   {
  551|  12.0M|      return has_zero(chunk ^ repeat_byte8(Char));
  552|  12.0M|   }
_ZN3glz8has_charILc93EEEDam:
  550|  12.0M|   {
  551|  12.0M|      return has_zero(chunk ^ repeat_byte8(Char));
  552|  12.0M|   }
_ZN3glz11skip_stringIXtlNS_16skip_string_optsELb0ELb0ELb0ELb1EEETkNS_10is_contextERNS_7contextERPKcS5_QntdtT_6paddedEEvOT0_OT1_T2_:
 1020|  19.4k|   {
 1021|  19.4k|      if constexpr (not Opts.opening_handled) {
 1022|  19.4k|         ++it;
 1023|  19.4k|      }
 1024|       |
 1025|  19.4k|      const auto* const utf8_start = it;
 1026|       |
 1027|       |      if constexpr (Opts.validate_skipped) {
 1028|       |         while (true) {
 1029|       |            // A null-terminated buffer terminates on the trailing '\0' (caught by the control
 1030|       |            // character check below); a non-null-terminated buffer has no sentinel, so bound the
 1031|       |            // scan before each dereference.
 1032|       |            if constexpr (not Opts.null_terminated) {
 1033|       |               if (it == end) [[unlikely]] {
 1034|       |                  ctx.error = error_code::unexpected_end;
 1035|       |                  return;
 1036|       |               }
 1037|       |            }
 1038|       |            if ((*it & 0b11100000) == 0) [[unlikely]] {
 1039|       |               ctx.error = error_code::syntax_error;
 1040|       |               return;
 1041|       |            }
 1042|       |
 1043|       |            switch (*it) {
 1044|       |            case '"': {
 1045|       |               validate_utf8_span<Opts>(ctx, utf8_start, it);
 1046|       |               ++it;
 1047|       |               return;
 1048|       |            }
 1049|       |            case '\\': {
 1050|       |               ++it;
 1051|       |               if constexpr (not Opts.null_terminated) {
 1052|       |                  if (it == end) [[unlikely]] {
 1053|       |                     ctx.error = error_code::unexpected_end;
 1054|       |                     return;
 1055|       |                  }
 1056|       |               }
 1057|       |               if (char_unescape_table[uint8_t(*it)]) {
 1058|       |                  ++it;
 1059|       |                  continue;
 1060|       |               }
 1061|       |               else if (*it == 'u') {
 1062|       |                  ++it;
 1063|       |                  if (skip_unicode_code_point(it, end)) [[likely]] {
 1064|       |                     continue;
 1065|       |                  }
 1066|       |                  else [[unlikely]] {
 1067|       |                     ctx.error = error_code::unicode_escape_conversion_failure;
 1068|       |                     return;
 1069|       |                  }
 1070|       |               }
 1071|       |               ctx.error = error_code::syntax_error;
 1072|       |               return;
 1073|       |            }
 1074|       |            }
 1075|       |            ++it;
 1076|       |         }
 1077|       |      }
 1078|  19.4k|      else {
 1079|  19.4k|         skip_string_view(ctx, it, end);
 1080|  19.4k|         if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (1080:14): [True: 83, False: 19.4k]
  ------------------
 1081|     83|            return;
 1082|     83|         }
 1083|  19.4k|         if (validate_utf8_span<Opts>(ctx, utf8_start, it)) [[unlikely]] {
  ------------------
  |  Branch (1083:14): [True: 202, False: 19.2k]
  ------------------
 1084|    202|            return;
 1085|    202|         }
 1086|  19.2k|         ++it; // skip the quote
 1087|  19.2k|      }
 1088|  19.4k|   }
_ZN3glz18validate_utf8_spanITnDaXtlNS_16skip_string_optsELb0ELb0ELb0ELb1EEETkNS_10is_contextERNS_7contextEccEEbOT0_PKT1_PKT2_m:
  832|  19.4k|   {
  833|       |      if constexpr (not check_validate_utf8(Opts)) {
  834|       |         // Everything the caller computed for us is dead, which lets its scan loop drop the
  835|       |         // accumulator entirely.
  836|       |         (void)ctx, (void)start, (void)fin, (void)ascii_acc;
  837|       |         return false;
  838|       |      }
  839|  19.4k|      else {
  840|  19.4k|         if ((ascii_acc & repeat_byte8(0b10000000)) == 0) {
  ------------------
  |  Branch (840:14): [True: 0, False: 19.4k]
  ------------------
  841|      0|            return false; // pure ASCII is trivially well formed UTF-8
  842|      0|         }
  843|  19.4k|         if (!validate_utf8(start, size_t(fin - start))) [[unlikely]] {
  ------------------
  |  Branch (843:14): [True: 202, False: 19.2k]
  ------------------
  844|    202|            ctx.error = error_code::invalid_utf8;
  845|    202|            return true;
  846|    202|         }
  847|  19.2k|         return false;
  848|  19.4k|      }
  849|  19.4k|   }
_ZN3glz17match_invalid_endILc34EXtlNS_22match_invalid_end_optsEEETkNS_10is_contextENS_7contextERPKcS4_EEbRT1_OT2_T3_:
  411|  2.43M|   {
  412|  2.43M|      if (*it != C) [[unlikely]] {
  ------------------
  |  Branch (412:11): [True: 2.46k, False: 2.43M]
  ------------------
  413|  2.46k|         if constexpr (C == '"') {
  414|  2.46k|            ctx.error = error_code::expected_quote;
  415|       |         }
  416|       |         else if constexpr (C == ',') {
  417|       |            ctx.error = error_code::expected_comma;
  418|       |         }
  419|       |         else if constexpr (C == ':') {
  420|       |            ctx.error = error_code::expected_colon;
  421|       |         }
  422|       |         else if constexpr (C == '[' || C == ']') {
  423|       |            ctx.error = error_code::expected_bracket;
  424|       |         }
  425|       |         else if constexpr (C == '{' || C == '}') {
  426|       |            ctx.error = error_code::expected_brace;
  427|       |         }
  428|       |         else {
  429|       |            ctx.error = error_code::syntax_error;
  430|       |         }
  431|  2.46k|         return true;
  432|  2.46k|      }
  433|  2.43M|      else [[likely]] {
  434|  2.43M|         ++it;
  435|  2.43M|      }
  436|  2.43M|      if constexpr (not Opts.null_terminated) {
  437|  2.43M|         if (it == end) [[unlikely]] {
  ------------------
  |  Branch (437:14): [True: 2, False: 2.43M]
  ------------------
  438|      2|            ctx.error = error_code::unexpected_end;
  439|      2|            return true;
  440|      2|         }
  441|  2.43M|      }
  442|  2.43M|      return false;
  443|  2.43M|   }
_ZN3glz18validate_utf8_spanITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEETkNS_10is_contextERNS_7contextEccEEbOT0_PKT1_PKT2_m:
  832|   770k|   {
  833|       |      if constexpr (not check_validate_utf8(Opts)) {
  834|       |         // Everything the caller computed for us is dead, which lets its scan loop drop the
  835|       |         // accumulator entirely.
  836|       |         (void)ctx, (void)start, (void)fin, (void)ascii_acc;
  837|       |         return false;
  838|       |      }
  839|   770k|      else {
  840|   770k|         if ((ascii_acc & repeat_byte8(0b10000000)) == 0) {
  ------------------
  |  Branch (840:14): [True: 744k, False: 26.3k]
  ------------------
  841|   744k|            return false; // pure ASCII is trivially well formed UTF-8
  842|   744k|         }
  843|  26.3k|         if (!validate_utf8(start, size_t(fin - start))) [[unlikely]] {
  ------------------
  |  Branch (843:14): [True: 13.6k, False: 12.6k]
  ------------------
  844|  13.6k|            ctx.error = error_code::invalid_utf8;
  845|  13.6k|            return true;
  846|  13.6k|         }
  847|  12.6k|         return false;
  848|  26.3k|      }
  849|   770k|   }
_ZN3glz25handle_unicode_code_pointIccEEjRPKT_RPT0_S3_:
  288|  29.5k|   {
  289|  29.5k|      using namespace unicode;
  290|       |
  291|  29.5k|      if (it + 4 >= end) [[unlikely]] {
  ------------------
  |  Branch (291:11): [True: 48, False: 29.4k]
  ------------------
  292|     48|         return false;
  293|     48|      }
  294|  29.4k|      const uint32_t high = hex_to_u32(it);
  295|  29.4k|      if (high == 0xFFFFFFFFu) [[unlikely]] {
  ------------------
  |  Branch (295:11): [True: 126, False: 29.3k]
  ------------------
  296|    126|         return false;
  297|    126|      }
  298|  29.3k|      it += 4; // skip the code point characters
  299|       |
  300|  29.3k|      uint32_t code_point;
  301|       |
  302|  29.3k|      if ((high & generic_surrogate_mask) == generic_surrogate_value) {
  ------------------
  |  Branch (302:11): [True: 2.95k, False: 26.4k]
  ------------------
  303|       |         // surrogate pair code points
  304|  2.95k|         if ((high & surrogate_mask) != high_surrogate_value) {
  ------------------
  |  Branch (304:14): [True: 24, False: 2.92k]
  ------------------
  305|     24|            return false;
  306|     24|         }
  307|       |
  308|  2.92k|         if (it + 6 >= end) [[unlikely]] {
  ------------------
  |  Branch (308:14): [True: 14, False: 2.91k]
  ------------------
  309|     14|            return false;
  310|     14|         }
  311|       |         // The next two characters must be `\u`
  312|  2.91k|         uint16_t u;
  313|  2.91k|         std::memcpy(&u, it, 2);
  314|  2.91k|         if (u != to_uint16_t(R"(\u)")) [[unlikely]] {
  ------------------
  |  Branch (314:14): [True: 113, False: 2.80k]
  ------------------
  315|    113|            return false;
  316|    113|         }
  317|  2.80k|         it += 2;
  318|       |         // verify that second unicode escape sequence is present
  319|  2.80k|         const uint32_t low = hex_to_u32(it);
  320|  2.80k|         if (low == 0xFFFFFFFFu) [[unlikely]] {
  ------------------
  |  Branch (320:14): [True: 37, False: 2.76k]
  ------------------
  321|     37|            return false;
  322|     37|         }
  323|  2.76k|         it += 4;
  324|       |
  325|  2.76k|         if ((low & surrogate_mask) != low_surrogate_value) [[unlikely]] {
  ------------------
  |  Branch (325:14): [True: 91, False: 2.67k]
  ------------------
  326|     91|            return false;
  327|     91|         }
  328|       |
  329|  2.67k|         code_point = (high & surrogate_codepoint_mask) << surrogate_codepoint_bits;
  330|  2.67k|         code_point |= (low & surrogate_codepoint_mask);
  331|  2.67k|         code_point += surrogate_codepoint_offset;
  332|  2.67k|      }
  333|  26.4k|      else {
  334|  26.4k|         code_point = high;
  335|  26.4k|      }
  336|  29.0k|      const uint32_t offset = code_point_to_utf8(code_point, dst);
  337|  29.0k|      dst += offset;
  338|  29.0k|      return offset;
  339|  29.3k|   }
_ZN3glz10hex_to_u32EPKc:
  203|   158k|   {
  204|   158k|      constexpr auto& t = digit_hex_table;
  205|   158k|      const uint8_t arr[4]{t[uint8_t(c[3])], t[uint8_t(c[2])], t[uint8_t(c[1])], t[uint8_t(c[0])]};
  206|   158k|      auto chunk = std::bit_cast<uint32_t>(arr);
  207|       |      // On big-endian, bit_cast produces bytes in opposite order than expected
  208|       |      // byteswap to get consistent little-endian representation
  209|       |      if constexpr (std::endian::native == std::endian::big) {
  210|       |         chunk = std::byteswap(chunk);
  211|       |      }
  212|       |      // check that all hex characters are valid
  213|   158k|      if (chunk & repeat_byte4(0b11110000u)) [[unlikely]] {
  ------------------
  |  Branch (213:11): [True: 4.33k, False: 154k]
  ------------------
  214|  4.33k|         return 0xFFFFFFFFu;
  215|  4.33k|      }
  216|       |
  217|       |      // now pack into first four bytes of uint32_t
  218|   154k|      uint32_t packed{};
  219|   154k|      packed |= (chunk & 0x0000000F);
  220|   154k|      packed |= (chunk & 0x00000F00) >> 4;
  221|   154k|      packed |= (chunk & 0x000F0000) >> 8;
  222|   154k|      packed |= (chunk & 0x0F000000) >> 12;
  223|   154k|      return packed;
  224|   158k|   }
_ZN3glz18code_point_to_utf8IcEEjjPT_:
  228|  29.0k|   {
  229|  29.0k|      if (code_point <= 0x7F) {
  ------------------
  |  Branch (229:11): [True: 1.53k, False: 27.5k]
  ------------------
  230|  1.53k|         c[0] = Char(code_point);
  231|  1.53k|         return 1;
  232|  1.53k|      }
  233|  27.5k|      if (code_point <= 0x7FF) {
  ------------------
  |  Branch (233:11): [True: 21.7k, False: 5.84k]
  ------------------
  234|  21.7k|         c[0] = Char(0xC0 | ((code_point >> 6) & 0x1F));
  235|  21.7k|         c[1] = Char(0x80 | (code_point & 0x3F));
  236|  21.7k|         return 2;
  237|  21.7k|      }
  238|  5.84k|      if (code_point <= 0xFFFF) {
  ------------------
  |  Branch (238:11): [True: 3.17k, False: 2.67k]
  ------------------
  239|  3.17k|         c[0] = Char(0xE0 | ((code_point >> 12) & 0x0F));
  240|  3.17k|         c[1] = Char(0x80 | ((code_point >> 6) & 0x3F));
  241|  3.17k|         c[2] = Char(0x80 | (code_point & 0x3F));
  242|  3.17k|         return 3;
  243|  3.17k|      }
  244|  2.67k|      if (code_point <= 0x10FFFF) {
  ------------------
  |  Branch (244:11): [True: 2.67k, False: 0]
  ------------------
  245|  2.67k|         c[0] = Char(0xF0 | ((code_point >> 18) & 0x07));
  246|  2.67k|         c[1] = Char(0x80 | ((code_point >> 12) & 0x3F));
  247|  2.67k|         c[2] = Char(0x80 | ((code_point >> 6) & 0x3F));
  248|  2.67k|         c[3] = Char(0x80 | (code_point & 0x3F));
  249|  2.67k|         return 4;
  250|  2.67k|      }
  251|      0|      return 0;
  252|  2.67k|   }
_ZN3glz17match_invalid_endILc91EXtlNS_22match_invalid_end_optsEEETkNS_10is_contextENS_7contextERPKcS4_EEbRT1_OT2_T3_:
  411|  46.0k|   {
  412|  46.0k|      if (*it != C) [[unlikely]] {
  ------------------
  |  Branch (412:11): [True: 176, False: 45.8k]
  ------------------
  413|       |         if constexpr (C == '"') {
  414|       |            ctx.error = error_code::expected_quote;
  415|       |         }
  416|       |         else if constexpr (C == ',') {
  417|       |            ctx.error = error_code::expected_comma;
  418|       |         }
  419|       |         else if constexpr (C == ':') {
  420|       |            ctx.error = error_code::expected_colon;
  421|       |         }
  422|    176|         else if constexpr (C == '[' || C == ']') {
  423|    176|            ctx.error = error_code::expected_bracket;
  424|       |         }
  425|       |         else if constexpr (C == '{' || C == '}') {
  426|       |            ctx.error = error_code::expected_brace;
  427|       |         }
  428|       |         else {
  429|       |            ctx.error = error_code::syntax_error;
  430|       |         }
  431|    176|         return true;
  432|    176|      }
  433|  45.8k|      else [[likely]] {
  434|  45.8k|         ++it;
  435|  45.8k|      }
  436|  45.8k|      if constexpr (not Opts.null_terminated) {
  437|  45.8k|         if (it == end) [[unlikely]] {
  ------------------
  |  Branch (437:14): [True: 14, False: 45.8k]
  ------------------
  438|     14|            ctx.error = error_code::unexpected_end;
  439|     14|            return true;
  440|     14|         }
  441|  45.8k|      }
  442|  45.8k|      return false;
  443|  46.0k|   }
_ZN3glz18validate_utf8_spanITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETkNS_10is_contextERNS_7contextEccEEbOT0_PKT1_PKT2_m:
  832|  1.65M|   {
  833|       |      if constexpr (not check_validate_utf8(Opts)) {
  834|       |         // Everything the caller computed for us is dead, which lets its scan loop drop the
  835|       |         // accumulator entirely.
  836|       |         (void)ctx, (void)start, (void)fin, (void)ascii_acc;
  837|       |         return false;
  838|       |      }
  839|  1.65M|      else {
  840|  1.65M|         if ((ascii_acc & repeat_byte8(0b10000000)) == 0) {
  ------------------
  |  Branch (840:14): [True: 1.53M, False: 124k]
  ------------------
  841|  1.53M|            return false; // pure ASCII is trivially well formed UTF-8
  842|  1.53M|         }
  843|   124k|         if (!validate_utf8(start, size_t(fin - start))) [[unlikely]] {
  ------------------
  |  Branch (843:14): [True: 37, False: 123k]
  ------------------
  844|     37|            ctx.error = error_code::invalid_utf8;
  845|     37|            return true;
  846|     37|         }
  847|   123k|         return false;
  848|   124k|      }
  849|  1.65M|   }
_ZN3glz5matchITnNS_14string_literalEXtlNS1_ILm4EEEtlA4_cLc117ELc108ELc108EEEETnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETkNS_10is_contextERNS_7contextERPKcS8_Qntcl15check_is_paddedT0_EEEvOT1_OT2_T3_:
  491|  1.83k|   {
  492|  1.83k|      const auto n = size_t(end - it);
  493|  1.83k|      static constexpr auto S = str.sv();
  494|  1.83k|      if ((n < str.size()) || not comparitor<S>(it)) [[unlikely]] {
  ------------------
  |  Branch (494:11): [True: 321, False: 1.51k]
  |  Branch (494:31): [True: 360, False: 1.15k]
  ------------------
  495|    681|         ctx.error = error_code::syntax_error;
  496|    681|      }
  497|  1.15k|      else [[likely]] {
  498|  1.15k|         it += str.size();
  499|  1.15k|      }
  500|  1.83k|   }
_ZN3glz5matchILc34ETkNS_10is_contextENS_7contextERPKcEEbRT0_OT1_:
  447|  44.8k|   {
  448|  44.8k|      if (*it != C) [[unlikely]] {
  ------------------
  |  Branch (448:11): [True: 0, False: 44.8k]
  ------------------
  449|      0|         if constexpr (C == '"') {
  450|      0|            ctx.error = error_code::expected_quote;
  451|       |         }
  452|       |         else if constexpr (C == ',') {
  453|       |            ctx.error = error_code::expected_comma;
  454|       |         }
  455|       |         else if constexpr (C == ':') {
  456|       |            ctx.error = error_code::expected_colon;
  457|       |         }
  458|       |         else if constexpr (C == '[' || C == ']') {
  459|       |            ctx.error = error_code::expected_bracket;
  460|       |         }
  461|       |         else if constexpr (C == '{' || C == '}') {
  462|       |            ctx.error = error_code::expected_brace;
  463|       |         }
  464|       |         else {
  465|       |            ctx.error = error_code::syntax_error;
  466|       |         }
  467|      0|         return true;
  468|      0|      }
  469|  44.8k|      else [[likely]] {
  470|  44.8k|         ++it;
  471|  44.8k|         return false;
  472|  44.8k|      }
  473|  44.8k|   }
_ZN3glz5matchITnNS_14string_literalEXtlNS1_ILm5EEEtlA5_cLc110ELc117ELc108ELc108EEEETnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEETkNS_10is_contextERNS_7contextERPKcS8_Qntcl15check_is_paddedT0_EEEvOT1_OT2_T3_:
  491|    706|   {
  492|    706|      const auto n = size_t(end - it);
  493|    706|      static constexpr auto S = str.sv();
  494|    706|      if ((n < str.size()) || not comparitor<S>(it)) [[unlikely]] {
  ------------------
  |  Branch (494:11): [True: 14, False: 692]
  |  Branch (494:31): [True: 223, False: 469]
  ------------------
  495|    237|         ctx.error = error_code::syntax_error;
  496|    237|      }
  497|    469|      else [[likely]] {
  498|    469|         it += str.size();
  499|    469|      }
  500|    706|   }
_ZN3glz11skip_numberIXtlNS_16skip_number_optsEEETkNS_10is_contextERNS_7contextERPKcS5_EEvOT0_OT1_T2_:
 1526|  53.9k|   {
 1527|  53.9k|      if constexpr (not Opts.validate) {
 1528|       |         if constexpr (Opts.null_terminated) {
 1529|       |            // Relies on the trailing '\0' sentinel (numeric_table['\0'] == false) to terminate.
 1530|       |            while (numeric_table[uint8_t(*it)]) {
 1531|       |               ++it;
 1532|       |            }
 1533|       |         }
 1534|  53.9k|         else {
 1535|  12.4M|            while (it < end && numeric_table[uint8_t(*it)]) {
  ------------------
  |  Branch (1535:20): [True: 12.4M, False: 34]
  |  Branch (1535:32): [True: 12.3M, False: 53.9k]
  ------------------
 1536|  12.3M|               ++it;
 1537|  12.3M|            }
 1538|  53.9k|         }
 1539|       |      }
 1540|       |      else {
 1541|       |         skip_number_with_validation(ctx, it, end);
 1542|       |      }
 1543|  53.9k|   }
_ZN3glz5matchITnNS_14string_literalEXtlNS1_ILm5EEEtlA5_cLc110ELc117ELc108ELc108EEEETnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETkNS_10is_contextERNS_7contextERPKcS8_Qntcl15check_is_paddedT0_EEEvOT1_OT2_T3_:
  491|   224k|   {
  492|   224k|      const auto n = size_t(end - it);
  493|   224k|      static constexpr auto S = str.sv();
  494|   224k|      if ((n < str.size()) || not comparitor<S>(it)) [[unlikely]] {
  ------------------
  |  Branch (494:11): [True: 284, False: 224k]
  |  Branch (494:31): [True: 431, False: 223k]
  ------------------
  495|    715|         ctx.error = error_code::syntax_error;
  496|    715|      }
  497|   223k|      else [[likely]] {
  498|   223k|         it += str.size();
  499|   223k|      }
  500|   224k|   }
_ZN3glz5matchILc125ETkNS_10is_contextENS_7contextERPKcEEbRT0_OT1_:
  447|  49.7k|   {
  448|  49.7k|      if (*it != C) [[unlikely]] {
  ------------------
  |  Branch (448:11): [True: 12.2k, False: 37.5k]
  ------------------
  449|       |         if constexpr (C == '"') {
  450|       |            ctx.error = error_code::expected_quote;
  451|       |         }
  452|       |         else if constexpr (C == ',') {
  453|       |            ctx.error = error_code::expected_comma;
  454|       |         }
  455|       |         else if constexpr (C == ':') {
  456|       |            ctx.error = error_code::expected_colon;
  457|       |         }
  458|       |         else if constexpr (C == '[' || C == ']') {
  459|       |            ctx.error = error_code::expected_bracket;
  460|       |         }
  461|  12.2k|         else if constexpr (C == '{' || C == '}') {
  462|  12.2k|            ctx.error = error_code::expected_brace;
  463|       |         }
  464|       |         else {
  465|       |            ctx.error = error_code::syntax_error;
  466|       |         }
  467|  12.2k|         return true;
  468|  12.2k|      }
  469|  37.5k|      else [[likely]] {
  470|  37.5k|         ++it;
  471|  37.5k|         return false;
  472|  37.5k|      }
  473|  49.7k|   }
_ZN3glz5matchILc93ETkNS_10is_contextENS_7contextERPKcEEbRT0_OT1_:
  447|  18.5k|   {
  448|  18.5k|      if (*it != C) [[unlikely]] {
  ------------------
  |  Branch (448:11): [True: 2.01k, False: 16.5k]
  ------------------
  449|       |         if constexpr (C == '"') {
  450|       |            ctx.error = error_code::expected_quote;
  451|       |         }
  452|       |         else if constexpr (C == ',') {
  453|       |            ctx.error = error_code::expected_comma;
  454|       |         }
  455|       |         else if constexpr (C == ':') {
  456|       |            ctx.error = error_code::expected_colon;
  457|       |         }
  458|  2.01k|         else if constexpr (C == '[' || C == ']') {
  459|  2.01k|            ctx.error = error_code::expected_bracket;
  460|       |         }
  461|       |         else if constexpr (C == '{' || C == '}') {
  462|       |            ctx.error = error_code::expected_brace;
  463|       |         }
  464|       |         else {
  465|       |            ctx.error = error_code::syntax_error;
  466|       |         }
  467|  2.01k|         return true;
  468|  2.01k|      }
  469|  16.5k|      else [[likely]] {
  470|  16.5k|         ++it;
  471|  16.5k|         return false;
  472|  16.5k|      }
  473|  18.5k|   }
_ZN3glz11skip_stringIXtlNS_16skip_string_optsELb0ELb0ELb1ELb1EEETkNS_10is_contextERNS_7contextERPKcS5_QntdtT_6paddedEEvOT0_OT1_T2_:
 1020|   213k|   {
 1021|   213k|      if constexpr (not Opts.opening_handled) {
 1022|   213k|         ++it;
 1023|   213k|      }
 1024|       |
 1025|   213k|      const auto* const utf8_start = it;
 1026|       |
 1027|   213k|      if constexpr (Opts.validate_skipped) {
 1028|  19.6M|         while (true) {
  ------------------
  |  Branch (1028:17): [True: 19.6M, Folded]
  ------------------
 1029|       |            // A null-terminated buffer terminates on the trailing '\0' (caught by the control
 1030|       |            // character check below); a non-null-terminated buffer has no sentinel, so bound the
 1031|       |            // scan before each dereference.
 1032|  19.6M|            if constexpr (not Opts.null_terminated) {
 1033|  19.6M|               if (it == end) [[unlikely]] {
  ------------------
  |  Branch (1033:20): [True: 169, False: 19.6M]
  ------------------
 1034|    169|                  ctx.error = error_code::unexpected_end;
 1035|    169|                  return;
 1036|    169|               }
 1037|  19.6M|            }
 1038|  19.6M|            if ((*it & 0b11100000) == 0) [[unlikely]] {
  ------------------
  |  Branch (1038:17): [True: 3.78k, False: 19.6M]
  ------------------
 1039|  3.78k|               ctx.error = error_code::syntax_error;
 1040|  3.78k|               return;
 1041|  3.78k|            }
 1042|       |
 1043|  19.6M|            switch (*it) {
  ------------------
  |  Branch (1043:21): [True: 413k, False: 19.2M]
  ------------------
 1044|   193k|            case '"': {
  ------------------
  |  Branch (1044:13): [True: 193k, False: 19.4M]
  ------------------
 1045|   193k|               validate_utf8_span<Opts>(ctx, utf8_start, it);
 1046|   193k|               ++it;
 1047|   193k|               return;
 1048|      0|            }
 1049|   220k|            case '\\': {
  ------------------
  |  Branch (1049:13): [True: 220k, False: 19.4M]
  ------------------
 1050|   220k|               ++it;
 1051|   220k|               if constexpr (not Opts.null_terminated) {
 1052|   220k|                  if (it == end) [[unlikely]] {
  ------------------
  |  Branch (1052:23): [True: 13, False: 220k]
  ------------------
 1053|     13|                     ctx.error = error_code::unexpected_end;
 1054|     13|                     return;
 1055|     13|                  }
 1056|   220k|               }
 1057|   220k|               if (char_unescape_table[uint8_t(*it)]) {
  ------------------
  |  Branch (1057:20): [True: 105k, False: 114k]
  ------------------
 1058|   105k|                  ++it;
 1059|   105k|                  continue;
 1060|   105k|               }
 1061|   114k|               else if (*it == 'u') {
  ------------------
  |  Branch (1061:25): [True: 113k, False: 1.71k]
  ------------------
 1062|   113k|                  ++it;
 1063|   113k|                  if (skip_unicode_code_point(it, end)) [[likely]] {
  ------------------
  |  Branch (1063:23): [True: 98.8k, False: 14.3k]
  ------------------
 1064|  98.8k|                     continue;
 1065|  98.8k|                  }
 1066|  14.3k|                  else [[unlikely]] {
 1067|  14.3k|                     ctx.error = error_code::unicode_escape_conversion_failure;
 1068|  14.3k|                     return;
 1069|  14.3k|                  }
 1070|   113k|               }
 1071|  1.71k|               ctx.error = error_code::syntax_error;
 1072|  1.71k|               return;
 1073|   220k|            }
 1074|  19.6M|            }
 1075|  19.2M|            ++it;
 1076|  19.2M|         }
 1077|       |      }
 1078|       |      else {
 1079|       |         skip_string_view(ctx, it, end);
 1080|       |         if (bool(ctx.error)) [[unlikely]] {
 1081|       |            return;
 1082|       |         }
 1083|       |         if (validate_utf8_span<Opts>(ctx, utf8_start, it)) [[unlikely]] {
 1084|       |            return;
 1085|       |         }
 1086|       |         ++it; // skip the quote
 1087|       |      }
 1088|   213k|   }
_ZN3glz18validate_utf8_spanITnDaXtlNS_16skip_string_optsELb0ELb0ELb1ELb1EEETkNS_10is_contextERNS_7contextEccEEbOT0_PKT1_PKT2_m:
  832|   193k|   {
  833|       |      if constexpr (not check_validate_utf8(Opts)) {
  834|       |         // Everything the caller computed for us is dead, which lets its scan loop drop the
  835|       |         // accumulator entirely.
  836|       |         (void)ctx, (void)start, (void)fin, (void)ascii_acc;
  837|       |         return false;
  838|       |      }
  839|   193k|      else {
  840|   193k|         if ((ascii_acc & repeat_byte8(0b10000000)) == 0) {
  ------------------
  |  Branch (840:14): [True: 0, False: 193k]
  ------------------
  841|      0|            return false; // pure ASCII is trivially well formed UTF-8
  842|      0|         }
  843|   193k|         if (!validate_utf8(start, size_t(fin - start))) [[unlikely]] {
  ------------------
  |  Branch (843:14): [True: 465, False: 193k]
  ------------------
  844|    465|            ctx.error = error_code::invalid_utf8;
  845|    465|            return true;
  846|    465|         }
  847|   193k|         return false;
  848|   193k|      }
  849|   193k|   }
_ZN3glz23skip_unicode_code_pointIcEEbRPKT_S3_:
  343|   113k|   {
  344|   113k|      using namespace unicode;
  345|   113k|      if (it + 4 >= end) [[unlikely]] {
  ------------------
  |  Branch (345:11): [True: 5.17k, False: 107k]
  ------------------
  346|  5.17k|         return false;
  347|  5.17k|      }
  348|       |
  349|   107k|      const uint32_t high = hex_to_u32(it);
  350|   107k|      if (high == 0xFFFFFFFFu) [[unlikely]] {
  ------------------
  |  Branch (350:11): [True: 2.22k, False: 105k]
  ------------------
  351|  2.22k|         return false;
  352|  2.22k|      }
  353|   105k|      it += 4; // skip the code point characters
  354|       |
  355|   105k|      uint32_t code_point;
  356|       |
  357|   105k|      if ((high & generic_surrogate_mask) == generic_surrogate_value) {
  ------------------
  |  Branch (357:11): [True: 22.2k, False: 83.4k]
  ------------------
  358|       |         // surrogate pair code points
  359|  22.2k|         if ((high & surrogate_mask) != high_surrogate_value) [[unlikely]] {
  ------------------
  |  Branch (359:14): [True: 798, False: 21.4k]
  ------------------
  360|    798|            return false;
  361|    798|         }
  362|       |
  363|  21.4k|         if (it + 6 >= end) [[unlikely]] {
  ------------------
  |  Branch (363:14): [True: 1.46k, False: 20.0k]
  ------------------
  364|  1.46k|            return false;
  365|  1.46k|         }
  366|       |         // The next two characters must be `\u`
  367|  20.0k|         uint16_t u;
  368|  20.0k|         std::memcpy(&u, it, 2);
  369|  20.0k|         if (u != to_uint16_t(R"(\u)")) [[unlikely]] {
  ------------------
  |  Branch (369:14): [True: 1.51k, False: 18.5k]
  ------------------
  370|  1.51k|            return false;
  371|  1.51k|         }
  372|  18.5k|         it += 2;
  373|       |         // verify that second unicode escape sequence is present
  374|  18.5k|         const uint32_t low = hex_to_u32(it);
  375|  18.5k|         if (low == 0xFFFFFFFFu) [[unlikely]] {
  ------------------
  |  Branch (375:14): [True: 1.95k, False: 16.5k]
  ------------------
  376|  1.95k|            return false;
  377|  1.95k|         }
  378|  16.5k|         it += 4;
  379|       |
  380|  16.5k|         if ((low & surrogate_mask) != low_surrogate_value) [[unlikely]] {
  ------------------
  |  Branch (380:14): [True: 1.20k, False: 15.3k]
  ------------------
  381|  1.20k|            return false;
  382|  1.20k|         }
  383|       |
  384|  15.3k|         code_point = (high & surrogate_codepoint_mask) << surrogate_codepoint_bits;
  385|  15.3k|         code_point |= (low & surrogate_codepoint_mask);
  386|  15.3k|         code_point += surrogate_codepoint_offset;
  387|  15.3k|      }
  388|  83.4k|      else {
  389|  83.4k|         code_point = high;
  390|  83.4k|      }
  391|  98.8k|      return skip_code_point(code_point) > 0;
  392|   105k|   }
_ZN3glz15skip_code_pointEj:
  255|  98.8k|   {
  256|  98.8k|      if (code_point <= 0x7F) {
  ------------------
  |  Branch (256:11): [True: 7.68k, False: 91.1k]
  ------------------
  257|  7.68k|         return 1;
  258|  7.68k|      }
  259|  91.1k|      if (code_point <= 0x7FF) {
  ------------------
  |  Branch (259:11): [True: 57.7k, False: 33.3k]
  ------------------
  260|  57.7k|         return 2;
  261|  57.7k|      }
  262|  33.3k|      if (code_point <= 0xFFFF) {
  ------------------
  |  Branch (262:11): [True: 17.9k, False: 15.3k]
  ------------------
  263|  17.9k|         return 3;
  264|  17.9k|      }
  265|  15.3k|      if (code_point <= 0x10FFFF) {
  ------------------
  |  Branch (265:11): [True: 15.3k, False: 0]
  ------------------
  266|  15.3k|         return 4;
  267|  15.3k|      }
  268|      0|      return 0;
  269|  15.3k|   }
_ZN3glz5matchITnNS_14string_literalEXtlNS1_ILm4EEEtlA4_cLc117ELc108ELc108EEEETnDaXtlNS_22registry_validate_optsIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEEEtlS5_Lj10ELb0ELb0ELb1ELb1EELb1ELb1EEETkNS_10is_contextERNS_7contextERPKcSA_Qntcl15check_is_paddedT0_EEEvOT1_OT2_T3_:
  491|  4.17k|   {
  492|  4.17k|      const auto n = size_t(end - it);
  493|  4.17k|      static constexpr auto S = str.sv();
  494|  4.17k|      if ((n < str.size()) || not comparitor<S>(it)) [[unlikely]] {
  ------------------
  |  Branch (494:11): [True: 849, False: 3.32k]
  |  Branch (494:31): [True: 1.21k, False: 2.11k]
  ------------------
  495|  2.06k|         ctx.error = error_code::syntax_error;
  496|  2.06k|      }
  497|  2.11k|      else [[likely]] {
  498|  2.11k|         it += str.size();
  499|  2.11k|      }
  500|  4.17k|   }
_ZN3glz5matchITnNS_14string_literalEXtlNS1_ILm5EEEtlA5_cLc97ELc108ELc115ELc101EEEETnDaXtlNS_22registry_validate_optsIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEEEtlS5_Lj10ELb0ELb0ELb1ELb1EELb1ELb1EEETkNS_10is_contextERNS_7contextERPKcSA_Qntcl15check_is_paddedT0_EEEvOT1_OT2_T3_:
  491|  5.25k|   {
  492|  5.25k|      const auto n = size_t(end - it);
  493|  5.25k|      static constexpr auto S = str.sv();
  494|  5.25k|      if ((n < str.size()) || not comparitor<S>(it)) [[unlikely]] {
  ------------------
  |  Branch (494:11): [True: 1.82k, False: 3.43k]
  |  Branch (494:31): [True: 1.62k, False: 1.80k]
  ------------------
  495|  3.44k|         ctx.error = error_code::syntax_error;
  496|  3.44k|      }
  497|  1.80k|      else [[likely]] {
  498|  1.80k|         it += str.size();
  499|  1.80k|      }
  500|  5.25k|   }
_ZN3glz5matchITnNS_14string_literalEXtlNS1_ILm4EEEtlA4_cLc114ELc117ELc101EEEETnDaXtlNS_22registry_validate_optsIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEEEtlS5_Lj10ELb0ELb0ELb1ELb1EELb1ELb1EEETkNS_10is_contextERNS_7contextERPKcSA_Qntcl15check_is_paddedT0_EEEvOT1_OT2_T3_:
  491|  3.51k|   {
  492|  3.51k|      const auto n = size_t(end - it);
  493|  3.51k|      static constexpr auto S = str.sv();
  494|  3.51k|      if ((n < str.size()) || not comparitor<S>(it)) [[unlikely]] {
  ------------------
  |  Branch (494:11): [True: 1.01k, False: 2.50k]
  |  Branch (494:31): [True: 894, False: 1.60k]
  ------------------
  495|  1.91k|         ctx.error = error_code::syntax_error;
  496|  1.91k|      }
  497|  1.60k|      else [[likely]] {
  498|  1.60k|         it += str.size();
  499|  1.60k|      }
  500|  3.51k|   }
_ZN3glz11skip_numberIXtlNS_16skip_number_optsELb1EEETkNS_10is_contextERNS_7contextERPKcS5_EEvOT0_OT1_T2_:
 1526|   368k|   {
 1527|       |      if constexpr (not Opts.validate) {
 1528|       |         if constexpr (Opts.null_terminated) {
 1529|       |            // Relies on the trailing '\0' sentinel (numeric_table['\0'] == false) to terminate.
 1530|       |            while (numeric_table[uint8_t(*it)]) {
 1531|       |               ++it;
 1532|       |            }
 1533|       |         }
 1534|       |         else {
 1535|       |            while (it < end && numeric_table[uint8_t(*it)]) {
 1536|       |               ++it;
 1537|       |            }
 1538|       |         }
 1539|       |      }
 1540|   368k|      else {
 1541|   368k|         skip_number_with_validation(ctx, it, end);
 1542|   368k|      }
 1543|   368k|   }
_ZN3glz27skip_number_with_validationITkNS_10is_contextERNS_7contextERPKcS4_EEvOT_OT0_T1_:
 1453|   368k|   {
 1454|       |      // Every standalone *it read below is guarded by it != end so the scan stays inside the
 1455|       |      // buffer for non-null-terminated input (the std::find_if_not calls are already bounded by
 1456|       |      // end). A null-terminated buffer is unaffected: it reaches end only once the number is
 1457|       |      // fully consumed, where these guards short-circuit exactly as the trailing '\0' sentinel
 1458|       |      // would have.
 1459|   368k|      it += (it != end) && (*it == '-');
  ------------------
  |  Branch (1459:13): [True: 368k, False: 0]
  |  Branch (1459:28): [True: 99.8k, False: 268k]
  ------------------
 1460|   368k|      const auto sig_start_it = it;
 1461|   368k|      auto frac_start_it = end;
 1462|   368k|      if (it != end && *it == '0') {
  ------------------
  |  Branch (1462:11): [True: 365k, False: 2.90k]
  |  Branch (1462:24): [True: 19.9k, False: 345k]
  ------------------
 1463|  19.9k|         ++it;
 1464|       |         // RFC 8259 section 6: number = [ minus ] int [ frac ] [ exp ]. The exponent may follow
 1465|       |         // the integer part directly, with no fractional part in between (e.g. "0e4").
 1466|  19.9k|         if (it != end && (*it | ('E' ^ 'e')) == 'e') {
  ------------------
  |  Branch (1466:14): [True: 13.8k, False: 6.02k]
  |  Branch (1466:27): [True: 3.67k, False: 10.2k]
  ------------------
 1467|  3.67k|            ++it;
 1468|  3.67k|            goto exp_start;
 1469|  3.67k|         }
 1470|  16.2k|         if (it == end || *it != '.') {
  ------------------
  |  Branch (1470:14): [True: 6.02k, False: 10.2k]
  |  Branch (1470:27): [True: 5.40k, False: 4.80k]
  ------------------
 1471|  11.4k|            return;
 1472|  11.4k|         }
 1473|  4.80k|         ++it;
 1474|  4.80k|         goto frac_start;
 1475|  16.2k|      }
 1476|   348k|      it = std::find_if_not(it, end, is_digit);
 1477|   348k|      if (it == sig_start_it) {
  ------------------
  |  Branch (1477:11): [True: 157k, False: 191k]
  ------------------
 1478|   157k|         ctx.error = error_code::syntax_error;
 1479|   157k|         return;
 1480|   157k|      }
 1481|   191k|      if (it != end && (*it | ('E' ^ 'e')) == 'e') {
  ------------------
  |  Branch (1481:11): [True: 107k, False: 83.1k]
  |  Branch (1481:24): [True: 18.2k, False: 89.7k]
  ------------------
 1482|  18.2k|         ++it;
 1483|  18.2k|         goto exp_start;
 1484|  18.2k|      }
 1485|   172k|      if (it == end || *it != '.') return;
  ------------------
  |  Branch (1485:11): [True: 83.1k, False: 89.7k]
  |  Branch (1485:24): [True: 68.1k, False: 21.5k]
  ------------------
 1486|  21.5k|      ++it;
 1487|  26.3k|   frac_start:
 1488|  26.3k|      frac_start_it = it;
 1489|  26.3k|      it = std::find_if_not(it, end, is_digit);
 1490|  26.3k|      if (it == frac_start_it) {
  ------------------
  |  Branch (1490:11): [True: 1.38k, False: 24.9k]
  ------------------
 1491|  1.38k|         ctx.error = error_code::syntax_error;
 1492|  1.38k|         return;
 1493|  1.38k|      }
 1494|  24.9k|      if (it == end || (*it | ('E' ^ 'e')) != 'e') return;
  ------------------
  |  Branch (1494:11): [True: 1.70k, False: 23.2k]
  |  Branch (1494:24): [True: 18.5k, False: 4.69k]
  ------------------
 1495|  4.69k|      ++it;
 1496|  26.6k|   exp_start:
 1497|  26.6k|      it += (it != end) && (*it == '+' || *it == '-');
  ------------------
  |  Branch (1497:13): [True: 26.2k, False: 365]
  |  Branch (1497:29): [True: 7.30k, False: 18.9k]
  |  Branch (1497:43): [True: 2.24k, False: 16.6k]
  ------------------
 1498|  26.6k|      const auto exp_start_it = it;
 1499|  26.6k|      it = std::find_if_not(it, end, is_digit);
 1500|  26.6k|      if (it == exp_start_it) {
  ------------------
  |  Branch (1500:11): [True: 3.96k, False: 22.6k]
  ------------------
 1501|  3.96k|         ctx.error = error_code::syntax_error;
 1502|  3.96k|         return;
 1503|  3.96k|      }
 1504|  26.6k|   }
_ZN3glz5matchITnNS_14string_literalEXtlNS1_ILm4EEEtlA4_cLc117ELc108ELc108EEEETnDaXtlZNS_11parse_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETkNS_10is_contextERNS_7contextERPKcS9_EEDaOT0_OT1_T2_E21opts_validate_skippedtlS5_Lj10ELb0ELb0ELb1ELb1EELb1EEETkNS_10is_contextES7_SA_S9_Qntcl15check_is_paddedT0_EEEvSE_OSF_T3_:
  491|    543|   {
  492|    543|      const auto n = size_t(end - it);
  493|    543|      static constexpr auto S = str.sv();
  494|    543|      if ((n < str.size()) || not comparitor<S>(it)) [[unlikely]] {
  ------------------
  |  Branch (494:11): [True: 0, False: 543]
  |  Branch (494:31): [True: 0, False: 543]
  ------------------
  495|      0|         ctx.error = error_code::syntax_error;
  496|      0|      }
  497|    543|      else [[likely]] {
  498|    543|         it += str.size();
  499|    543|      }
  500|    543|   }
_ZN3glz5matchITnNS_14string_literalEXtlNS1_ILm5EEEtlA5_cLc97ELc108ELc115ELc101EEEETnDaXtlZNS_11parse_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETkNS_10is_contextERNS_7contextERPKcS9_EEDaOT0_OT1_T2_E21opts_validate_skippedtlS5_Lj10ELb0ELb0ELb1ELb1EELb1EEETkNS_10is_contextES7_SA_S9_Qntcl15check_is_paddedT0_EEEvSE_OSF_T3_:
  491|  1.17k|   {
  492|  1.17k|      const auto n = size_t(end - it);
  493|  1.17k|      static constexpr auto S = str.sv();
  494|  1.17k|      if ((n < str.size()) || not comparitor<S>(it)) [[unlikely]] {
  ------------------
  |  Branch (494:11): [True: 0, False: 1.17k]
  |  Branch (494:31): [True: 0, False: 1.17k]
  ------------------
  495|      0|         ctx.error = error_code::syntax_error;
  496|      0|      }
  497|  1.17k|      else [[likely]] {
  498|  1.17k|         it += str.size();
  499|  1.17k|      }
  500|  1.17k|   }
_ZN3glz5matchITnNS_14string_literalEXtlNS1_ILm4EEEtlA4_cLc114ELc117ELc101EEEETnDaXtlZNS_11parse_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETkNS_10is_contextERNS_7contextERPKcS9_EEDaOT0_OT1_T2_E21opts_validate_skippedtlS5_Lj10ELb0ELb0ELb1ELb1EELb1EEETkNS_10is_contextES7_SA_S9_Qntcl15check_is_paddedT0_EEEvSE_OSF_T3_:
  491|    869|   {
  492|    869|      const auto n = size_t(end - it);
  493|    869|      static constexpr auto S = str.sv();
  494|    869|      if ((n < str.size()) || not comparitor<S>(it)) [[unlikely]] {
  ------------------
  |  Branch (494:11): [True: 0, False: 869]
  |  Branch (494:31): [True: 0, False: 869]
  ------------------
  495|      0|         ctx.error = error_code::syntax_error;
  496|      0|      }
  497|    869|      else [[likely]] {
  498|    869|         it += str.size();
  499|    869|      }
  500|    869|   }

_ZNK3glz14string_literalILm4EE4sizeEv:
   25|  17.2k|      [[nodiscard]] constexpr size_t size() const noexcept { return length; }
_ZNK3glz14string_literalILm5EE4sizeEv:
   25|   459k|      [[nodiscard]] constexpr size_t size() const noexcept { return length; }

_ZN3glz6detail15get_source_infoITkNS_8has_sizeENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEEENS0_11source_infoERKT_m:
   39|  4.11M|      {
   40|  4.11M|         using V = std::decay_t<decltype(buffer[0])>;
   41|       |
   42|       |         if constexpr (std::same_as<V, std::byte>) {
   43|       |            return {.context = "", .index = index};
   44|       |         }
   45|  4.11M|         else {
   46|  4.11M|            if (index >= buffer.size()) {
  ------------------
  |  Branch (46:17): [True: 3.73M, False: 382k]
  ------------------
   47|  3.73M|               return {.context = "", .index = index};
   48|  3.73M|            }
   49|       |
   50|   382k|            const auto start = std::begin(buffer) + index;
   51|   382k|            const auto line = size_t(std::count(std::begin(buffer), start, static_cast<V>('\n')) + 1);
   52|   382k|            const auto rstart = std::rbegin(buffer) + buffer.size() - index - 1;
   53|   382k|            const auto prev_new_line =
   54|   382k|               std::find((std::min)(rstart + 1, std::rend(buffer)), std::rend(buffer), static_cast<V>('\n'));
   55|   382k|            const auto column = size_t(std::distance(rstart, prev_new_line));
   56|   382k|            const auto next_new_line =
   57|   382k|               std::find((std::min)(start + 1, std::end(buffer)), std::end(buffer), static_cast<V>('\n'));
   58|       |
   59|   382k|            const auto offset = (prev_new_line == std::rend(buffer) ? 0 : index - column + 1);
  ------------------
  |  Branch (59:34): [True: 376k, False: 5.74k]
  ------------------
   60|   382k|            auto context_begin = std::begin(buffer) + offset;
   61|   382k|            auto context_end = next_new_line;
   62|       |
   63|   382k|            size_t front_truncation = 0;
   64|   382k|            size_t rear_truncation = 0;
   65|       |
   66|   382k|            if (std::distance(context_begin, context_end) > 64) {
  ------------------
  |  Branch (66:17): [True: 29.6k, False: 352k]
  ------------------
   67|       |               // reduce the context length so that we can more easily see errors, especially for non-prettified buffers
   68|  29.6k|               if (column <= 32) {
  ------------------
  |  Branch (68:20): [True: 15.8k, False: 13.8k]
  ------------------
   69|  15.8k|                  rear_truncation = 64;
   70|  15.8k|                  context_end = context_begin + rear_truncation;
   71|  15.8k|               }
   72|  13.8k|               else {
   73|  13.8k|                  front_truncation = column - 32;
   74|  13.8k|                  context_begin += front_truncation;
   75|  13.8k|                  if (std::distance(context_begin, context_end) > 64) {
  ------------------
  |  Branch (75:23): [True: 7.32k, False: 6.50k]
  ------------------
   76|  7.32k|                     rear_truncation = front_truncation + 64;
   77|  7.32k|                     context_end = std::begin(buffer) + offset + rear_truncation;
   78|  7.32k|                  }
   79|  13.8k|               }
   80|  29.6k|            }
   81|       |
   82|   382k|            std::string context{context_begin, context_end};
   83|   382k|            convert_tabs_to_single_spaces(context);
   84|   382k|            return {line, column, context, index, front_truncation, rear_truncation};
   85|  4.11M|         }
   86|  4.11M|      }
_ZN3glz6detail29convert_tabs_to_single_spacesERNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
   30|   382k|      {
   31|  5.22M|         for (auto& c : input) {
  ------------------
  |  Branch (31:23): [True: 5.22M, False: 382k]
  ------------------
   32|  5.22M|            if (c == '\t') {
  ------------------
  |  Branch (32:17): [True: 43.7k, False: 5.18M]
  ------------------
   33|  43.7k|               c = ' ';
   34|  43.7k|            }
   35|  5.22M|         }
   36|   382k|      }
_ZN3glz6detail21generate_error_stringENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEERKNS0_11source_infoES5_:
   97|  4.11M|      {
   98|  4.11M|         std::string b{};
   99|  4.11M|         b.resize(error.size() + info.context.size() + filename.size() + 128);
  100|  4.11M|         size_t ix{};
  101|       |
  102|  4.11M|         if (not filename.empty()) {
  ------------------
  |  Branch (102:14): [True: 0, False: 4.11M]
  ------------------
  103|      0|            dump_not_empty(filename, b, ix);
  104|      0|            dump(':', b, ix);
  105|      0|         }
  106|       |
  107|  4.11M|         glz::context ctx{};
  108|       |
  109|       |         // Diagnostic numbers (index/line/column) are always formatted with size-optimized
  110|       |         // integer conversion: error formatting is never a throughput path, and this keeps
  111|       |         // glz::format_error from pulling in the 40 KB integer table regardless of the
  112|       |         // optimization level used elsewhere in the program.
  113|  4.11M|         if (info.context.empty()) {
  ------------------
  |  Branch (113:14): [True: 3.73M, False: 382k]
  ------------------
  114|  3.73M|            dump("index ", b, ix);
  115|  3.73M|            write_chars::op<opts_size{}>(info.index, ctx, b, ix);
  116|  3.73M|            dump(": ", b, ix);
  117|  3.73M|            dump_maybe_empty(error, b, ix);
  118|  3.73M|         }
  119|   382k|         else {
  120|   382k|            write_chars::op<opts_size{}>(info.line, ctx, b, ix);
  121|   382k|            dump(':', b, ix);
  122|   382k|            write_chars::op<opts_size{}>(info.column, ctx, b, ix);
  123|   382k|            dump(": ", b, ix);
  124|   382k|            dump_maybe_empty(error, b, ix);
  125|   382k|            dump('\n', b, ix);
  126|   382k|            if (info.front_truncation) {
  ------------------
  |  Branch (126:17): [True: 13.8k, False: 368k]
  ------------------
  127|  13.8k|               if (info.rear_truncation) {
  ------------------
  |  Branch (127:20): [True: 7.32k, False: 6.50k]
  ------------------
  128|  7.32k|                  dump("...", b, ix);
  129|  7.32k|                  dump_maybe_empty(info.context, b, ix);
  130|  7.32k|                  dump("...\n   ", b, ix);
  131|  7.32k|               }
  132|  6.50k|               else {
  133|  6.50k|                  dump("...", b, ix);
  134|  6.50k|                  dump_maybe_empty(info.context, b, ix);
  135|  6.50k|                  dump("\n   ", b, ix);
  136|  6.50k|               }
  137|  13.8k|            }
  138|   368k|            else {
  139|   368k|               dump("   ", b, ix);
  140|   368k|               dump_maybe_empty(info.context, b, ix);
  141|   368k|               dump("\n   ", b, ix);
  142|   368k|            }
  143|   382k|            dumpn(' ', info.column - 1 - info.front_truncation, b, ix);
  144|   382k|            dump('^', b, ix);
  145|   382k|         }
  146|       |
  147|  4.11M|         b.resize(ix);
  148|  4.11M|         return b;
  149|  4.11M|      }

_ZN3glz8to_charsITkNSt3__114floating_pointEdLb0EEEPcS2_T_:
 1118|  2.62k|   {
 1119|  2.62k|      static_assert(std::is_same_v<T, float> || std::is_same_v<T, double>);
 1120|  2.62k|      return zmij::detail::write<T, OptSize>(val, buf);
 1121|  2.62k|   }
_ZN3glz4zmij6detail5writeIdLb0EEEPcT_S3_:
  975|  2.62k|      {
  976|  2.62k|         using namespace detail_impl;
  977|  2.62k|         using traits = float_traits<Float>;
  978|  2.62k|         auto bits = traits::to_bits(value);
  979|  2.62k|         auto bin_exp = traits::get_exp(bits);
  980|  2.62k|         auto bin_sig = traits::get_sig(bits);
  981|       |
  982|  2.62k|         *buffer = '-';
  983|  2.62k|         buffer += traits::is_negative(bits);
  984|       |
  985|  2.62k|         const auto* c = &consts_v<OptSize>;
  986|  2.62k|         ZMIJ_ASM(("" : "+r"(c)));
  ------------------
  |  |  126|  2.62k|#define ZMIJ_ASM(x) asm x
  ------------------
  987|  2.62k|         int64_t threshold = traits::num_bits == 64 ? static_cast<int64_t>(c->threshold) : 10'000'000;
  ------------------
  |  Branch (987:30): [True: 2.62k, Folded]
  ------------------
  988|       |
  989|  2.62k|         to_decimal_result dec;
  990|  2.62k|         bool is_normal = unsigned(bin_exp - 1) < unsigned(traits::exp_mask - 1);
  991|  2.62k|         if (!is_normal) [[unlikely]] {
  ------------------
  |  Branch (991:14): [True: 1.03k, False: 1.59k]
  ------------------
  992|  1.03k|            if (bin_exp != 0) {
  ------------------
  |  Branch (992:17): [True: 0, False: 1.03k]
  ------------------
  993|       |#if GLZ_ZMIJ_EMIT_INF_NAN
  994|       |               memcpy(buffer, bin_sig == 0 ? "inf" : "nan", 4);
  995|       |               return buffer + 3;
  996|       |#else
  997|       |               // Undo the speculative '-' for sign-bit-set NaN/Inf: JSON "null"
  998|       |               // never carries a sign.
  999|      0|               buffer -= traits::is_negative(bits);
 1000|      0|               memcpy(buffer, "null", 4);
 1001|      0|               return buffer + 4;
 1002|      0|#endif
 1003|      0|            }
 1004|  1.03k|            if (bin_sig == 0) {
  ------------------
  |  Branch (1004:17): [True: 572, False: 458]
  ------------------
 1005|    572|               memcpy(buffer, "0", 2);
 1006|    572|               return buffer + 1;
 1007|    572|            }
 1008|    458|            dec = detail_impl::to_decimal<Float, typename traits::sig_type, OptSize>(bin_sig, 1, true, *c);
 1009|    458|            int64_t dec_sig = dec.sig * 10 + (dec.has_last_digit ? dec.last_digit : 0);
  ------------------
  |  Branch (1009:47): [True: 89, False: 369]
  ------------------
 1010|    458|            int32_t dec_exp = dec.exp;
 1011|  2.08k|            while (dec_sig < threshold) {
  ------------------
  |  Branch (1011:20): [True: 1.62k, False: 458]
  ------------------
 1012|  1.62k|               dec_sig *= 10;
 1013|  1.62k|               --dec_exp;
 1014|  1.62k|            }
 1015|    458|            int64_t d = static_cast<int64_t>(detail_impl::div10(static_cast<uint64_t>(dec_sig)));
 1016|    458|            int32_t last_digit = static_cast<int32_t>(dec_sig - d * 10);
 1017|    458|            dec = {d, dec_exp, last_digit, last_digit != 0};
 1018|    458|         }
 1019|  1.59k|         else {
 1020|  1.59k|            dec = detail_impl::to_decimal<Float, typename traits::sig_type, OptSize>(bin_sig | traits::implicit_bit,
 1021|  1.59k|                                                                                     bin_exp, bin_sig != 0, *c);
 1022|  1.59k|         }
 1023|  2.05k|         bool extra_digit = dec.sig >= threshold;
 1024|  2.05k|         int dec_exp = dec.exp + traits::max_digits10 - 2 + extra_digit;
 1025|  2.05k|         if (traits::num_bits == 32 && dec.sig < 1'000'000) [[unlikely]] {
  ------------------
  |  Branch (1025:14): [Folded, False: 2.05k]
  |  Branch (1025:40): [True: 0, False: 0]
  ------------------
 1026|      0|            dec.sig = 10 * dec.sig + (dec.has_last_digit ? dec.last_digit : 0);
  ------------------
  |  Branch (1026:39): [True: 0, False: 0]
  ------------------
 1027|      0|            dec.has_last_digit = false;
 1028|      0|            --dec_exp;
 1029|      0|         }
 1030|       |
 1031|  2.05k|         char* start = buffer;
 1032|  2.05k|         auto dig = to_digits<traits::num_bits, OptSize>(static_cast<uint64_t>(dec.sig), extra_digit, *c);
 1033|  2.05k|         constexpr int bcd_size = traits::num_bits == 64 ? 16 : 8;
  ------------------
  |  Branch (1033:35): [True: 0, Folded]
  ------------------
 1034|  2.05k|         if (dec_exp >= traits::min_fixed_dec_exp && dec_exp <= traits::max_fixed_dec_exp) {
  ------------------
  |  Branch (1034:14): [True: 1.49k, False: 560]
  |  Branch (1034:54): [True: 936, False: 558]
  ------------------
 1035|    936|            memcpy(start, &zeros_v, 8);
 1036|    936|            const auto& fmt = dec_exp_formats.get<traits>(dec_exp);
 1037|    936|            buffer += fmt.start_pos;
 1038|    936|            memcpy(buffer, &dig.digits, bcd_size);
 1039|    936|            memmove(buffer, buffer + !extra_digit, bcd_size);
 1040|    936|            buffer[bcd_size + extra_digit - 1] = static_cast<char>('0' + (dec.has_last_digit ? dec.last_digit : 0));
  ------------------
  |  Branch (1040:75): [True: 162, False: 774]
  ------------------
 1041|    936|            memmove(start + fmt.shift_pos, start + fmt.point_pos, bcd_size);
 1042|    936|            start[fmt.point_pos] = '.';
 1043|    936|            int num_digits = dec.has_last_digit ? bcd_size : dig.num_digits - 1;
  ------------------
  |  Branch (1043:30): [True: 162, False: 774]
  ------------------
 1044|    936|            return buffer + fmt.exp_pos[num_digits + extra_digit - 1];
 1045|    936|         }
 1046|  1.11k|         buffer += extra_digit;
 1047|  1.11k|         memcpy(buffer, &dig.digits, bcd_size);
 1048|  1.11k|         buffer[bcd_size] = static_cast<char>('0' + dec.last_digit);
 1049|  1.11k|         buffer += dec.has_last_digit ? bcd_size + 1 : dig.num_digits;
  ------------------
  |  Branch (1049:20): [True: 312, False: 806]
  ------------------
 1050|  1.11k|         start[0] = start[1];
 1051|  1.11k|         start[1] = '.';
 1052|  1.11k|         buffer -= (buffer - 1 == start + 1);
 1053|       |
 1054|  1.11k|         if constexpr (exp_string_table<OptSize>::enable) {
 1055|  1.11k|            uint64_t exp_data = exp_strings_v<OptSize>.data[dec_exp + exp_string_table<OptSize>::offset];
 1056|  1.11k|            int len = int(exp_data >> 48);
 1057|  1.11k|            if (is_big_endian) exp_data = bswap64(exp_data);
  ------------------
  |  Branch (1057:17): [Folded, False: 1.11k]
  ------------------
 1058|  1.11k|            memcpy(buffer, &exp_data, traits::max_exponent10 >= 100 ? 8 : 4);
  ------------------
  |  Branch (1058:39): [True: 1.11k, Folded]
  ------------------
 1059|  1.11k|            return buffer + len;
 1060|  1.11k|         }
 1061|       |         // Glaze emits uppercase 'E', omits '+' on positive exponents, and
 1062|       |         // drops the leading zero on single-digit exponents (E7, not E07).
 1063|       |         // Branchless: write "E-" always, then advance past the '-' only when
 1064|       |         // the exponent is negative.
 1065|      0|         bool neg = dec_exp < 0;
 1066|  1.11k|         buffer[0] = 'E';
 1067|  1.11k|         buffer[1] = '-';
 1068|  1.11k|         buffer += 1 + unsigned(neg);
 1069|  1.11k|         dec_exp = neg ? -dec_exp : dec_exp;
  ------------------
  |  Branch (1069:20): [True: 0, False: 1.11k]
  ------------------
 1070|  1.11k|         unsigned hundreds_written = 0;
 1071|  1.11k|         if constexpr (traits::max_exponent10 >= 100) {
 1072|  1.11k|            int32_t digit = 0;
 1073|       |            if constexpr (use_umul128_hi64) {
 1074|       |               digit = static_cast<int32_t>(umul128_hi64(static_cast<uint64_t>(dec_exp), 0x290000000000000ull));
 1075|       |            }
 1076|  1.11k|            else {
 1077|  1.11k|               digit = static_cast<int32_t>((uint32_t(dec_exp) * div100_sig) >> div100_exp);
 1078|  1.11k|            }
 1079|  1.11k|            *buffer = static_cast<char>('0' + digit);
 1080|  1.11k|            hundreds_written = unsigned(dec_exp >= 100);
 1081|  1.11k|            buffer += hundreds_written;
 1082|  1.11k|            dec_exp -= digit * 100;
 1083|  1.11k|         }
 1084|       |         // dec_exp now in [0, 99]. Skip the tens digit only when no higher
 1085|       |         // digit has been written (i.e. true leading zero, not interior).
 1086|  1.11k|         const char* d2 = digits2(dec_exp);
 1087|  1.11k|         *buffer = d2[0];
 1088|  1.11k|         buffer += hundreds_written | unsigned(dec_exp >= 10);
 1089|  1.11k|         *buffer = d2[1];
 1090|  1.11k|         return buffer + 1;
 1091|  2.05k|      }
_ZN3glz4zmij11detail_impl12float_traitsIdE7to_bitsEd:
  358|  2.62k|         {
  359|  2.62k|            sig_type bits;
  360|  2.62k|            memcpy(&bits, &value, sizeof(value));
  361|  2.62k|            return bits;
  362|  2.62k|         }
_ZN3glz4zmij11detail_impl12float_traitsIdE7get_expEm:
  367|  2.62k|         {
  368|  2.62k|            return static_cast<int32_t>((bits << 1) >> (num_sig_bits + 1));
  369|  2.62k|         }
_ZN3glz4zmij11detail_impl12float_traitsIdE7get_sigEm:
  365|  2.62k|         static auto get_sig(sig_type bits) noexcept -> sig_type { return bits & (implicit_bit - 1); }
_ZN3glz4zmij11detail_impl12float_traitsIdE11is_negativeEm:
  364|  2.62k|         static auto is_negative(sig_type bits) noexcept -> bool { return bits >> (num_bits - 1); }
_ZN3glz4zmij11detail_impl10to_decimalIdmLb0EEENS1_17to_decimal_resultET0_lbRKNS1_9constantsIXT1_EEE:
  868|  2.05k|      {
  869|  2.05k|         using traits = float_traits<Float>;
  870|  2.05k|         int64_t bin_exp = raw_exp - traits::exp_offset;
  871|  2.05k|         constexpr int num_bits = std::numeric_limits<UInt>::digits;
  872|       |
  873|  2.05k|         constexpr uint64_t log10_2_sig = 78'913;
  874|  2.05k|         constexpr int32_t log10_2_exp = 18;
  875|  2.05k|         int32_t dec_exp = 0;
  876|       |         if constexpr (use_umul128_hi64) {
  877|       |            dec_exp =
  878|       |               static_cast<int32_t>(umul128_hi64(static_cast<uint64_t>(bin_exp), log10_2_sig << (64 - log10_2_exp)));
  879|       |         }
  880|  2.05k|         else {
  881|  2.05k|            dec_exp = compute_dec_exp(bin_exp);
  882|  2.05k|         }
  883|  2.05k|         uint64_t even = 1 - (bin_sig & 1);
  884|  2.05k|         constexpr int32_t extra_shift = exp_shift_table<OptSize>::extra_shift;
  885|       |
  886|  2.05k|         if (!regular) [[unlikely]] {
  ------------------
  |  Branch (886:14): [True: 374, False: 1.68k]
  ------------------
  887|    374|            int32_t irregular_dec_exp = compute_dec_exp(bin_exp, false);
  888|    374|            int32_t shift = compute_exp_shift(bin_exp, irregular_dec_exp + 1) + extra_shift;
  889|    374|            uint128 pow10 = c.pow10_significands[-irregular_dec_exp - 1];
  890|    374|            uint128 p = umul192_hi128(pow10.hi, pow10.lo, bin_sig << shift);
  891|       |
  892|    374|            int64_t integral = p.hi >> extra_shift;
  893|    374|            uint64_t fractional = p.hi << (64 - extra_shift) | p.lo >> extra_shift;
  894|       |
  895|    374|            uint64_t half_ulp = pow10.hi >> (extra_shift + 1 - shift);
  896|    374|            bool round_up = half_ulp > ~uint64_t(0) - fractional;
  897|    374|            bool round_down = (half_ulp >> 1) > fractional;
  898|    374|            integral += round_up;
  899|       |
  900|    374|            int32_t digit = static_cast<int32_t>(umul128_add_hi64(fractional, 10, (uint64_t(1) << 63) - 1));
  901|    374|            int32_t lo = static_cast<int32_t>(umul128_add_hi64(fractional - (half_ulp >> 1), 10, ~uint64_t(0)));
  902|    374|            if (digit < lo) digit = lo;
  ------------------
  |  Branch (902:17): [True: 347, False: 27]
  ------------------
  903|    374|            return {integral, irregular_dec_exp, digit, (round_up + round_down) == 0};
  904|    374|         }
  905|       |
  906|       |         if constexpr (num_bits == 32) {
  907|       |            constexpr int32_t float_extra_shift = 34;
  908|       |            int32_t shift = compute_exp_shift(bin_exp, dec_exp + 1) + float_extra_shift;
  909|       |            uint64_t pow10_hi = c.pow10_significands[-dec_exp - 1].hi;
  910|       |            uint64_t p = umul128_hi64(pow10_hi + 1, uint64_t(bin_sig) << shift);
  911|       |
  912|       |            int64_t integral = p >> float_extra_shift;
  913|       |            uint64_t fractional = p & ((1ull << float_extra_shift) - 1);
  914|       |
  915|       |            uint64_t half_ulp = (pow10_hi >> (65 - shift)) + even;
  916|       |            bool round_up = (fractional + half_ulp) >> float_extra_shift;
  917|       |            bool round_down = half_ulp > fractional;
  918|       |            integral += round_up;
  919|       |
  920|       |            uint64_t prod = fractional * 10;
  921|       |            int32_t digit = static_cast<int32_t>(prod >> float_extra_shift);
  922|       |            uint64_t rem = prod & ((1ull << float_extra_shift) - 1);
  923|       |            digit +=
  924|       |               rem > (1ull << (float_extra_shift - 1)) || (rem == (1ull << (float_extra_shift - 1)) && (digit & 1));
  925|       |            return {integral, dec_exp, digit, (round_up + round_down) == 0};
  926|       |         }
  927|  1.68k|         else {
  928|  1.68k|            int32_t shift = exp_shift_table<OptSize>::enable ? exp_shifts_v<OptSize>.data[bin_exp + traits::exp_offset]
  ------------------
  |  Branch (928:29): [True: 1.68k, Folded]
  ------------------
  929|  1.68k|                                                             : compute_exp_shift(bin_exp, dec_exp + 1) + extra_shift;
  930|  1.68k|            ZMIJ_ASM(("" : "+r"(dec_exp)));
  ------------------
  |  |  126|  1.68k|#define ZMIJ_ASM(x) asm x
  ------------------
  931|  1.68k|            uint128 pow10 = c.pow10_significands[-dec_exp - 1];
  932|  1.68k|            uint128 p = umul192_hi128(pow10.hi, pow10.lo, bin_sig << shift);
  933|  1.68k|            int64_t integral = p.hi >> extra_shift;
  934|  1.68k|            uint64_t fractional = p.hi << (64 - extra_shift) | p.lo >> extra_shift;
  935|  1.68k|            uint64_t half_ulp = (pow10.hi >> (extra_shift + 1 - shift)) + even;
  936|  1.68k|            bool round_up = fractional + half_ulp < fractional;
  937|  1.68k|            bool round_down = half_ulp > fractional;
  938|  1.68k|            integral += round_up;
  939|       |
  940|  1.68k|            int32_t digit = static_cast<int32_t>(umul128_add_hi64(fractional, 10, c.biased_half));
  941|  1.68k|            if (fractional == (1ull << 62)) [[unlikely]] {
  ------------------
  |  Branch (941:17): [True: 3, False: 1.67k]
  ------------------
  942|      3|               digit = 2;
  943|      3|            }
  944|  1.68k|            return {integral, dec_exp, digit, (round_up + round_down) == 0};
  945|  1.68k|         }
  946|  1.68k|      }
_ZN3glz4zmij11detail_impl15compute_dec_expElb:
  333|  2.42k|      {
  334|  2.42k|         assert(bin_exp >= -1334 && bin_exp <= 2620);
  ------------------
  |  Branch (334:10): [True: 2.42k, False: 0]
  |  Branch (334:10): [True: 2.42k, False: 0]
  |  Branch (334:10): [True: 2.42k, False: 0]
  ------------------
  335|  2.42k|         constexpr int log10_3_over_4_sig = 131'072;
  336|  2.42k|         constexpr int log10_2_sig = 315'653, log10_2_exp = 20;
  337|  2.42k|         return static_cast<int32_t>((bin_exp * log10_2_sig - !regular * log10_3_over_4_sig) >> log10_2_exp);
  338|  2.42k|      }
_ZN3glz4zmij11detail_impl17compute_exp_shiftEli:
  457|    374|      {
  458|    374|         assert(dec_exp >= -350 && dec_exp <= 350);
  ------------------
  |  Branch (458:10): [True: 374, False: 0]
  |  Branch (458:10): [True: 374, False: 0]
  |  Branch (458:10): [True: 374, False: 0]
  ------------------
  459|    374|         constexpr int log2_pow10_sig = 217'707, log2_pow10_exp = 16;
  460|    374|         int pow10_bin_exp = -dec_exp * log2_pow10_sig >> log2_pow10_exp;
  461|    374|         return static_cast<int32_t>(bin_exp + pow10_bin_exp + 1);
  462|    374|      }
_ZNK3glz4zmij11detail_impl23pow10_significand_tableILb0EEixEi:
  440|  2.05k|         {
  441|  2.05k|            constexpr int dec_exp_min = -293;
  442|  2.05k|            int i = dec_exp - dec_exp_min;
  443|  2.05k|            if (compress) return compute(i);
  ------------------
  |  Branch (443:17): [Folded, False: 2.05k]
  ------------------
  444|  2.05k|            if (!split_tables) return {data[i * 2], data[i * 2 + 1]};
  ------------------
  |  Branch (444:17): [True: 2.05k, Folded]
  ------------------
  445|       |
  446|      0|            const uint64_t* hi = data + num_pow10s + dec_exp_min - 1;
  447|      0|            const uint64_t* lo = hi + num_pow10s;
  448|       |
  449|      0|            if !consteval {
  450|      0|               ZMIJ_ASM(volatile("" : "+r"(hi), "+r"(lo)));
  ------------------
  |  |  126|      0|#define ZMIJ_ASM(x) asm x
  ------------------
  451|      0|            }
  452|      0|            return {hi[-dec_exp], lo[-dec_exp]};
  453|  2.05k|         }
_ZN3glz4zmij11detail_impl13umul192_hi128Emmm:
  308|  2.05k|      {
  309|  2.05k|         uint128_t p = umul128(x_hi, y);
  310|  2.05k|         uint64_t lo = uint64_t(p) + uint64_t(umul128(x_lo, y) >> 64);
  311|  2.05k|         return {uint64_t(p >> 64) + (lo < uint64_t(p)), lo};
  312|  2.05k|      }
_ZN3glz4zmij11detail_impl7umul128Emm:
  265|  4.56k|      {
  266|  4.56k|#if ZMIJ_USE_INT128
  267|  4.56k|         return uint128_t(x) * y;
  268|       |#else
  269|       |#if defined(_M_AMD64)
  270|       |         if !consteval {
  271|       |            uint64_t hi = 0;
  272|       |            uint64_t lo = _umul128(x, y, &hi);
  273|       |            return {hi, lo};
  274|       |         }
  275|       |#elif defined(_M_ARM64)
  276|       |         if !consteval {
  277|       |            return {__umulh(x, y), x * y};
  278|       |         }
  279|       |#endif
  280|       |         uint64_t a = x >> 32;
  281|       |         uint64_t b = uint32_t(x);
  282|       |         uint64_t c = y >> 32;
  283|       |         uint64_t d = uint32_t(y);
  284|       |
  285|       |         uint64_t ac = a * c;
  286|       |         uint64_t bc = b * c;
  287|       |         uint64_t ad = a * d;
  288|       |         uint64_t bd = b * d;
  289|       |
  290|       |         uint64_t cs = (bd >> 32) + uint32_t(ad) + uint32_t(bc);
  291|       |         return {ac + (ad >> 32) + (bc >> 32) + (cs >> 32), (cs << 32) + uint32_t(bd)};
  292|       |#endif
  293|  4.56k|      }
_ZN3glz4zmij11detail_impl16umul128_add_hi64Emmm:
  298|  2.42k|      {
  299|  2.42k|#if ZMIJ_USE_INT128
  300|  2.42k|         return uint64_t((uint128_t(x) * y + c) >> 64);
  301|       |#else
  302|       |         auto p = umul128(x, y);
  303|       |         return p.hi + (p.lo + c < p.lo);
  304|       |#endif
  305|  2.42k|      }
_ZN3glz4zmij11detail_impl5div10Em:
  326|    458|      {
  327|    458|         assert(x <= (1ull << 62));
  ------------------
  |  Branch (327:10): [True: 458, False: 0]
  ------------------
  328|    458|         constexpr uint64_t div10_sig64 = (1ull << 63) / 5 + 1;
  329|    458|         return ZMIJ_USE_INT128 ? umul128_hi64(x, div10_sig64) : x / 10;
  ------------------
  |  |  247|    458|#define ZMIJ_USE_INT128 1
  |  |  ------------------
  |  |  |  Branch (247:25): [True: 458, Folded]
  |  |  ------------------
  ------------------
  330|    458|      }
_ZN3glz4zmij11detail_impl12umul128_hi64Emm:
  295|    458|      constexpr auto umul128_hi64(uint64_t x, uint64_t y) noexcept -> uint64_t { return uint64_t(umul128(x, y) >> 64); }
_ZN3glz4zmij11detail_impl9to_digitsILi64ELb0EEENS1_10dec_digitsIXT_EEEmbRKNS1_9constantsIXT0_EEE:
  809|  2.05k|      {
  810|       |         if constexpr (num_bits == 32) {
  811|       |            auto result = to_bcd8<OptSize>(value);
  812|       |            return {result.bcd + zeros_v, result.len};
  813|       |         }
  814|  2.05k|         else {
  815|       |#if !ZMIJ_USE_NEON && !ZMIJ_USE_SSE
  816|       |            uint32_t bbccddee = uint32_t(value / 100'000'000);
  817|       |            uint32_t ffgghhii = uint32_t(value % 100'000'000);
  818|       |            auto hi = to_bcd8<OptSize>(bbccddee);
  819|       |            if (ffgghhii == 0) return {{hi.bcd + zeros_v, zeros_v}, hi.len};
  820|       |            auto lo = to_bcd8<OptSize>(ffgghhii);
  821|       |            return {{hi.bcd + zeros_v, lo.bcd + zeros_v}, 8 + lo.len};
  822|       |#elif ZMIJ_USE_NEON
  823|       |            auto unshuffled_digits = to_unshuffled_digits(value, c);
  824|       |            uint8x16_t digits = vrev64q_u8(unshuffled_digits);
  825|       |            uint16x8_t str = vaddq_u16(vreinterpretq_u16_u8(digits), vreinterpretq_u16_s8(vdupq_n_s8('0')));
  826|       |
  827|       |            // vcgtzq_s8 is AArch64-only; the portable spelling (ARMv7 NEON and
  828|       |            // up) is "compare greater-than against a zero vector".
  829|       |            uint16x8_t is_not_zero = vreinterpretq_u16_u8(vcgtq_s8(vreinterpretq_s8_u8(digits), vdupq_n_s8(0)));
  830|       |            uint64_t zeroes = vget_lane_u64(vreinterpret_u64_u8(vshrn_n_u16(is_not_zero, 4)), 0);
  831|       |            return {str, 16 - (clz(zeroes) >> 2)};
  832|       |#else
  833|  2.05k|            uint32_t abbccddee = uint32_t(value / 100'000'000);
  834|  2.05k|            uint32_t ffgghhii = uint32_t(value % 100'000'000);
  835|       |
  836|  2.05k|            const __m128i zeros = _mm_load_si128(m128ptr(&c.zeros));
  837|  2.05k|            auto unshuffled_bcd = to_unshuffled_digits(abbccddee, ffgghhii, c);
  838|       |#if ZMIJ_USE_SSE4_1
  839|       |            const __m128i bswap = _mm_load_si128(m128ptr(&c.bswap));
  840|       |            auto bcd = _mm_shuffle_epi8(unshuffled_bcd, bswap);
  841|       |#else
  842|  2.05k|            auto bcd = _mm_shuffle_epi32(unshuffled_bcd, _MM_SHUFFLE(0, 1, 2, 3));
  843|  2.05k|#endif
  844|       |
  845|  2.05k|            __m128i mask128 = _mm_cmpgt_epi8(bcd, _mm_setzero_si128());
  846|  2.05k|            uint64_t mask = _mm_movemask_epi8(mask128);
  847|       |#if defined(__LZCNT__) && !defined(ZMIJ_NO_BUILTINS)
  848|       |            int len = 32 - _lzcnt_u32(mask);
  849|       |#else
  850|  2.05k|            int len = 63 - clz((mask << 1) | 1);
  851|  2.05k|#endif
  852|  2.05k|            return {_mm_or_si128(bcd, zeros), len};
  853|  2.05k|#endif
  854|  2.05k|         }
  855|  2.05k|      }
_ZN3glz4zmij11detail_impl20to_unshuffled_digitsILb0EEEDv2_xjjRKNS1_9constantsIXT_EEE:
  735|  2.05k|      {
  736|  2.05k|         const __m128i div10k = _mm_load_si128(m128ptr(&c.div10k));
  737|  2.05k|         const __m128i neg10k = _mm_load_si128(m128ptr(&c.neg10k));
  738|  2.05k|         __m128i x = _mm_set_epi64x(bbccddee, ffgghhii);
  739|  2.05k|         __m128i y = _mm_add_epi64(x, _mm_mul_epu32(neg10k, _mm_srli_epi64(_mm_mul_epu32(x, div10k), div10k_exp)));
  740|  2.05k|         return to_bcd_4x4(y, c);
  741|  2.05k|      }
_ZN3glz4zmij11detail_impl10to_bcd_4x4ILb0EEEDv2_xS3_RKNS1_9constantsIXT_EEE:
  712|  2.05k|      {
  713|  2.05k|         const __m128i div100 = _mm_load_si128(m128ptr(&c.div100));
  714|  2.05k|         const __m128i div10 = _mm_load_si128(m128ptr(&c.div10));
  715|       |#if ZMIJ_USE_SSE4_1
  716|       |         const __m128i neg100 = _mm_load_si128(m128ptr(&c.neg100));
  717|       |         const __m128i neg10 = _mm_load_si128(m128ptr(&c.neg10));
  718|       |
  719|       |         __m128i z = _mm_add_epi64(y, _mm_mullo_epi32(neg100, _mm_srli_epi32(_mm_mulhi_epu16(y, div100), 3)));
  720|       |         return _mm_add_epi16(z, _mm_mullo_epi16(neg10, _mm_mulhi_epu16(z, div10)));
  721|       |#else
  722|  2.05k|         const __m128i hundred = _mm_load_si128(m128ptr(&c.hundred));
  723|  2.05k|         const __m128i moddiv10 = _mm_load_si128(m128ptr(&c.moddiv10));
  724|       |
  725|  2.05k|         __m128i y_div_100 = _mm_srli_epi16(_mm_mulhi_epu16(y, div100), 3);
  726|  2.05k|         __m128i y_mod_100 = _mm_sub_epi16(y, _mm_mullo_epi16(y_div_100, hundred));
  727|  2.05k|         __m128i z = _mm_or_si128(_mm_slli_epi32(y_mod_100, 16), y_div_100);
  728|  2.05k|         return _mm_sub_epi16(_mm_slli_epi16(z, 8), _mm_mullo_epi16(moddiv10, _mm_mulhi_epu16(z, div10)));
  729|  2.05k|#endif
  730|  2.05k|      }
_ZN3glz4zmij11detail_impl3clzEm:
  187|  2.05k|      {
  188|  2.05k|         assert(x != 0);
  ------------------
  |  Branch (188:10): [True: 2.05k, False: 0]
  ------------------
  189|  2.05k|#if ZMIJ_HAS_BUILTIN(__builtin_clzll)
  190|  2.05k|         return __builtin_clzll(x);
  191|       |#elif defined(_M_AMD64) && defined(__AVX2__)
  192|       |         return __lzcnt64(x);
  193|       |#elif defined(_M_AMD64) || defined(_M_ARM64)
  194|       |         unsigned long idx;
  195|       |         _BitScanReverse64(&idx, x);
  196|       |         return 63 - idx;
  197|       |#elif ZMIJ_MSC_VER
  198|       |         unsigned long idx;
  199|       |         if (_BitScanReverse(&idx, uint32_t(x >> 32))) return 31 - idx;
  200|       |         _BitScanReverse(&idx, uint32_t(x));
  201|       |         return 63 - idx;
  202|       |#else
  203|       |         int n = 64;
  204|       |         for (; x > 0; x >>= 1) --n;
  205|       |         return n;
  206|       |#endif
  207|  2.05k|      }
_ZNK3glz4zmij11detail_impl20dec_exp_format_table3getINS1_12float_traitsIdEEEERKNS2_5entryEi:
  559|    936|         {
  560|    936|            constexpr auto min = traits::min_fixed_dec_exp, max = Traits::max_fixed_dec_exp;
  561|    936|            unsigned i = unsigned(dec_exp - min);
  562|    936|            return data[i <= unsigned(max - min) ? i : num_entries - 1];
  ------------------
  |  Branch (562:25): [True: 936, False: 0]
  ------------------
  563|    936|         }