LLVMFuzzerTestOneInput:
   16|  7.38k|{
   17|       |   // use a vector with null termination instead of a std::string to avoid
   18|       |   // small string optimization to hide bounds problems
   19|  7.38k|   std::vector<char> buffer{Data, Data + Size};
   20|  7.38k|   buffer.push_back('\0');
   21|       |
   22|  7.38k|   [[maybe_unused]] auto s = glz::read_jsonc<my_struct>(std::string_view{buffer.data(), Size});
   23|  7.38k|   if (s) {
  ------------------
  |  Branch (23:8): [True: 3, False: 7.37k]
  ------------------
   24|       |      // hooray! valid json found
   25|      3|   }
   26|  7.38k|   return 0;
   27|  7.38k|}

_ZN3glz10get_memberIR9my_structRiEEDcOT_OT0_:
  616|  8.07k|   {
  617|  8.07k|      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|  8.07k|      else {
  639|  8.07k|         return element;
  640|  8.07k|      }
  641|  8.07k|   }
_ZN3glz10get_memberIR9my_structRdEEDcOT_OT0_:
  616|  23.1k|   {
  617|  23.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|  23.1k|      else {
  639|  23.1k|         return element;
  640|  23.1k|      }
  641|  23.1k|   }
_ZN3glz10get_memberIR9my_structRNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEDcOT_OT0_:
  616|  5.17k|   {
  617|  5.17k|      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|  5.17k|      else {
  639|  5.17k|         return element;
  640|  5.17k|      }
  641|  5.17k|   }
_ZN3glz10get_memberIR9my_structRNSt3__15arrayImLm3EEEEEDcOT_OT0_:
  616|  7.27k|   {
  617|  7.27k|      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|  7.27k|      else {
  639|  7.27k|         return element;
  640|  7.27k|      }
  641|  7.27k|   }

_ZN3glz11enter_depthITkNS_10is_contextENS_7contextEEEbRT_:
  250|  14.4k|   {
  251|  14.4k|      if (ctx.depth >= max_recursive_depth_limit) [[unlikely]] {
  ------------------
  |  Branch (251:11): [True: 0, False: 14.4k]
  ------------------
  252|      0|         ctx.error = error_code::exceeded_max_recursive_depth;
  253|      0|         return true;
  254|      0|      }
  255|  14.4k|      ++ctx.depth;
  256|  14.4k|      return false;
  257|  14.4k|   }
_ZNK3glz9error_ctxcvbEv:
  129|  7.38k|      operator bool() const noexcept { return ec != error_code::none; }

_ZN3glz4readITnDaXtlNS_4optsELj10ELb1ELb1ELb1ELb1EEE9my_structTkNS_10contiguousENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEETkNS_10is_contextERNS_7contextEQaa14read_supportedIT0_XdtT_6formatEEnt18is_input_streamingIT1_EEENS_9error_ctxERSA_OSB_OT2_:
  136|  7.38k|   {
  137|  7.38k|      static_assert(sizeof(decltype(*buffer.data())) == 1);
  138|  7.38k|      using Buffer = std::remove_reference_t<decltype(buffer)>;
  139|       |
  140|  7.38k|      if constexpr (Opts.format != NDJSON) {
  141|  7.38k|         if (buffer.empty()) [[unlikely]] {
  ------------------
  |  Branch (141:14): [True: 0, False: 7.38k]
  ------------------
  142|      0|            ctx.error = error_code::no_read_input;
  143|      0|            return {0, ctx.error, ctx.custom_error_message};
  144|      0|         }
  145|  7.38k|      }
  146|       |
  147|  7.38k|      constexpr bool use_padded = resizable<Buffer> && non_const_buffer<Buffer> && !check_disable_padding(Opts);
  ------------------
  |  Branch (147:35): [Folded, False: 7.38k]
  |  Branch (147:56): [True: 0, Folded]
  |  Branch (147:84): [True: 0, Folded]
  ------------------
  148|       |
  149|  7.38k|      [[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|  7.38k|      auto [it, end] = read_iterators<Opts, use_padded>(buffer);
  157|  7.38k|      auto start = it;
  158|  7.38k|      if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (158:11): [True: 0, False: 7.38k]
  ------------------
  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|  7.38k|      if constexpr (requires { ctx.speculation_budget; }) {
  165|  7.38k|         const size_t proportional = max_speculative_parse_factor * size_t(end - it);
  166|  7.38k|         ctx.speculation_budget =
  167|  7.38k|            (proportional > min_speculative_parse_bytes ? proportional : min_speculative_parse_bytes) + 2;
  ------------------
  |  Branch (167:14): [True: 77, False: 7.30k]
  ------------------
  168|  7.38k|      }
  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|  7.38k|      else {
  183|  7.38k|         parse<Opts.format>::template op<is_padded_off<Opts>()>(value, ctx, it, end);
  184|  7.38k|      }
  185|       |
  186|  7.38k|      if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (186:11): [True: 7.37k, False: 3]
  ------------------
  187|  7.37k|         goto finish;
  188|  7.37k|      }
  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|  7.38k|   finish:
  206|  7.38k|      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|  7.38k|      return {size_t(it - start), ctx.error, ctx.custom_error_message};
  214|      3|   }
_ZN3glz14read_iteratorsITnDaXtlNS_4optsELj10ELb1ELb1ELb1ELb1EEELb0ETkNS_10contiguousERNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEEEDaOT1_:
   40|  7.38k|   {
   41|  7.38k|      static_assert(sizeof(decltype(*buffer.data())) == 1);
   42|       |
   43|  7.38k|      auto it = reinterpret_cast<const char*>(buffer.data());
   44|  7.38k|      auto end = reinterpret_cast<const char*>(buffer.data()); // to be incremented
   45|       |
   46|       |      if constexpr (Padded) {
   47|       |         end += buffer.size() - padding_bytes;
   48|       |      }
   49|  7.38k|      else {
   50|  7.38k|         end += buffer.size();
   51|  7.38k|      }
   52|       |
   53|  7.38k|      return std::pair{it, end};
   54|  7.38k|   }
_ZN3glz23finalize_top_level_readITnDaXtlNS_4optsELj10ELb1ELb1ELb1ELb1EEETkNS_10is_contextERNS_7contextEEEvOT0_PKcS7_S7_:
  115|  7.38k|   {
  116|       |      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|       |         if (ctx.error == error_code::end_reached && ctx.depth == 0 && it == end && start < it) {
  122|       |            context ws_ctx{}; // only written to when skip_ws parses a comment; the result is unused
  123|       |            const char* consumed = start;
  124|       |            skip_ws<Opts>(ws_ctx, consumed, it);
  125|       |            if (consumed == it) {
  126|       |               ctx.error = error_code::no_read_input;
  127|       |            }
  128|       |         }
  129|       |      }
  130|  7.38k|      finalize_read_context<Opts>(ctx);
  131|  7.38k|   }
_ZN3glz21finalize_read_contextITnDaXtlNS_4optsELj10ELb1ELb1ELb1ELb1EEETkNS_10is_contextERNS_7contextEEEvOT0_:
   76|  7.38k|   {
   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|  7.38k|      settle_end_reached(ctx);
   96|  7.38k|   }
_ZN3glz18settle_end_reachedITkNS_10is_contextERNS_7contextEEEvOT_:
   68|  7.38k|   {
   69|  7.38k|      if (ctx.error == error_code::end_reached) {
  ------------------
  |  Branch (69:11): [True: 0, False: 7.38k]
  ------------------
   70|      0|         ctx.error = (ctx.depth == 0) ? error_code::none : error_code::unexpected_end;
  ------------------
  |  Branch (70:22): [True: 0, False: 0]
  ------------------
   71|      0|      }
   72|  7.38k|   }

_ZN3glz11decode_hashILj10E9my_structXtlNS_11hash_info_tIS1_Lm256EEELNS_9hash_typeE1EtlNSt3__15arrayIhLm256EEEtlA256_hLh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh3ELh4ELh4ELh1ELh4ELh4ELh4ELh2ELh0ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4EEELm1ELm5EEELS4_1EE2opIRPKcSC_EEmOT_T0_:
 2465|  44.3k|      {
 2466|       |         if constexpr (HashInfo.sized_hash) {
 2467|       |            const auto* c = quote_memchr<HashInfo.min_length>(it, end);
 2468|       |            if (c) [[likely]] {
 2469|       |               const auto n = size_t(static_cast<std::decay_t<decltype(it)>>(c) - it);
 2470|       |               if (n == 0 || n > HashInfo.max_length || HashInfo.unique_index >= size_t(end - it)) [[unlikely]] {
 2471|       |                  return N; // error
 2472|       |               }
 2473|       |
 2474|       |               const auto h = bitmix(uint16_t(it[HashInfo.unique_index]) | (uint16_t(n) << 8), HashInfo.seed);
 2475|       |               return HashInfo.table[h % bsize];
 2476|       |            }
 2477|       |            else [[unlikely]] {
 2478|       |               return N;
 2479|       |            }
 2480|       |         }
 2481|  44.3k|         else {
 2482|       |            if constexpr (N == 2) {
 2483|       |               if constexpr (uindex > 0) {
 2484|       |                  if ((it + uindex) >= end) [[unlikely]] {
 2485|       |                     return N; // error
 2486|       |                  }
 2487|       |               }
 2488|       |               // Avoids using a hash table
 2489|       |               constexpr auto first_key_char = reflect<T>::keys[0][uindex];
 2490|       |               return size_t(bool(it[uindex] ^ first_key_char));
 2491|       |            }
 2492|  44.3k|            else {
 2493|       |               if constexpr (uindex > 0) {
 2494|       |                  if ((it + uindex) >= end) [[unlikely]] {
 2495|       |                     return N; // error
 2496|       |                  }
 2497|       |               }
 2498|  44.3k|               return HashInfo.table[uint8_t(it[uindex])];
 2499|  44.3k|            }
 2500|  44.3k|         }
 2501|  44.3k|      }

_ZN3glz10read_jsoncITkNS_14read_supportedIL_ZNS_4JSONEEEE9my_structTkNS_9is_bufferENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEEENS3_8expectedIT_NS_9error_ctxEEEOT0_:
 5324|  7.38k|   {
 5325|  7.38k|      T value{};
 5326|  7.38k|      context ctx{};
 5327|  7.38k|      const error_ctx ec = read<opts{.comments = true}>(value, std::forward<Buffer>(buffer), ctx);
 5328|  7.38k|      if (ec) {
  ------------------
  |  Branch (5328:11): [True: 7.37k, False: 3]
  ------------------
 5329|  7.37k|         return unexpected<error_ctx>(ec);
 5330|  7.37k|      }
 5331|      3|      return value;
 5332|  7.38k|   }
_ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb1ELb1ELb1ELb1EEER9my_structTkNS_10is_contextERNS_7contextERPKcS9_EEvOT0_OT1_OT2_T3_:
   49|  7.38k|      {
   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|  7.38k|         else {
   60|  7.38k|            using V = std::remove_cvref_t<T>;
   61|  7.38k|            from<JSON, V>::template op<Opts>(std::forward<T>(value), std::forward<Ctx>(ctx), std::forward<It0>(it),
   62|  7.38k|                                             end);
   63|  7.38k|         }
   64|  7.38k|      }
_ZN3glz4fromILj10E9my_structE2opITnDaXtlNS_4optsELj10ELb1ELb1ELb1ELb1EEETnNS_14string_literalEXtlNS5_ILm1EEEEERS1_TkNS_10is_contextERNS_7contextERPKcSB_EEvOT1_OT2_OT3_T4_:
 3085|  7.38k|      {
 3086|  7.38k|         static constexpr auto num_members = reflect<T>::size;
 3087|       |
 3088|  7.38k|         static constexpr auto Opts = opening_handled_off<ws_handled_off<Options>()>();
 3089|  7.38k|         if constexpr (!check_opening_handled(Options)) {
 3090|  7.38k|            if constexpr (!check_ws_handled(Options)) {
 3091|  7.38k|               if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (3091:20): [True: 14, False: 7.36k]
  ------------------
 3092|     14|                  return;
 3093|     14|               }
 3094|  7.38k|            }
 3095|  7.38k|            if (match_invalid_end<'{', Opts>(ctx, it, end)) {
  ------------------
  |  Branch (3095:17): [True: 107, False: 7.27k]
  ------------------
 3096|    107|               return;
 3097|    107|            }
 3098|       |            if constexpr (not Opts.null_terminated) {
 3099|       |               if (it == end) [[unlikely]] {
 3100|       |                  ctx.error = error_code::unexpected_end;
 3101|       |                  return;
 3102|       |               }
 3103|       |            }
 3104|       |            // one nesting level (see enter_depth): counted in both modes so the limit binds,
 3105|       |            // released at each syntactic close below
 3106|  7.27k|            if (enter_depth(ctx)) [[unlikely]] {
  ------------------
  |  Branch (3106:17): [True: 0, False: 7.27k]
  ------------------
 3107|      0|               return;
 3108|      0|            }
 3109|  7.27k|         }
 3110|  7.27k|         const auto ws_start = it;
 3111|  7.38k|         if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (3111:14): [True: 14, False: 7.36k]
  ------------------
 3112|     14|            return;
 3113|     14|         }
 3114|  7.36k|         const size_t ws_size = size_t(it - ws_start);
 3115|       |
 3116|       |         if constexpr ((glaze_object_t<T> || reflectable<T>) && num_members == 0 && Opts.error_on_unknown_keys) {
 3117|       |            if constexpr (not tag.sv().empty()) {
 3118|       |               if (*it == '"') {
 3119|       |                  ++it;
 3120|       |                  if constexpr (not Opts.null_terminated) {
 3121|       |                     if (it == end) [[unlikely]] {
 3122|       |                        ctx.error = error_code::unexpected_end;
 3123|       |                        return;
 3124|       |                     }
 3125|       |                  }
 3126|       |
 3127|       |                  const auto start = it;
 3128|       |                  skip_string_view(ctx, it, end);
 3129|       |                  if (bool(ctx.error)) [[unlikely]]
 3130|       |                     return;
 3131|       |                  if (validate_utf8_span<Opts>(ctx, start, it)) [[unlikely]]
 3132|       |                     return;
 3133|       |                  const sv key{start, size_t(it - start)};
 3134|       |                  ++it;
 3135|       |                  if constexpr (not Opts.null_terminated) {
 3136|       |                     if (it == end) [[unlikely]] {
 3137|       |                        ctx.error = error_code::unexpected_end;
 3138|       |                        return;
 3139|       |                     }
 3140|       |                  }
 3141|       |
 3142|       |                  if (key == tag.sv()) {
 3143|       |                     if (parse_ws_colon<Opts>(ctx, it, end)) {
 3144|       |                        return;
 3145|       |                     }
 3146|       |
 3147|       |                     parse<JSON>::handle_unknown<Opts>(key, value, ctx, it, end);
 3148|       |                     if (bool(ctx.error)) [[unlikely]]
 3149|       |                        return;
 3150|       |
 3151|       |                     if (skip_ws<Opts>(ctx, it, end)) {
 3152|       |                        return;
 3153|       |                     }
 3154|       |                  }
 3155|       |                  else {
 3156|       |                     ctx.error = error_code::unknown_key;
 3157|       |                     return;
 3158|       |                  }
 3159|       |               }
 3160|       |            }
 3161|       |
 3162|       |            if (*it == '}') [[likely]] {
 3163|       |               --ctx.depth;
 3164|       |               if constexpr (glaze_object_t<T> || reflectable<T>) {
 3165|       |                  if constexpr (has_self_constraint_v<T> && !check_skip_self_constraint(Opts)) {
 3166|       |                     auto wrapper = self_constraint_v<T>(value);
 3167|       |                     from<JSON, decltype(wrapper)>::template op<ws_handled<Opts>()>(wrapper, ctx, it, end);
 3168|       |                     if (bool(ctx.error)) {
 3169|       |                        return;
 3170|       |                     }
 3171|       |                  }
 3172|       |               }
 3173|       |               ++it;
 3174|       |               if constexpr (not Opts.null_terminated) {
 3175|       |                  if (it == end) {
 3176|       |                     ctx.error = error_code::end_reached;
 3177|       |                     return;
 3178|       |                  }
 3179|       |               }
 3180|       |               if constexpr (Opts.partial_read) {
 3181|       |                  ctx.error = error_code::partial_read_complete;
 3182|       |               }
 3183|       |               return;
 3184|       |            }
 3185|       |            ctx.error = error_code::unknown_key;
 3186|       |            return;
 3187|       |         }
 3188|  7.36k|         else {
 3189|  7.36k|            decltype(auto) fields = [&]() -> decltype(auto) {
 3190|  7.36k|               if constexpr ((glaze_object_t<T> || reflectable<T>) &&
 3191|  7.36k|                             (Opts.error_on_missing_keys || Opts.partial_read)) {
 3192|  7.36k|                  return bit_array<num_members>{};
 3193|  7.36k|               }
 3194|  7.36k|               else {
 3195|  7.36k|                  return nullptr;
 3196|  7.36k|               }
 3197|  7.36k|            }();
 3198|       |
 3199|  7.36k|            size_t read_count{}; // for partial_read
 3200|       |
 3201|  7.36k|            bool first = true;
 3202|  51.9k|            while (true) {
  ------------------
  |  Branch (3202:20): [True: 48.5k, Folded]
  ------------------
 3203|       |               if constexpr ((glaze_object_t<T> || reflectable<T>) && Opts.partial_read) {
 3204|       |                  static constexpr bit_array<num_members> all_fields = [] {
 3205|       |                     bit_array<num_members> arr{};
 3206|       |                     for (size_t i = 0; i < num_members; ++i) {
 3207|       |                        arr[i] = true;
 3208|       |                     }
 3209|       |                     return arr;
 3210|       |                  }();
 3211|       |
 3212|       |                  if ((all_fields & fields) == all_fields) {
 3213|       |                     ctx.error = error_code::partial_read_complete;
 3214|       |                     --ctx.depth; // as above: an early success still closes this level
 3215|       |                     return;
 3216|       |                  }
 3217|       |               }
 3218|       |
 3219|       |               // Streaming refill point: at start of each iteration, ensure buffer has data
 3220|       |               if constexpr (has_streaming_state<decltype(ctx)>) {
 3221|       |                  if (ctx.stream.enabled()) {
 3222|       |                     const size_t consumed = static_cast<size_t>(it - ctx.stream.data());
 3223|       |                     const size_t remaining = ctx.stream.size() - consumed;
 3224|       |                     // Refill when less than half of buffer remains to ensure space for next key-value pair
 3225|       |                     if (remaining <= ctx.stream.size() / 2 || it >= end) {
 3226|       |                        const char* new_it;
 3227|       |                        const char* new_end;
 3228|       |                        ctx.stream.consume_and_refill(consumed, new_it, new_end);
 3229|       |                        it = new_it;
 3230|       |                        end = new_end;
 3231|       |                        if (it >= end && ctx.stream.at_eof()) {
 3232|       |                           ctx.error = error_code::unexpected_end;
 3233|       |                           return;
 3234|       |                        }
 3235|       |                     }
 3236|       |                  }
 3237|       |               }
 3238|       |
 3239|  48.5k|               if (*it == '}') {
  ------------------
  |  Branch (3239:20): [True: 3, False: 48.5k]
  ------------------
 3240|      3|                  --ctx.depth;
 3241|       |                  if constexpr ((glaze_object_t<T> || reflectable<T>) && Opts.error_on_missing_keys) {
 3242|       |                     constexpr auto req_fields = required_fields<T, Opts>();
 3243|       |                     if ((req_fields & fields) != req_fields) {
 3244|       |                        for (size_t i = 0; i < num_members; ++i) {
 3245|       |                           if (not fields[i] && req_fields[i]) {
 3246|       |                              ctx.custom_error_message = reflect<T>::keys[i];
 3247|       |                              // We just return the first missing key in order to avoid heap allocations
 3248|       |                              break;
 3249|       |                           }
 3250|       |                        }
 3251|       |
 3252|       |                        ctx.error = error_code::missing_key;
 3253|       |                        return;
 3254|       |                     }
 3255|       |                  }
 3256|      3|                  if constexpr (glaze_object_t<T> || reflectable<T>) {
 3257|       |                     if constexpr (has_self_constraint_v<T> && !check_skip_self_constraint(Opts)) {
 3258|       |                        auto wrapper = self_constraint_v<T>(value);
 3259|       |                        from<JSON, decltype(wrapper)>::template op<ws_handled<Opts>()>(wrapper, ctx, it, end);
 3260|       |                        if (bool(ctx.error)) {
 3261|       |                           return;
 3262|       |                        }
 3263|       |                     }
 3264|      3|                  }
 3265|      3|                  ++it; // Increment after checking for missing keys so errors are within buffer bounds
 3266|       |                  if constexpr (not Opts.null_terminated) {
 3267|       |                     if (it == end) {
 3268|       |                        ctx.error = error_code::end_reached;
 3269|       |                        return;
 3270|       |                     }
 3271|       |                  }
 3272|      3|                  return;
 3273|      3|               }
 3274|  48.5k|               else if (first) {
  ------------------
  |  Branch (3274:25): [True: 7.24k, False: 41.2k]
  ------------------
 3275|  7.24k|                  first = false;
 3276|  7.24k|               }
 3277|  41.2k|               else {
 3278|  41.2k|                  if (match_invalid_end<',', Opts>(ctx, it, end)) {
  ------------------
  |  Branch (3278:23): [True: 3.88k, False: 37.3k]
  ------------------
 3279|  3.88k|                     return;
 3280|  3.88k|                  }
 3281|       |                  if constexpr (not Opts.null_terminated) {
 3282|       |                     if (it == end) [[unlikely]] {
 3283|       |                        ctx.error = error_code::unexpected_end;
 3284|       |                        return;
 3285|       |                     }
 3286|       |                  }
 3287|       |
 3288|       |                  if constexpr ((not Opts.minified) && (num_members > 1 || not Opts.error_on_unknown_keys) &&
 3289|       |                                (!Opts.comments)) {
 3290|       |                     if (ws_size && ws_size < size_t(end - it)) {
 3291|       |                        skip_matching_ws(ws_start, it, ws_size);
 3292|       |                     }
 3293|       |                  }
 3294|       |
 3295|  37.3k|                  if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (3295:23): [True: 15, False: 37.3k]
  ------------------
 3296|     15|                     return;
 3297|     15|                  }
 3298|  37.3k|               }
 3299|       |
 3300|  44.6k|               constexpr auto reflection_type = glaze_object_t<T> || reflectable<T>;
  ------------------
  |  Branch (3300:49): [Folded, False: 0]
  |  Branch (3300:70): [True: 0, Folded]
  ------------------
 3301|       |
 3302|       |               if constexpr (reflection_type && (num_members == 0)) {
 3303|       |                  if constexpr (Opts.error_on_unknown_keys) {
 3304|       |                     static_assert(false_v<T>, "This should be unreachable");
 3305|       |                  }
 3306|       |                  else {
 3307|       |                     if (match_invalid_end<'"', Opts>(ctx, it, end)) {
 3308|       |                        return;
 3309|       |                     }
 3310|       |
 3311|       |                     // parsing to an empty object, but at this point the JSON presents keys
 3312|       |
 3313|       |                     // Unknown key handler does not unescape keys. Unknown escaped keys are
 3314|       |                     // handled by the user.
 3315|       |
 3316|       |                     const auto start = it;
 3317|       |                     skip_string_view(ctx, it, end);
 3318|       |                     if (bool(ctx.error)) [[unlikely]]
 3319|       |                        return;
 3320|       |                     if (validate_utf8_span<Opts>(ctx, start, it)) [[unlikely]]
 3321|       |                        return;
 3322|       |                     const sv key{start, size_t(it - start)};
 3323|       |                     ++it;
 3324|       |                     if constexpr (not Opts.null_terminated) {
 3325|       |                        if (it == end) [[unlikely]] {
 3326|       |                           ctx.error = error_code::unexpected_end;
 3327|       |                           return;
 3328|       |                        }
 3329|       |                     }
 3330|       |
 3331|       |                     if (parse_ws_colon<Opts>(ctx, it, end)) {
 3332|       |                        return;
 3333|       |                     }
 3334|       |
 3335|       |                     // Check if this key is the variant tag that should be skipped
 3336|       |                     if constexpr (not tag.sv().empty()) {
 3337|       |                        if (key == tag.sv()) {
 3338|       |                           // Skip the tag value
 3339|       |                           skip_value<JSON>::op<Opts>(ctx, it, end);
 3340|       |                           if (bool(ctx.error)) [[unlikely]]
 3341|       |                              return;
 3342|       |                           if (skip_ws<Opts>(ctx, it, end)) {
 3343|       |                              return;
 3344|       |                           }
 3345|       |                           continue;
 3346|       |                        }
 3347|       |                     }
 3348|       |
 3349|       |                     parse<JSON>::handle_unknown<Opts>(key, value, ctx, it, end);
 3350|       |                     if (bool(ctx.error)) [[unlikely]]
 3351|       |                        return;
 3352|       |                     if constexpr (not Opts.null_terminated) {
 3353|       |                        if (it == end) [[unlikely]] {
 3354|       |                           ctx.error = error_code::unexpected_end;
 3355|       |                           return;
 3356|       |                        }
 3357|       |                     }
 3358|       |                     if (skip_ws<Opts>(ctx, it, end)) {
 3359|       |                        return;
 3360|       |                     }
 3361|       |                  }
 3362|       |               }
 3363|  44.6k|               else if constexpr (reflection_type) {
 3364|  44.6k|                  static_assert(bool(hash_info<T>.type));
 3365|       |
 3366|  44.6k|                  if (*it != '"') [[unlikely]] {
  ------------------
  |  Branch (3366:23): [True: 244, False: 44.3k]
  ------------------
 3367|    244|                     ctx.error = error_code::expected_quote;
 3368|    244|                     return;
 3369|    244|                  }
 3370|  44.3k|                  ++it;
 3371|       |                  if constexpr (not Opts.null_terminated) {
 3372|       |                     if (it == end) [[unlikely]] {
 3373|       |                        ctx.error = error_code::unexpected_end;
 3374|       |                        return;
 3375|       |                     }
 3376|       |                  }
 3377|       |
 3378|       |                  if constexpr (not tag.sv().empty() && not contains_tag<T, tag>()) {
 3379|       |                     // For tagged variants we first check to see if the key matches the tag
 3380|       |                     // We only need to do this if the tag is not part of the keys
 3381|       |
 3382|       |                     const auto start = it;
 3383|       |                     skip_string_view(ctx, it, end);
 3384|       |                     if (bool(ctx.error)) [[unlikely]]
 3385|       |                        return;
 3386|       |                     if (validate_utf8_span<Opts>(ctx, start, it)) [[unlikely]]
 3387|       |                        return;
 3388|       |                     const sv key{start, size_t(it - start)};
 3389|       |                     ++it;
 3390|       |                     if constexpr (not Opts.null_terminated) {
 3391|       |                        if (it == end) [[unlikely]] {
 3392|       |                           ctx.error = error_code::unexpected_end;
 3393|       |                           return;
 3394|       |                        }
 3395|       |                     }
 3396|       |
 3397|       |                     if (key == tag.sv()) {
 3398|       |                        if (parse_ws_colon<Opts>(ctx, it, end)) {
 3399|       |                           return;
 3400|       |                        }
 3401|       |
 3402|       |                        parse<JSON>::handle_unknown<Opts>(key, value, ctx, it, end);
 3403|       |                        if (bool(ctx.error)) [[unlikely]]
 3404|       |                           return;
 3405|       |
 3406|       |                        if (skip_ws<Opts>(ctx, it, end)) {
 3407|       |                           return;
 3408|       |                        }
 3409|       |                        continue;
 3410|       |                     }
 3411|       |                     else {
 3412|       |                        it = start; // reset the iterator
 3413|       |                     }
 3414|       |                  }
 3415|       |
 3416|       |                  if constexpr (Opts.error_on_missing_keys || Opts.partial_read) {
 3417|       |                     size_t index = num_members;
 3418|       |                     parse_and_invoke<Opts, T>(value, ctx, it, end, index);
 3419|       |                     if (bool(ctx.error)) [[unlikely]]
 3420|       |                        return;
 3421|       |                     if (index < num_members) {
 3422|       |                        fields[index] = true;
 3423|       |                     }
 3424|       |                  }
 3425|  44.3k|                  else {
 3426|  44.3k|                     parse_and_invoke<Opts, T>(value, ctx, it, end);
 3427|  44.3k|                     if (bool(ctx.error)) [[unlikely]]
  ------------------
  |  Branch (3427:26): [True: 3.07k, False: 41.3k]
  ------------------
 3428|  3.07k|                        return;
 3429|  44.3k|                  }
 3430|       |               }
 3431|       |               else {
 3432|       |                  // For types like std::map, std::unordered_map
 3433|       |
 3434|       |                  auto reading = [&](auto&& key) {
 3435|       |                     if constexpr (Opts.partial_read) {
 3436|       |                        if (auto element = value.find(key); element != value.end()) {
 3437|       |                           ++read_count;
 3438|       |                           parse<JSON>::op<ws_handled<Opts>()>(element->second, ctx, it, end);
 3439|       |                        }
 3440|       |                        else {
 3441|       |                           skip_value<JSON>::op<Opts>(ctx, it, end);
 3442|       |                        }
 3443|       |                     }
 3444|       |                     else {
 3445|       |                        parse<JSON>::op<ws_handled<Opts>()>(value[key], ctx, it, end);
 3446|       |                     }
 3447|       |                  };
 3448|       |
 3449|       |                  // using Key = std::conditional_t<heterogeneous_map<T>, sv, typename T::key_type>;
 3450|       |                  using Key = typename T::key_type;
 3451|       |                  if constexpr (std::is_same_v<Key, std::string>) {
 3452|       |                     ctx.scratch.clear();
 3453|       |                     parse<JSON>::op<Opts>(ctx.scratch, ctx, it, end);
 3454|       |                     if (bool(ctx.error)) [[unlikely]]
 3455|       |                        return;
 3456|       |
 3457|       |                     if (parse_ws_colon<Opts>(ctx, it, end)) {
 3458|       |                        return;
 3459|       |                     }
 3460|       |
 3461|       |                     reading(ctx.scratch);
 3462|       |                     if constexpr (Opts.partial_read) {
 3463|       |                        if (read_count == value.size()) {
 3464|       |                           return;
 3465|       |                        }
 3466|       |                     }
 3467|       |                     if (bool(ctx.error)) [[unlikely]]
 3468|       |                        return;
 3469|       |                  }
 3470|       |                  else if constexpr (str_t<Key>) {
 3471|       |                     Key key;
 3472|       |                     parse<JSON>::op<Opts>(key, ctx, it, end);
 3473|       |                     if (bool(ctx.error)) [[unlikely]]
 3474|       |                        return;
 3475|       |
 3476|       |                     if (parse_ws_colon<Opts>(ctx, it, end)) {
 3477|       |                        return;
 3478|       |                     }
 3479|       |
 3480|       |                     reading(key);
 3481|       |                     if constexpr (Opts.partial_read) {
 3482|       |                        if (read_count == value.size()) {
 3483|       |                           return;
 3484|       |                        }
 3485|       |                     }
 3486|       |                     if (bool(ctx.error)) [[unlikely]]
 3487|       |                        return;
 3488|       |                  }
 3489|       |                  else {
 3490|       |                     Key key_value{};
 3491|       |                     if constexpr (is_named_enum<Key> || mimics_str_t<Key>) {
 3492|       |                        parse<JSON>::op<Opts>(key_value, ctx, it, end);
 3493|       |                     }
 3494|       |                     else if constexpr (std::is_arithmetic_v<Key>) {
 3495|       |                        // prefer over quoted_t below to avoid double parsing of quoted_t
 3496|       |                        parse<JSON>::op<opt_true<Opts, quoted_num_opt_tag{}>>(key_value, ctx, it, end);
 3497|       |                     }
 3498|       |                     else {
 3499|       |                        parse<JSON>::op<opt_false<Opts, raw_string_opt_tag{}>>(quoted_t<Key>{key_value}, ctx, it, end);
 3500|       |                     }
 3501|       |                     if (bool(ctx.error)) [[unlikely]]
 3502|       |                        return;
 3503|       |
 3504|       |                     if (parse_ws_colon<Opts>(ctx, it, end)) {
 3505|       |                        return;
 3506|       |                     }
 3507|       |
 3508|       |                     reading(key_value);
 3509|       |                     if constexpr (Opts.partial_read) {
 3510|       |                        if (read_count == value.size()) {
 3511|       |                           return;
 3512|       |                        }
 3513|       |                     }
 3514|       |                     if (bool(ctx.error)) [[unlikely]]
 3515|       |                        return;
 3516|       |                  }
 3517|       |               }
 3518|       |
 3519|       |               // Streaming refill point: after parsing each key-value pair, refill if buffer is low
 3520|       |               if constexpr (has_streaming_state<decltype(ctx)>) {
 3521|       |                  if (ctx.stream.enabled()) {
 3522|       |                     const size_t consumed = static_cast<size_t>(it - ctx.stream.data());
 3523|       |                     // Refill when less than 25% of buffer remains to ensure enough space for next element
 3524|       |                     if (ctx.stream.size() - consumed <= ctx.stream.size() / 4 || it >= end) {
 3525|       |                        const char* new_it;
 3526|       |                        const char* new_end;
 3527|       |                        ctx.stream.consume_and_refill(consumed, new_it, new_end);
 3528|       |                        it = new_it;
 3529|       |                        end = new_end;
 3530|       |                        if (it >= end && ctx.stream.at_eof()) {
 3531|       |                           ctx.error = error_code::unexpected_end;
 3532|       |                           return;
 3533|       |                        }
 3534|       |                     }
 3535|       |                  }
 3536|       |               }
 3537|       |
 3538|  44.6k|               if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (3538:20): [True: 23, False: 44.6k]
  ------------------
 3539|     23|                  return;
 3540|     23|               }
 3541|  44.6k|            }
 3542|  7.36k|         }
 3543|  7.36k|      }
_ZZN3glz4fromILj10E9my_structE2opITnDaXtlNS_4optsELj10ELb1ELb1ELb1ELb1EEETnNS_14string_literalEXtlNS5_ILm1EEEEERS1_TkNS_10is_contextERNS_7contextERPKcSB_EEvOT1_OT2_OT3_T4_ENKUlvE_clEv:
 3189|  7.24k|            decltype(auto) fields = [&]() -> decltype(auto) {
 3190|       |               if constexpr ((glaze_object_t<T> || reflectable<T>) &&
 3191|       |                             (Opts.error_on_missing_keys || Opts.partial_read)) {
 3192|       |                  return bit_array<num_members>{};
 3193|       |               }
 3194|  7.24k|               else {
 3195|  7.24k|                  return nullptr;
 3196|  7.24k|               }
 3197|  7.24k|            }();
_ZN3glz16parse_and_invokeITnDaXtlNS_4optsELj10ELb1ELb1ELb1ELb1EEE9my_structRS2_JETkNS_10is_contextERNS_7contextERPKcS8_Qoo14glaze_object_tIT0_E11reflectableIS9_EEEvOT1_OT3_OT4_OT5_DpOT2_:
  364|  44.3k|   {
  365|  44.3k|      constexpr auto N = reflect<T>::size;
  366|       |
  367|       |      if constexpr (N == 1) {
  368|       |         decode_index<Opts, T, 0>(value, ctx, it, end, selected_index...);
  369|       |      }
  370|       |      else if constexpr (check_linear_search(Opts)) {
  371|       |         // Linear search path
  372|       |         auto key_start = it;
  373|       |         const auto index = decode_linear<T>(ctx, it, end);
  374|       |         if (bool(ctx.error)) [[unlikely]]
  375|       |            return;
  376|       |
  377|       |         if (index >= N) [[unlikely]] {
  378|       |            if constexpr (Opts.error_on_unknown_keys) {
  379|       |               ctx.error = error_code::unknown_key;
  380|       |               return;
  381|       |            }
  382|       |            else {
  383|       |               // it sits one past the closing quote, so the raw key spans [key_start, it - 1)
  384|       |               if (validate_utf8_span<Opts>(ctx, key_start, it - 1)) [[unlikely]] {
  385|       |                  return;
  386|       |               }
  387|       |               const sv key{key_start, size_t(it - key_start - 1)};
  388|       |               if constexpr (not Opts.null_terminated) {
  389|       |                  if (it == end) [[unlikely]] {
  390|       |                     ctx.error = error_code::unexpected_end;
  391|       |                     return;
  392|       |                  }
  393|       |               }
  394|       |               if (parse_ws_colon<Opts>(ctx, it, end)) {
  395|       |                  return;
  396|       |               }
  397|       |               parse<JSON>::handle_unknown<Opts>(key, value, ctx, it, end);
  398|       |               return;
  399|       |            }
  400|       |         }
  401|       |
  402|       |         if constexpr (not Opts.null_terminated) {
  403|       |            if (it == end) [[unlikely]] {
  404|       |               ctx.error = error_code::unexpected_end;
  405|       |               return;
  406|       |            }
  407|       |         }
  408|       |         if (skip_ws<Opts>(ctx, it, end)) {
  409|       |            return;
  410|       |         }
  411|       |         if (match_invalid_end<':', Opts>(ctx, it, end)) {
  412|       |            return;
  413|       |         }
  414|       |         if (skip_ws<Opts>(ctx, it, end)) {
  415|       |            return;
  416|       |         }
  417|       |
  418|       |         // Fold expression dispatch - avoids jump table overhead for smaller binary size
  419|       |         auto parse_field = [&]<size_t I>() {
  420|       |            if constexpr (check_skip_null_members_on_read(Opts)) {
  421|       |               if (*it == 'n') {
  422|       |                  ++it;
  423|       |                  if constexpr (not Opts.null_terminated) {
  424|       |                     if (it == end) [[unlikely]] {
  425|       |                        ctx.error = error_code::unexpected_end;
  426|       |                        return;
  427|       |                     }
  428|       |                  }
  429|       |                  match<"ull", Opts>(ctx, it, end);
  430|       |                  if constexpr (Opts.error_on_missing_keys || Opts.partial_read) {
  431|       |                     ((selected_index = I), ...);
  432|       |                  }
  433|       |                  return;
  434|       |               }
  435|       |            }
  436|       |
  437|       |            // Check for operation-specific skipping
  438|       |            if constexpr (meta_has_skip<std::remove_cvref_t<T>>) {
  439|       |               constexpr auto Key = get<I>(reflect<T>::keys);
  440|       |               if constexpr (meta<std::remove_cvref_t<T>>::skip(Key, {glz::operation::parse})) {
  441|       |                  skip_value<JSON>::op<Opts>(ctx, it, end);
  442|       |                  if (bool(ctx.error)) [[unlikely]]
  443|       |                     return;
  444|       |                  if constexpr (Opts.error_on_missing_keys || Opts.partial_read) {
  445|       |                     ((selected_index = I), ...);
  446|       |                  }
  447|       |                  return;
  448|       |               }
  449|       |            }
  450|       |
  451|       |            using V = refl_t<T, I>;
  452|       |            if constexpr (const_value_v<V>) {
  453|       |               if constexpr (check_error_on_const_read(Opts)) {
  454|       |                  ctx.error = error_code::attempt_const_read;
  455|       |               }
  456|       |               else {
  457|       |                  skip_value<JSON>::op<Opts>(ctx, it, end);
  458|       |               }
  459|       |            }
  460|       |            else {
  461|       |               // For linear_search, use Opts directly to avoid duplicate template instantiations
  462|       |               // We've already skipped whitespace before reaching here
  463|       |               if constexpr (glaze_object_t<T>) {
  464|       |                  from<JSON, std::remove_cvref_t<V>>::template op<Opts>(get_member(value, get<I>(reflect<T>::values)),
  465|       |                                                                        ctx, it, end);
  466|       |               }
  467|       |               else {
  468|       |                  from<JSON, std::remove_cvref_t<V>>::template op<Opts>(get_member(value, get<I>(to_tie(value))), ctx,
  469|       |                                                                        it, end);
  470|       |               }
  471|       |            }
  472|       |            if constexpr (Opts.error_on_missing_keys || Opts.partial_read) {
  473|       |               ((selected_index = I), ...);
  474|       |            }
  475|       |         };
  476|       |         [&]<size_t... Is>(std::index_sequence<Is...>) {
  477|       |            (void)(((index == Is ? (parse_field.template operator()<Is>(), true) : false) || ...));
  478|       |         }(std::make_index_sequence<N>{});
  479|       |      }
  480|  44.3k|      else {
  481|       |         // Hash-based lookup
  482|  44.3k|         constexpr auto& HashInfo = hash_info<T>;
  483|  44.3k|         constexpr auto type = HashInfo.type;
  484|  44.3k|         static_assert(bool(type), "invalid hash algorithm");
  485|       |
  486|  44.3k|         const auto index = decode_hash<JSON, T, HashInfo, HashInfo.type>::op(it, end);
  487|       |
  488|  44.3k|         if (index >= N) [[unlikely]] {
  ------------------
  |  Branch (488:14): [True: 31, False: 44.3k]
  ------------------
  489|     31|            if constexpr (Opts.error_on_unknown_keys) {
  490|     31|               ctx.error = error_code::unknown_key;
  491|     31|               return;
  492|       |            }
  493|       |            else {
  494|       |               auto start = it;
  495|       |               skip_string_view(ctx, it, end);
  496|       |               if (bool(ctx.error)) [[unlikely]]
  497|       |                  return;
  498|       |               if (validate_utf8_span<Opts>(ctx, start, it)) [[unlikely]]
  499|       |                  return;
  500|       |               const sv key = {start, size_t(it - start)};
  501|       |               ++it; // skip the quote
  502|       |               if constexpr (not Opts.null_terminated) {
  503|       |                  if (it == end) [[unlikely]] {
  504|       |                     ctx.error = error_code::unexpected_end;
  505|       |                     return;
  506|       |                  }
  507|       |               }
  508|       |               if (parse_ws_colon<Opts>(ctx, it, end)) {
  509|       |                  return;
  510|       |               }
  511|       |               parse<JSON>::handle_unknown<Opts>(key, value, ctx, it, end);
  512|       |               return;
  513|       |            }
  514|     31|         }
  515|       |
  516|       |         if constexpr (N == 2) {
  517|       |            if (index == 0) {
  518|       |               decode_index<Opts, T, 0>(value, ctx, it, end, selected_index...);
  519|       |            }
  520|       |            else {
  521|       |               decode_index<Opts, T, 1>(value, ctx, it, end, selected_index...);
  522|       |            }
  523|       |         }
  524|  44.3k|         else {
  525|  44.3k|            visit<N>([&]<size_t I>() { decode_index<Opts, T, I>(value, ctx, it, end, selected_index...); }, index);
  526|  44.3k|         }
  527|  44.3k|      }
  528|  44.3k|   }
_ZZN3glz16parse_and_invokeITnDaXtlNS_4optsELj10ELb1ELb1ELb1ELb1EEE9my_structRS2_JETkNS_10is_contextERNS_7contextERPKcS8_Qoo14glaze_object_tIT0_E11reflectableIS9_EEEvOT1_OT3_OT4_OT5_DpOT2_ENKUlTnmvE_clILm0EEEDav:
  525|  8.21k|            visit<N>([&]<size_t I>() { decode_index<Opts, T, I>(value, ctx, it, end, selected_index...); }, index);
_ZN3glz12decode_indexITnDaXtlNS_4optsELj10ELb1ELb1ELb1ELb1EEE9my_structLm0ERS2_JETkNS_10is_contextERNS_7contextERPKcS8_Qoo14glaze_object_tIT0_E11reflectableIS9_EEEvOT2_OT4_OT5_OT6_DpOT3_:
  234|  8.21k|   {
  235|  8.21k|      static constexpr auto Key = get<I>(reflect<T>::keys);
  236|  8.21k|      static constexpr auto KeyWithEndQuote = join_v<Key, chars<"\"">>;
  237|  8.21k|      static constexpr auto Length = KeyWithEndQuote.size();
  238|       |
  239|  8.21k|      if (((it + Length) < end) && comparitor<KeyWithEndQuote>(it)) [[likely]] {
  ------------------
  |  Branch (239:11): [True: 8.21k, False: 4]
  |  Branch (239:36): [True: 8.20k, False: 12]
  ------------------
  240|  8.20k|         it += Length;
  241|       |         if constexpr (not Opts.null_terminated) {
  242|       |            if (it == end) [[unlikely]] {
  243|       |               ctx.error = error_code::unexpected_end;
  244|       |               return;
  245|       |            }
  246|       |         }
  247|       |
  248|  8.20k|         if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (248:14): [True: 17, False: 8.18k]
  ------------------
  249|     17|            return;
  250|     17|         }
  251|  8.18k|         if (match_invalid_end<':', Opts>(ctx, it, end)) {
  ------------------
  |  Branch (251:14): [True: 100, False: 8.08k]
  ------------------
  252|    100|            return;
  253|    100|         }
  254|  8.08k|         if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (254:14): [True: 13, False: 8.07k]
  ------------------
  255|     13|            return;
  256|     13|         }
  257|       |
  258|       |         // Check for null value skipping on read
  259|       |         if constexpr (check_skip_null_members_on_read(Opts)) {
  260|       |            if (*it == 'n') {
  261|       |               ++it;
  262|       |               if constexpr (not Opts.null_terminated) {
  263|       |                  if (it == end) [[unlikely]] {
  264|       |                     ctx.error = error_code::unexpected_end;
  265|       |                     return;
  266|       |                  }
  267|       |               }
  268|       |               match<"ull", Opts>(ctx, it, end);
  269|       |               if (bool(ctx.error)) [[unlikely]]
  270|       |                  return;
  271|       |               // Successfully matched "null", skip it
  272|       |               if constexpr (Opts.error_on_missing_keys || Opts.partial_read) {
  273|       |                  ((selected_index = I), ...); // Mark as handled even if skipped
  274|       |               }
  275|       |               return;
  276|       |            }
  277|       |         }
  278|       |
  279|       |         // Check for operation-specific skipping
  280|       |         if constexpr (meta_has_skip<std::remove_cvref_t<T>>) {
  281|       |            if constexpr (meta<std::remove_cvref_t<T>>::skip(Key, {glz::operation::parse})) {
  282|       |               skip_value<JSON>::op<Opts>(ctx, it, end);
  283|       |               if (bool(ctx.error)) [[unlikely]]
  284|       |                  return; // Propagate error from skip_value
  285|       |               if constexpr (Opts.error_on_missing_keys || Opts.partial_read) {
  286|       |                  ((selected_index = I), ...); // Mark as handled even if skipped
  287|       |               }
  288|       |               return;
  289|       |            }
  290|       |         }
  291|       |
  292|  8.07k|         using V = refl_t<T, I>;
  293|       |
  294|       |         if constexpr (const_value_v<V>) {
  295|       |            if constexpr (check_error_on_const_read(Opts)) {
  296|       |               ctx.error = error_code::attempt_const_read;
  297|       |            }
  298|       |            else {
  299|       |               // do not read anything into the const value
  300|       |               skip_value<JSON>::op<Opts>(ctx, it, end);
  301|       |            }
  302|       |         }
  303|       |         else if constexpr (is_function_ptr_or_ref<V>) {
  304|       |            // Function pointers cannot be deserialized from JSON.
  305|       |            // When write_function_pointers is enabled the writer emits a type-name string,
  306|       |            // but there is nothing meaningful to reconstruct on read — just skip the value.
  307|       |            // When write_function_pointers is off the key is never written, so this branch
  308|       |            // is unreachable in that case.
  309|       |            skip_value<JSON>::op<Opts>(ctx, it, end);
  310|       |         }
  311|  8.07k|         else {
  312|       |            if constexpr (glaze_object_t<T>) {
  313|       |               from<JSON, std::remove_cvref_t<V>>::template op<ws_handled<Opts>()>(
  314|       |                  get_member(value, get<I>(reflect<T>::values)), ctx, it, end);
  315|       |            }
  316|  8.07k|            else {
  317|  8.07k|               from<JSON, std::remove_cvref_t<V>>::template op<ws_handled<Opts>()>(
  318|  8.07k|                  get_member(value, get<I>(to_tie(value))), ctx, it, end);
  319|  8.07k|            }
  320|  8.07k|         }
  321|       |
  322|       |         if constexpr (Opts.error_on_missing_keys || Opts.partial_read) {
  323|       |            ((selected_index = I), ...);
  324|       |         }
  325|  8.07k|      }
  326|     16|      else [[unlikely]] {
  327|     16|         decode_index_unknown_key<Opts, T>(value, ctx, it, end);
  328|     16|      }
  329|  8.21k|   }
_ZN3glz4fromILj10EiE2opITnDaXtlNS_4optsELj10ELb1ELb1ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEERPKcRiTkNS_10is_contextERNS_7contextES5_EEvOT1_OT2_OT0_T3_:
  808|  8.07k|      {
  809|       |         if constexpr (check_quoted_num(Opts)) {
  810|       |            if (skip_ws<Opts>(ctx, it, end)) {
  811|       |               return;
  812|       |            }
  813|       |            if (match_invalid_end<'"', Opts>(ctx, it, end)) {
  814|       |               return;
  815|       |            }
  816|       |         }
  817|       |
  818|       |         if constexpr (!check_ws_handled(Opts)) {
  819|       |            if (skip_ws<Opts>(ctx, it, end)) {
  820|       |               return;
  821|       |            }
  822|       |         }
  823|       |
  824|  8.07k|         using V = std::decay_t<decltype(value)>;
  825|  8.07k|         if constexpr (int_t<V>) {
  826|  8.07k|            static_assert(sizeof(*it) == sizeof(char));
  827|       |
  828|  8.07k|            if constexpr (Opts.null_terminated) {
  829|  8.07k|               if (not glz::atoi(value, it)) [[unlikely]] {
  ------------------
  |  Branch (829:20): [True: 345, False: 7.72k]
  ------------------
  830|    345|                  ctx.error = error_code::parse_number_failure;
  831|    345|                  return;
  832|    345|               }
  833|       |            }
  834|       |            else {
  835|       |               if (not glz::atoi(value, it, end)) [[unlikely]] {
  836|       |                  ctx.error = error_code::parse_number_failure;
  837|       |                  return;
  838|       |               }
  839|       |            }
  840|       |         }
  841|       |         else {
  842|       |// float128_t requires std::from_chars for floating-point, unavailable on older Apple platforms (iOS < 16.3)
  843|       |#if !defined(_LIBCPP_VERSION) || defined(_LIBCPP_AVAILABILITY_HAS_TO_CHARS_FLOATING_POINT)
  844|       |            if constexpr (is_float128<V>) {
  845|       |               auto [ptr, ec] = std::from_chars(it, end, value);
  846|       |               if (ec != std::errc()) {
  847|       |                  ctx.error = error_code::parse_number_failure;
  848|       |                  return;
  849|       |               }
  850|       |               it = ptr;
  851|       |            }
  852|       |            else
  853|       |#endif
  854|       |            {
  855|       |               if constexpr (std::is_volatile_v<std::remove_reference_t<decltype(value)>>) {
  856|       |                  // Hardware may interact with value changes, so we parse into a temporary and assign in one
  857|       |                  // place
  858|       |                  V temp;
  859|       |                  if constexpr (is_size_optimized(Opts)) {
  860|       |                     auto [ptr, ec] = simple_float::from_chars<Opts.null_terminated>(it, end, temp);
  861|       |                     if (ec != std::errc{}) [[unlikely]] {
  862|       |                        ctx.error = error_code::parse_number_failure;
  863|       |                        return;
  864|       |                     }
  865|       |                     it = ptr;
  866|       |                  }
  867|       |                  else {
  868|       |                     auto [ptr, ec] = glz::from_chars<Opts.null_terminated>(it, end, temp);
  869|       |                     if (ec != std::errc()) [[unlikely]] {
  870|       |                        ctx.error = error_code::parse_number_failure;
  871|       |                        return;
  872|       |                     }
  873|       |                     it = ptr;
  874|       |                  }
  875|       |                  value = temp;
  876|       |               }
  877|       |               else {
  878|       |                  if constexpr (is_size_optimized(Opts)) {
  879|       |                     auto [ptr, ec] = simple_float::from_chars<Opts.null_terminated>(it, end, value);
  880|       |                     if (ec != std::errc{}) [[unlikely]] {
  881|       |                        ctx.error = error_code::parse_number_failure;
  882|       |                        return;
  883|       |                     }
  884|       |                     it = ptr;
  885|       |                  }
  886|       |                  else {
  887|       |                     auto [ptr, ec] = glz::from_chars<Opts.null_terminated>(it, end, value);
  888|       |                     if (ec != std::errc()) [[unlikely]] {
  889|       |                        ctx.error = error_code::parse_number_failure;
  890|       |                        return;
  891|       |                     }
  892|       |                     it = ptr;
  893|       |                  }
  894|       |               }
  895|       |            }
  896|       |         }
  897|       |
  898|       |         if constexpr (check_quoted_num(Opts)) {
  899|       |            if constexpr (not Opts.null_terminated) {
  900|       |               if (it == end) [[unlikely]] {
  901|       |                  ctx.error = error_code::unexpected_end;
  902|       |                  return;
  903|       |               }
  904|       |            }
  905|       |            if (match<'"'>(ctx, it)) {
  906|       |               return;
  907|       |            }
  908|       |            if constexpr (not Opts.null_terminated) {
  909|       |               if (it == end) {
  910|       |                  ctx.error = error_code::end_reached;
  911|       |                  return;
  912|       |               }
  913|       |            }
  914|       |         }
  915|  8.07k|         else {
  916|       |            if constexpr (not Opts.null_terminated) {
  917|       |               if (it == end) {
  918|       |                  ctx.error = error_code::end_reached;
  919|       |                  return;
  920|       |               }
  921|       |            }
  922|  8.07k|         }
  923|  8.07k|      }
_ZN3glz24decode_index_unknown_keyITnDaXtlNS_4optsELj10ELb1ELb1ELb1ELb1EEE9my_structRS2_TkNS_10is_contextERNS_7contextERPKcS7_Qoo14glaze_object_tIT0_E11reflectableIS9_EEEvOT1_OT2_OT3_T4_:
  177|    120|   {
  178|    120|      if constexpr (Opts.error_on_unknown_keys) {
  179|    120|         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|    120|   }
_ZZN3glz16parse_and_invokeITnDaXtlNS_4optsELj10ELb1ELb1ELb1ELb1EEE9my_structRS2_JETkNS_10is_contextERNS_7contextERPKcS8_Qoo14glaze_object_tIT0_E11reflectableIS9_EEEvOT1_OT3_OT4_OT5_DpOT2_ENKUlTnmvE_clILm1EEEDav:
  525|  23.3k|            visit<N>([&]<size_t I>() { decode_index<Opts, T, I>(value, ctx, it, end, selected_index...); }, index);
_ZN3glz12decode_indexITnDaXtlNS_4optsELj10ELb1ELb1ELb1ELb1EEE9my_structLm1ERS2_JETkNS_10is_contextERNS_7contextERPKcS8_Qoo14glaze_object_tIT0_E11reflectableIS9_EEEvOT2_OT4_OT5_OT6_DpOT3_:
  234|  23.3k|   {
  235|  23.3k|      static constexpr auto Key = get<I>(reflect<T>::keys);
  236|  23.3k|      static constexpr auto KeyWithEndQuote = join_v<Key, chars<"\"">>;
  237|  23.3k|      static constexpr auto Length = KeyWithEndQuote.size();
  238|       |
  239|  23.3k|      if (((it + Length) < end) && comparitor<KeyWithEndQuote>(it)) [[likely]] {
  ------------------
  |  Branch (239:11): [True: 23.3k, False: 4]
  |  Branch (239:36): [True: 23.3k, False: 21]
  ------------------
  240|  23.3k|         it += Length;
  241|       |         if constexpr (not Opts.null_terminated) {
  242|       |            if (it == end) [[unlikely]] {
  243|       |               ctx.error = error_code::unexpected_end;
  244|       |               return;
  245|       |            }
  246|       |         }
  247|       |
  248|  23.3k|         if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (248:14): [True: 11, False: 23.3k]
  ------------------
  249|     11|            return;
  250|     11|         }
  251|  23.3k|         if (match_invalid_end<':', Opts>(ctx, it, end)) {
  ------------------
  |  Branch (251:14): [True: 108, False: 23.2k]
  ------------------
  252|    108|            return;
  253|    108|         }
  254|  23.2k|         if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (254:14): [True: 12, False: 23.1k]
  ------------------
  255|     12|            return;
  256|     12|         }
  257|       |
  258|       |         // Check for null value skipping on read
  259|       |         if constexpr (check_skip_null_members_on_read(Opts)) {
  260|       |            if (*it == 'n') {
  261|       |               ++it;
  262|       |               if constexpr (not Opts.null_terminated) {
  263|       |                  if (it == end) [[unlikely]] {
  264|       |                     ctx.error = error_code::unexpected_end;
  265|       |                     return;
  266|       |                  }
  267|       |               }
  268|       |               match<"ull", Opts>(ctx, it, end);
  269|       |               if (bool(ctx.error)) [[unlikely]]
  270|       |                  return;
  271|       |               // Successfully matched "null", skip it
  272|       |               if constexpr (Opts.error_on_missing_keys || Opts.partial_read) {
  273|       |                  ((selected_index = I), ...); // Mark as handled even if skipped
  274|       |               }
  275|       |               return;
  276|       |            }
  277|       |         }
  278|       |
  279|       |         // Check for operation-specific skipping
  280|       |         if constexpr (meta_has_skip<std::remove_cvref_t<T>>) {
  281|       |            if constexpr (meta<std::remove_cvref_t<T>>::skip(Key, {glz::operation::parse})) {
  282|       |               skip_value<JSON>::op<Opts>(ctx, it, end);
  283|       |               if (bool(ctx.error)) [[unlikely]]
  284|       |                  return; // Propagate error from skip_value
  285|       |               if constexpr (Opts.error_on_missing_keys || Opts.partial_read) {
  286|       |                  ((selected_index = I), ...); // Mark as handled even if skipped
  287|       |               }
  288|       |               return;
  289|       |            }
  290|       |         }
  291|       |
  292|  23.1k|         using V = refl_t<T, I>;
  293|       |
  294|       |         if constexpr (const_value_v<V>) {
  295|       |            if constexpr (check_error_on_const_read(Opts)) {
  296|       |               ctx.error = error_code::attempt_const_read;
  297|       |            }
  298|       |            else {
  299|       |               // do not read anything into the const value
  300|       |               skip_value<JSON>::op<Opts>(ctx, it, end);
  301|       |            }
  302|       |         }
  303|       |         else if constexpr (is_function_ptr_or_ref<V>) {
  304|       |            // Function pointers cannot be deserialized from JSON.
  305|       |            // When write_function_pointers is enabled the writer emits a type-name string,
  306|       |            // but there is nothing meaningful to reconstruct on read — just skip the value.
  307|       |            // When write_function_pointers is off the key is never written, so this branch
  308|       |            // is unreachable in that case.
  309|       |            skip_value<JSON>::op<Opts>(ctx, it, end);
  310|       |         }
  311|  23.1k|         else {
  312|       |            if constexpr (glaze_object_t<T>) {
  313|       |               from<JSON, std::remove_cvref_t<V>>::template op<ws_handled<Opts>()>(
  314|       |                  get_member(value, get<I>(reflect<T>::values)), ctx, it, end);
  315|       |            }
  316|  23.1k|            else {
  317|  23.1k|               from<JSON, std::remove_cvref_t<V>>::template op<ws_handled<Opts>()>(
  318|  23.1k|                  get_member(value, get<I>(to_tie(value))), ctx, it, end);
  319|  23.1k|            }
  320|  23.1k|         }
  321|       |
  322|       |         if constexpr (Opts.error_on_missing_keys || Opts.partial_read) {
  323|       |            ((selected_index = I), ...);
  324|       |         }
  325|  23.1k|      }
  326|     25|      else [[unlikely]] {
  327|     25|         decode_index_unknown_key<Opts, T>(value, ctx, it, end);
  328|     25|      }
  329|  23.3k|   }
_ZN3glz4fromILj10EdE2opITnDaXtlNS_4optsELj10ELb1ELb1ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEERPKcRdTkNS_10is_contextERNS_7contextES5_EEvOT1_OT2_OT0_T3_:
  808|  23.1k|      {
  809|       |         if constexpr (check_quoted_num(Opts)) {
  810|       |            if (skip_ws<Opts>(ctx, it, end)) {
  811|       |               return;
  812|       |            }
  813|       |            if (match_invalid_end<'"', Opts>(ctx, it, end)) {
  814|       |               return;
  815|       |            }
  816|       |         }
  817|       |
  818|       |         if constexpr (!check_ws_handled(Opts)) {
  819|       |            if (skip_ws<Opts>(ctx, it, end)) {
  820|       |               return;
  821|       |            }
  822|       |         }
  823|       |
  824|  23.1k|         using V = std::decay_t<decltype(value)>;
  825|       |         if constexpr (int_t<V>) {
  826|       |            static_assert(sizeof(*it) == sizeof(char));
  827|       |
  828|       |            if constexpr (Opts.null_terminated) {
  829|       |               if (not glz::atoi(value, it)) [[unlikely]] {
  830|       |                  ctx.error = error_code::parse_number_failure;
  831|       |                  return;
  832|       |               }
  833|       |            }
  834|       |            else {
  835|       |               if (not glz::atoi(value, it, end)) [[unlikely]] {
  836|       |                  ctx.error = error_code::parse_number_failure;
  837|       |                  return;
  838|       |               }
  839|       |            }
  840|       |         }
  841|  23.1k|         else {
  842|       |// float128_t requires std::from_chars for floating-point, unavailable on older Apple platforms (iOS < 16.3)
  843|  23.1k|#if !defined(_LIBCPP_VERSION) || defined(_LIBCPP_AVAILABILITY_HAS_TO_CHARS_FLOATING_POINT)
  844|       |            if constexpr (is_float128<V>) {
  845|       |               auto [ptr, ec] = std::from_chars(it, end, value);
  846|       |               if (ec != std::errc()) {
  847|       |                  ctx.error = error_code::parse_number_failure;
  848|       |                  return;
  849|       |               }
  850|       |               it = ptr;
  851|       |            }
  852|       |            else
  853|       |#endif
  854|  23.1k|            {
  855|       |               if constexpr (std::is_volatile_v<std::remove_reference_t<decltype(value)>>) {
  856|       |                  // Hardware may interact with value changes, so we parse into a temporary and assign in one
  857|       |                  // place
  858|       |                  V temp;
  859|       |                  if constexpr (is_size_optimized(Opts)) {
  860|       |                     auto [ptr, ec] = simple_float::from_chars<Opts.null_terminated>(it, end, temp);
  861|       |                     if (ec != std::errc{}) [[unlikely]] {
  862|       |                        ctx.error = error_code::parse_number_failure;
  863|       |                        return;
  864|       |                     }
  865|       |                     it = ptr;
  866|       |                  }
  867|       |                  else {
  868|       |                     auto [ptr, ec] = glz::from_chars<Opts.null_terminated>(it, end, temp);
  869|       |                     if (ec != std::errc()) [[unlikely]] {
  870|       |                        ctx.error = error_code::parse_number_failure;
  871|       |                        return;
  872|       |                     }
  873|       |                     it = ptr;
  874|       |                  }
  875|       |                  value = temp;
  876|       |               }
  877|  23.1k|               else {
  878|       |                  if constexpr (is_size_optimized(Opts)) {
  879|       |                     auto [ptr, ec] = simple_float::from_chars<Opts.null_terminated>(it, end, value);
  880|       |                     if (ec != std::errc{}) [[unlikely]] {
  881|       |                        ctx.error = error_code::parse_number_failure;
  882|       |                        return;
  883|       |                     }
  884|       |                     it = ptr;
  885|       |                  }
  886|  23.1k|                  else {
  887|  23.1k|                     auto [ptr, ec] = glz::from_chars<Opts.null_terminated>(it, end, value);
  888|  23.1k|                     if (ec != std::errc()) [[unlikely]] {
  ------------------
  |  Branch (888:26): [True: 374, False: 22.8k]
  ------------------
  889|    374|                        ctx.error = error_code::parse_number_failure;
  890|    374|                        return;
  891|    374|                     }
  892|  22.8k|                     it = ptr;
  893|  22.8k|                  }
  894|  23.1k|               }
  895|  23.1k|            }
  896|  23.1k|         }
  897|       |
  898|       |         if constexpr (check_quoted_num(Opts)) {
  899|       |            if constexpr (not Opts.null_terminated) {
  900|       |               if (it == end) [[unlikely]] {
  901|       |                  ctx.error = error_code::unexpected_end;
  902|       |                  return;
  903|       |               }
  904|       |            }
  905|       |            if (match<'"'>(ctx, it)) {
  906|       |               return;
  907|       |            }
  908|       |            if constexpr (not Opts.null_terminated) {
  909|       |               if (it == end) {
  910|       |                  ctx.error = error_code::end_reached;
  911|       |                  return;
  912|       |               }
  913|       |            }
  914|       |         }
  915|  23.1k|         else {
  916|       |            if constexpr (not Opts.null_terminated) {
  917|       |               if (it == end) {
  918|       |                  ctx.error = error_code::end_reached;
  919|       |                  return;
  920|       |               }
  921|       |            }
  922|  23.1k|         }
  923|  23.1k|      }
_ZZN3glz16parse_and_invokeITnDaXtlNS_4optsELj10ELb1ELb1ELb1ELb1EEE9my_structRS2_JETkNS_10is_contextERNS_7contextERPKcS8_Qoo14glaze_object_tIT0_E11reflectableIS9_EEEvOT1_OT3_OT4_OT5_DpOT2_ENKUlTnmvE_clILm2EEEDav:
  525|  5.33k|            visit<N>([&]<size_t I>() { decode_index<Opts, T, I>(value, ctx, it, end, selected_index...); }, index);
_ZN3glz12decode_indexITnDaXtlNS_4optsELj10ELb1ELb1ELb1ELb1EEE9my_structLm2ERS2_JETkNS_10is_contextERNS_7contextERPKcS8_Qoo14glaze_object_tIT0_E11reflectableIS9_EEEvOT2_OT4_OT5_OT6_DpOT3_:
  234|  5.33k|   {
  235|  5.33k|      static constexpr auto Key = get<I>(reflect<T>::keys);
  236|  5.33k|      static constexpr auto KeyWithEndQuote = join_v<Key, chars<"\"">>;
  237|  5.33k|      static constexpr auto Length = KeyWithEndQuote.size();
  238|       |
  239|  5.33k|      if (((it + Length) < end) && comparitor<KeyWithEndQuote>(it)) [[likely]] {
  ------------------
  |  Branch (239:11): [True: 5.30k, False: 31]
  |  Branch (239:36): [True: 5.29k, False: 5]
  ------------------
  240|  5.29k|         it += Length;
  241|       |         if constexpr (not Opts.null_terminated) {
  242|       |            if (it == end) [[unlikely]] {
  243|       |               ctx.error = error_code::unexpected_end;
  244|       |               return;
  245|       |            }
  246|       |         }
  247|       |
  248|  5.29k|         if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (248:14): [True: 10, False: 5.28k]
  ------------------
  249|     10|            return;
  250|     10|         }
  251|  5.28k|         if (match_invalid_end<':', Opts>(ctx, it, end)) {
  ------------------
  |  Branch (251:14): [True: 99, False: 5.18k]
  ------------------
  252|     99|            return;
  253|     99|         }
  254|  5.18k|         if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (254:14): [True: 16, False: 5.17k]
  ------------------
  255|     16|            return;
  256|     16|         }
  257|       |
  258|       |         // Check for null value skipping on read
  259|       |         if constexpr (check_skip_null_members_on_read(Opts)) {
  260|       |            if (*it == 'n') {
  261|       |               ++it;
  262|       |               if constexpr (not Opts.null_terminated) {
  263|       |                  if (it == end) [[unlikely]] {
  264|       |                     ctx.error = error_code::unexpected_end;
  265|       |                     return;
  266|       |                  }
  267|       |               }
  268|       |               match<"ull", Opts>(ctx, it, end);
  269|       |               if (bool(ctx.error)) [[unlikely]]
  270|       |                  return;
  271|       |               // Successfully matched "null", skip it
  272|       |               if constexpr (Opts.error_on_missing_keys || Opts.partial_read) {
  273|       |                  ((selected_index = I), ...); // Mark as handled even if skipped
  274|       |               }
  275|       |               return;
  276|       |            }
  277|       |         }
  278|       |
  279|       |         // Check for operation-specific skipping
  280|       |         if constexpr (meta_has_skip<std::remove_cvref_t<T>>) {
  281|       |            if constexpr (meta<std::remove_cvref_t<T>>::skip(Key, {glz::operation::parse})) {
  282|       |               skip_value<JSON>::op<Opts>(ctx, it, end);
  283|       |               if (bool(ctx.error)) [[unlikely]]
  284|       |                  return; // Propagate error from skip_value
  285|       |               if constexpr (Opts.error_on_missing_keys || Opts.partial_read) {
  286|       |                  ((selected_index = I), ...); // Mark as handled even if skipped
  287|       |               }
  288|       |               return;
  289|       |            }
  290|       |         }
  291|       |
  292|  5.17k|         using V = refl_t<T, I>;
  293|       |
  294|       |         if constexpr (const_value_v<V>) {
  295|       |            if constexpr (check_error_on_const_read(Opts)) {
  296|       |               ctx.error = error_code::attempt_const_read;
  297|       |            }
  298|       |            else {
  299|       |               // do not read anything into the const value
  300|       |               skip_value<JSON>::op<Opts>(ctx, it, end);
  301|       |            }
  302|       |         }
  303|       |         else if constexpr (is_function_ptr_or_ref<V>) {
  304|       |            // Function pointers cannot be deserialized from JSON.
  305|       |            // When write_function_pointers is enabled the writer emits a type-name string,
  306|       |            // but there is nothing meaningful to reconstruct on read — just skip the value.
  307|       |            // When write_function_pointers is off the key is never written, so this branch
  308|       |            // is unreachable in that case.
  309|       |            skip_value<JSON>::op<Opts>(ctx, it, end);
  310|       |         }
  311|  5.17k|         else {
  312|       |            if constexpr (glaze_object_t<T>) {
  313|       |               from<JSON, std::remove_cvref_t<V>>::template op<ws_handled<Opts>()>(
  314|       |                  get_member(value, get<I>(reflect<T>::values)), ctx, it, end);
  315|       |            }
  316|  5.17k|            else {
  317|  5.17k|               from<JSON, std::remove_cvref_t<V>>::template op<ws_handled<Opts>()>(
  318|  5.17k|                  get_member(value, get<I>(to_tie(value))), ctx, it, end);
  319|  5.17k|            }
  320|  5.17k|         }
  321|       |
  322|       |         if constexpr (Opts.error_on_missing_keys || Opts.partial_read) {
  323|       |            ((selected_index = I), ...);
  324|       |         }
  325|  5.17k|      }
  326|     36|      else [[unlikely]] {
  327|     36|         decode_index_unknown_key<Opts, T>(value, ctx, it, end);
  328|     36|      }
  329|  5.33k|   }
_ZN3glz4fromILj10ENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE2opITnDaXtlNS_4optsELj10ELb1ELb1ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEERPKcSC_S7_TkNS_10is_contextERNS_7contextEQntcl15check_is_paddedTL0__EEEvRT2_OT3_OT0_T1_:
 1084|  5.17k|      {
 1085|       |         if constexpr (check_string_as_number(Opts)) {
 1086|       |            auto start = it;
 1087|       |            skip_number<Opts>(ctx, it, end);
 1088|       |            if (bool(ctx.error)) [[unlikely]] {
 1089|       |               return;
 1090|       |            }
 1091|       |            if (start == it) [[unlikely]] {
 1092|       |               ctx.error = error_code::parse_number_failure;
 1093|       |               return;
 1094|       |            }
 1095|       |            value.append(start, size_t(it - start));
 1096|       |         }
 1097|  5.17k|         else {
 1098|  5.17k|            if constexpr (!check_opening_handled(Opts)) {
 1099|       |               if constexpr (!check_ws_handled(Opts)) {
 1100|       |                  if (skip_ws<Opts>(ctx, it, end)) {
 1101|       |                     return;
 1102|       |                  }
 1103|       |               }
 1104|       |
 1105|  5.17k|               if (match_invalid_end<'"', Opts>(ctx, it, end)) {
  ------------------
  |  Branch (1105:20): [True: 97, False: 5.07k]
  ------------------
 1106|     97|                  return;
 1107|     97|               }
 1108|  5.17k|            }
 1109|       |
 1110|  5.17k|            if constexpr (not check_raw_string(Opts)) {
 1111|  5.17k|               static constexpr auto string_padding_bytes = 8;
 1112|       |
 1113|  5.17k|               if (size_t(end - it) >= 8) {
  ------------------
  |  Branch (1113:20): [True: 4.85k, False: 320]
  ------------------
 1114|  4.85k|                  auto start = it;
 1115|  4.85k|                  uint64_t ascii_acc{};
 1116|  4.85k|                  const auto end8 = end - 8;
 1117|  1.50M|                  while (true) {
  ------------------
  |  Branch (1117:26): [True: 1.50M, Folded]
  ------------------
 1118|  1.50M|                     if (it >= end8) [[unlikely]] {
  ------------------
  |  Branch (1118:26): [True: 399, False: 1.50M]
  ------------------
 1119|    399|                        break;
 1120|    399|                     }
 1121|       |
 1122|  1.50M|                     uint64_t chunk;
 1123|  1.50M|                     std::memcpy(&chunk, it, 8);
 1124|       |                     if constexpr (std::endian::native == std::endian::big) {
 1125|       |                        chunk = std::byteswap(chunk);
 1126|       |                     }
 1127|  1.50M|                     ascii_acc |= chunk;
 1128|  1.50M|                     const uint64_t test_chars = has_quote(chunk);
 1129|  1.50M|                     if (test_chars) {
  ------------------
  |  Branch (1129:26): [True: 5.17k, False: 1.49M]
  ------------------
 1130|  5.17k|                        it += (countr_zero(test_chars) >> 3);
 1131|       |
 1132|  5.17k|                        auto* prev = it - 1;
 1133|  6.85k|                        while (*prev == '\\') {
  ------------------
  |  Branch (1133:32): [True: 1.68k, False: 5.17k]
  ------------------
 1134|  1.68k|                           --prev;
 1135|  1.68k|                        }
 1136|  5.17k|                        if (size_t(it - prev) % 2) {
  ------------------
  |  Branch (1136:29): [True: 4.45k, False: 721]
  ------------------
 1137|  4.45k|                           goto continue_decode;
 1138|  4.45k|                        }
 1139|    721|                        ++it; // skip the escaped quote
 1140|    721|                     }
 1141|  1.49M|                     else {
 1142|  1.49M|                        it += 8;
 1143|  1.49M|                     }
 1144|  1.50M|                  }
 1145|       |
 1146|  1.66k|                  while (it[-1] == '\\') [[unlikely]] {
  ------------------
  |  Branch (1146:26): [True: 1.27k, False: 399]
  ------------------
 1147|       |                     // if we ended on an escape character then we need to rewind
 1148|       |                     // because we lost our context
 1149|  1.27k|                     --it;
 1150|  1.27k|                  }
 1151|       |
 1152|       |                  // The byte-wise tail keeps feeding the accumulator: it has to cover every byte of
 1153|       |                  // the string, or a non-ASCII byte reached here would be waved through unvalidated.
 1154|  3.00k|                  for (; it < end; ++it) {
  ------------------
  |  Branch (1154:26): [True: 2.99k, False: 16]
  ------------------
 1155|  2.99k|                     ascii_acc |= uint8_t(*it);
 1156|  2.99k|                     if (*it == '"') {
  ------------------
  |  Branch (1156:26): [True: 405, False: 2.58k]
  ------------------
 1157|    405|                        auto* prev = it - 1;
 1158|  1.34k|                        while (*prev == '\\') {
  ------------------
  |  Branch (1158:32): [True: 942, False: 405]
  ------------------
 1159|    942|                           --prev;
 1160|    942|                        }
 1161|    405|                        if (size_t(it - prev) % 2) {
  ------------------
  |  Branch (1161:29): [True: 383, False: 22]
  ------------------
 1162|    383|                           goto continue_decode;
 1163|    383|                        }
 1164|    405|                     }
 1165|  2.99k|                  }
 1166|       |
 1167|     16|                  ctx.error = error_code::unexpected_end;
 1168|     16|                  return;
 1169|       |
 1170|  4.83k|               continue_decode:
 1171|       |
 1172|  4.83k|                  if (validate_utf8_span<Opts>(ctx, start, it, ascii_acc)) [[unlikely]] {
  ------------------
  |  Branch (1172:23): [True: 112, False: 4.72k]
  ------------------
 1173|    112|                     return;
 1174|    112|                  }
 1175|       |
 1176|  4.72k|                  const auto available_padding = size_t(end - it);
 1177|  4.72k|                  auto n = size_t(it - start);
 1178|  4.72k|                  if (available_padding >= 8) [[likely]] {
  ------------------
  |  Branch (1178:23): [True: 4.48k, False: 238]
  ------------------
 1179|  4.48k|                     value.resize(n + string_padding_bytes);
 1180|       |
 1181|  4.48k|                     auto* p = value.data();
 1182|       |
 1183|   927k|                     while (true) {
  ------------------
  |  Branch (1183:29): [True: 927k, Folded]
  ------------------
 1184|   927k|                        if (start >= it) {
  ------------------
  |  Branch (1184:29): [True: 3.96k, False: 923k]
  ------------------
 1185|  3.96k|                           break;
 1186|  3.96k|                        }
 1187|       |
 1188|   923k|                        std::memcpy(p, start, 8);
 1189|   923k|                        uint64_t swar;
 1190|   923k|                        std::memcpy(&swar, p, 8);
 1191|       |                        if constexpr (std::endian::native == std::endian::big) {
 1192|       |                           swar = std::byteswap(swar);
 1193|       |                        }
 1194|       |
 1195|   923k|                        constexpr uint64_t lo7_mask = repeat_byte8(0b01111111);
 1196|   923k|                        const uint64_t lo7 = swar & lo7_mask;
 1197|   923k|                        const uint64_t backslash = (lo7 ^ repeat_byte8('\\')) + lo7_mask;
 1198|   923k|                        const uint64_t less_32 = (swar & repeat_byte8(0b01100000)) + lo7_mask;
 1199|   923k|                        uint64_t next = ~((backslash & less_32) | swar);
 1200|       |
 1201|   923k|                        next &= repeat_byte8(0b10000000);
 1202|   923k|                        if (next == 0) {
  ------------------
  |  Branch (1202:29): [True: 921k, False: 2.12k]
  ------------------
 1203|   921k|                           start += 8;
 1204|   921k|                           p += 8;
 1205|   921k|                           continue;
 1206|   921k|                        }
 1207|       |
 1208|  2.12k|                        next = countr_zero(next) >> 3;
 1209|  2.12k|                        start += next;
 1210|  2.12k|                        if (start >= it) {
  ------------------
  |  Branch (1210:29): [True: 452, False: 1.67k]
  ------------------
 1211|    452|                           break;
 1212|    452|                        }
 1213|       |
 1214|  1.67k|                        if ((*start & 0b11100000) == 0) [[unlikely]] {
  ------------------
  |  Branch (1214:29): [True: 20, False: 1.65k]
  ------------------
 1215|     20|                           ctx.error = error_code::syntax_error;
 1216|     20|                           return;
 1217|     20|                        }
 1218|  1.65k|                        ++start; // skip the escape
 1219|  1.65k|                        if (*start == 'u') {
  ------------------
  |  Branch (1219:29): [True: 1.06k, False: 588]
  ------------------
 1220|  1.06k|                           ++start;
 1221|  1.06k|                           p += next;
 1222|  1.06k|                           const auto mark = start;
 1223|  1.06k|                           const auto offset = handle_unicode_code_point(start, p, end);
 1224|  1.06k|                           if (offset == 0) [[unlikely]] {
  ------------------
  |  Branch (1224:32): [True: 38, False: 1.03k]
  ------------------
 1225|     38|                              ctx.error = error_code::unicode_escape_conversion_failure;
 1226|     38|                              return;
 1227|     38|                           }
 1228|  1.03k|                           n += offset;
 1229|       |                           // escape + u + unicode code points
 1230|  1.03k|                           n -= 2 + uint32_t(start - mark);
 1231|  1.03k|                        }
 1232|    588|                        else {
 1233|    588|                           p += next;
 1234|    588|                           *p = char_unescape_table[uint8_t(*start)];
 1235|    588|                           if (*p == 0) [[unlikely]] {
  ------------------
  |  Branch (1235:32): [True: 8, False: 580]
  ------------------
 1236|      8|                              ctx.error = error_code::invalid_escape;
 1237|      8|                              return;
 1238|      8|                           }
 1239|    580|                           ++p;
 1240|    580|                           ++start;
 1241|    580|                           --n;
 1242|    580|                        }
 1243|  1.65k|                     }
 1244|       |
 1245|  4.41k|                     value.resize(n);
 1246|  4.41k|                     ++it;
 1247|  4.41k|                  }
 1248|    238|                  else {
 1249|       |                     // For large inputs this case of running out of buffer is very rare
 1250|    238|                     value.resize(n);
 1251|    238|                     auto* p = value.data();
 1252|       |
 1253|    238|                     it = start;
 1254|  9.14k|                     while (it < end) [[likely]] {
  ------------------
  |  Branch (1254:29): [True: 9.14k, False: 0]
  ------------------
 1255|  9.14k|                        if (*it == '"') {
  ------------------
  |  Branch (1255:29): [True: 152, False: 8.99k]
  ------------------
 1256|    152|                           value.resize(size_t(p - value.data()));
 1257|    152|                           ++it;
 1258|    152|                           return;
 1259|    152|                        }
 1260|       |
 1261|  8.99k|                        if ((*it & 0b11100000) == 0) [[unlikely]] {
  ------------------
  |  Branch (1261:29): [True: 26, False: 8.97k]
  ------------------
 1262|     26|                           ctx.error = error_code::syntax_error;
 1263|     26|                           return;
 1264|     26|                        }
 1265|       |
 1266|  8.97k|                        *p = *it;
 1267|       |
 1268|  8.97k|                        if (*it == '\\') {
  ------------------
  |  Branch (1268:29): [True: 1.67k, False: 7.29k]
  ------------------
 1269|  1.67k|                           ++it; // skip the escape
 1270|  1.67k|                           if (*it == 'u') {
  ------------------
  |  Branch (1270:32): [True: 934, False: 738]
  ------------------
 1271|    934|                              ++it;
 1272|    934|                              if (!handle_unicode_code_point(it, p, end)) [[unlikely]] {
  ------------------
  |  Branch (1272:35): [True: 50, False: 884]
  ------------------
 1273|     50|                                 ctx.error = error_code::unicode_escape_conversion_failure;
 1274|     50|                                 return;
 1275|     50|                              }
 1276|    934|                           }
 1277|    738|                           else {
 1278|    738|                              *p = char_unescape_table[uint8_t(*it)];
 1279|    738|                              if (*p == 0) [[unlikely]] {
  ------------------
  |  Branch (1279:35): [True: 10, False: 728]
  ------------------
 1280|     10|                                 ctx.error = error_code::invalid_escape;
 1281|     10|                                 return;
 1282|     10|                              }
 1283|    728|                              ++p;
 1284|    728|                              ++it;
 1285|    728|                           }
 1286|  1.67k|                        }
 1287|  7.29k|                        else {
 1288|  7.29k|                           ++it;
 1289|  7.29k|                           ++p;
 1290|  7.29k|                        }
 1291|  8.97k|                     }
 1292|       |
 1293|      0|                     ctx.error = error_code::unexpected_end;
 1294|      0|                  }
 1295|  4.72k|               }
 1296|    320|               else {
 1297|       |                  // For short strings
 1298|       |
 1299|    320|                  std::array<char, 8> buffer{};
 1300|       |
 1301|    320|                  auto* p = buffer.data();
 1302|    320|                  const auto* const utf8_start = it;
 1303|       |
 1304|    719|                  while (it < end) [[likely]] {
  ------------------
  |  Branch (1304:26): [True: 584, False: 135]
  ------------------
 1305|    584|                     *p = *it;
 1306|    584|                     if (*it == '"') {
  ------------------
  |  Branch (1306:26): [True: 159, False: 425]
  ------------------
 1307|    159|                        if (validate_utf8_span<Opts>(ctx, utf8_start, it)) [[unlikely]] {
  ------------------
  |  Branch (1307:29): [True: 61, False: 98]
  ------------------
 1308|     61|                           return;
 1309|     61|                        }
 1310|     98|                        const size_t n = size_t(p - buffer.data());
 1311|     98|#if __has_cpp_attribute(assume) >= 202207L
 1312|     98|                        [[assume(n <= sizeof(buffer))]];
 1313|     98|#endif
 1314|     98|                        value.assign(buffer.data(), n);
 1315|     98|                        ++it;
 1316|       |                        if constexpr (not Opts.null_terminated) {
 1317|       |                           if (it == end) {
 1318|       |                              ctx.error = error_code::end_reached;
 1319|       |                              return;
 1320|       |                           }
 1321|       |                        }
 1322|     98|                        return;
 1323|    159|                     }
 1324|    425|                     else if (*it == '\\') {
  ------------------
  |  Branch (1324:31): [True: 61, False: 364]
  ------------------
 1325|     61|                        ++it; // skip the escape
 1326|       |                        if constexpr (not Opts.null_terminated) {
 1327|       |                           if (it == end) [[unlikely]] {
 1328|       |                              ctx.error = error_code::unexpected_end;
 1329|       |                              return;
 1330|       |                           }
 1331|       |                        }
 1332|     61|                        if (*it == 'u') {
  ------------------
  |  Branch (1332:29): [True: 45, False: 16]
  ------------------
 1333|     45|                           ++it;
 1334|       |                           if constexpr (not Opts.null_terminated) {
 1335|       |                              if (it == end) [[unlikely]] {
 1336|       |                                 ctx.error = error_code::unexpected_end;
 1337|       |                                 return;
 1338|       |                              }
 1339|       |                           }
 1340|     45|                           if (!handle_unicode_code_point(it, p, end)) [[unlikely]] {
  ------------------
  |  Branch (1340:32): [True: 9, False: 36]
  ------------------
 1341|      9|                              ctx.error = error_code::unicode_escape_conversion_failure;
 1342|      9|                              return;
 1343|      9|                           }
 1344|     45|                        }
 1345|     16|                        else {
 1346|     16|                           *p = char_unescape_table[uint8_t(*it)];
 1347|     16|                           if (*p == 0) [[unlikely]] {
  ------------------
  |  Branch (1347:32): [True: 3, False: 13]
  ------------------
 1348|      3|                              ctx.error = error_code::invalid_escape;
 1349|      3|                              return;
 1350|      3|                           }
 1351|     13|                           ++p;
 1352|     13|                           ++it;
 1353|     13|                        }
 1354|     61|                     }
 1355|    364|                     else if ((*it & 0b11100000) == 0) [[unlikely]] {
  ------------------
  |  Branch (1355:31): [True: 14, False: 350]
  ------------------
 1356|     14|                        ctx.error = error_code::syntax_error;
 1357|     14|                        return;
 1358|     14|                     }
 1359|    350|                     else {
 1360|    350|                        ++it;
 1361|    350|                        ++p;
 1362|    350|                     }
 1363|    584|                  }
 1364|       |
 1365|    135|                  ctx.error = error_code::unexpected_end;
 1366|    135|               }
 1367|       |            }
 1368|       |            else {
 1369|       |               // raw_string
 1370|       |               auto start = it;
 1371|       |               skip_string_view(ctx, it, end);
 1372|       |               if (bool(ctx.error)) [[unlikely]]
 1373|       |                  return;
 1374|       |
 1375|       |               if (validate_utf8_span<Opts>(ctx, start, it)) [[unlikely]] {
 1376|       |                  return;
 1377|       |               }
 1378|       |
 1379|       |               value.assign(start, size_t(it - start));
 1380|       |               ++it;
 1381|       |            }
 1382|  5.17k|         }
 1383|  5.17k|      }
_ZZN3glz16parse_and_invokeITnDaXtlNS_4optsELj10ELb1ELb1ELb1ELb1EEE9my_structRS2_JETkNS_10is_contextERNS_7contextERPKcS8_Qoo14glaze_object_tIT0_E11reflectableIS9_EEEvOT1_OT3_OT4_OT5_DpOT2_ENKUlTnmvE_clILm3EEEDav:
  525|  7.45k|            visit<N>([&]<size_t I>() { decode_index<Opts, T, I>(value, ctx, it, end, selected_index...); }, index);
_ZN3glz12decode_indexITnDaXtlNS_4optsELj10ELb1ELb1ELb1ELb1EEE9my_structLm3ERS2_JETkNS_10is_contextERNS_7contextERPKcS8_Qoo14glaze_object_tIT0_E11reflectableIS9_EEEvOT2_OT4_OT5_OT6_DpOT3_:
  234|  7.45k|   {
  235|  7.45k|      static constexpr auto Key = get<I>(reflect<T>::keys);
  236|  7.45k|      static constexpr auto KeyWithEndQuote = join_v<Key, chars<"\"">>;
  237|  7.45k|      static constexpr auto Length = KeyWithEndQuote.size();
  238|       |
  239|  7.45k|      if (((it + Length) < end) && comparitor<KeyWithEndQuote>(it)) [[likely]] {
  ------------------
  |  Branch (239:11): [True: 7.44k, False: 6]
  |  Branch (239:36): [True: 7.40k, False: 37]
  ------------------
  240|  7.40k|         it += Length;
  241|       |         if constexpr (not Opts.null_terminated) {
  242|       |            if (it == end) [[unlikely]] {
  243|       |               ctx.error = error_code::unexpected_end;
  244|       |               return;
  245|       |            }
  246|       |         }
  247|       |
  248|  7.40k|         if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (248:14): [True: 12, False: 7.39k]
  ------------------
  249|     12|            return;
  250|     12|         }
  251|  7.39k|         if (match_invalid_end<':', Opts>(ctx, it, end)) {
  ------------------
  |  Branch (251:14): [True: 103, False: 7.29k]
  ------------------
  252|    103|            return;
  253|    103|         }
  254|  7.29k|         if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (254:14): [True: 14, False: 7.27k]
  ------------------
  255|     14|            return;
  256|     14|         }
  257|       |
  258|       |         // Check for null value skipping on read
  259|       |         if constexpr (check_skip_null_members_on_read(Opts)) {
  260|       |            if (*it == 'n') {
  261|       |               ++it;
  262|       |               if constexpr (not Opts.null_terminated) {
  263|       |                  if (it == end) [[unlikely]] {
  264|       |                     ctx.error = error_code::unexpected_end;
  265|       |                     return;
  266|       |                  }
  267|       |               }
  268|       |               match<"ull", Opts>(ctx, it, end);
  269|       |               if (bool(ctx.error)) [[unlikely]]
  270|       |                  return;
  271|       |               // Successfully matched "null", skip it
  272|       |               if constexpr (Opts.error_on_missing_keys || Opts.partial_read) {
  273|       |                  ((selected_index = I), ...); // Mark as handled even if skipped
  274|       |               }
  275|       |               return;
  276|       |            }
  277|       |         }
  278|       |
  279|       |         // Check for operation-specific skipping
  280|       |         if constexpr (meta_has_skip<std::remove_cvref_t<T>>) {
  281|       |            if constexpr (meta<std::remove_cvref_t<T>>::skip(Key, {glz::operation::parse})) {
  282|       |               skip_value<JSON>::op<Opts>(ctx, it, end);
  283|       |               if (bool(ctx.error)) [[unlikely]]
  284|       |                  return; // Propagate error from skip_value
  285|       |               if constexpr (Opts.error_on_missing_keys || Opts.partial_read) {
  286|       |                  ((selected_index = I), ...); // Mark as handled even if skipped
  287|       |               }
  288|       |               return;
  289|       |            }
  290|       |         }
  291|       |
  292|  7.27k|         using V = refl_t<T, I>;
  293|       |
  294|       |         if constexpr (const_value_v<V>) {
  295|       |            if constexpr (check_error_on_const_read(Opts)) {
  296|       |               ctx.error = error_code::attempt_const_read;
  297|       |            }
  298|       |            else {
  299|       |               // do not read anything into the const value
  300|       |               skip_value<JSON>::op<Opts>(ctx, it, end);
  301|       |            }
  302|       |         }
  303|       |         else if constexpr (is_function_ptr_or_ref<V>) {
  304|       |            // Function pointers cannot be deserialized from JSON.
  305|       |            // When write_function_pointers is enabled the writer emits a type-name string,
  306|       |            // but there is nothing meaningful to reconstruct on read — just skip the value.
  307|       |            // When write_function_pointers is off the key is never written, so this branch
  308|       |            // is unreachable in that case.
  309|       |            skip_value<JSON>::op<Opts>(ctx, it, end);
  310|       |         }
  311|  7.27k|         else {
  312|       |            if constexpr (glaze_object_t<T>) {
  313|       |               from<JSON, std::remove_cvref_t<V>>::template op<ws_handled<Opts>()>(
  314|       |                  get_member(value, get<I>(reflect<T>::values)), ctx, it, end);
  315|       |            }
  316|  7.27k|            else {
  317|  7.27k|               from<JSON, std::remove_cvref_t<V>>::template op<ws_handled<Opts>()>(
  318|  7.27k|                  get_member(value, get<I>(to_tie(value))), ctx, it, end);
  319|  7.27k|            }
  320|  7.27k|         }
  321|       |
  322|       |         if constexpr (Opts.error_on_missing_keys || Opts.partial_read) {
  323|       |            ((selected_index = I), ...);
  324|       |         }
  325|  7.27k|      }
  326|     43|      else [[unlikely]] {
  327|     43|         decode_index_unknown_key<Opts, T>(value, ctx, it, end);
  328|     43|      }
  329|  7.45k|   }
_ZN3glz4fromILj10ENSt3__15arrayImLm3EEEE2opITnDaXtlNS_4optsELj10ELb1ELb1ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEERS3_TkNS_10is_contextERNS_7contextERPKcSB_EEvOT0_OT1_OT2_T3_:
 2349|  7.27k|      {
 2350|  7.27k|         constexpr auto Opts = ws_handled_off<Options>();
 2351|       |         if constexpr (!check_ws_handled(Options)) {
 2352|       |            if (skip_ws<Opts>(ctx, it, end)) {
 2353|       |               return;
 2354|       |            }
 2355|       |         }
 2356|       |
 2357|  7.27k|         if (match_invalid_end<'[', Opts>(ctx, it, end)) {
  ------------------
  |  Branch (2357:14): [True: 108, False: 7.17k]
  ------------------
 2358|    108|            return;
 2359|    108|         }
 2360|       |         // one nesting level (see enter_depth): counted in both modes so the limit binds,
 2361|       |         // released at each syntactic close below
 2362|  7.17k|         if (enter_depth(ctx)) [[unlikely]] {
  ------------------
  |  Branch (2362:14): [True: 0, False: 7.17k]
  ------------------
 2363|      0|            return;
 2364|      0|         }
 2365|       |
 2366|  7.17k|         const auto ws_start = it;
 2367|  7.17k|         if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (2367:14): [True: 12, False: 7.15k]
  ------------------
 2368|     12|            return;
 2369|     12|         }
 2370|       |
 2371|  7.15k|         if (*it == ']') {
  ------------------
  |  Branch (2371:14): [True: 1.02k, False: 6.13k]
  ------------------
 2372|  1.02k|            --ctx.depth;
 2373|  1.02k|            ++it;
 2374|       |            if constexpr ((resizable<T> || is_inplace_vector<T>) && not check_append_arrays(Opts)) {
 2375|       |               value.clear();
 2376|       |
 2377|       |               if constexpr (check_shrink_to_fit(Opts) && has_shrink_to_fit<T>) {
 2378|       |                  value.shrink_to_fit();
 2379|       |               }
 2380|       |            }
 2381|  1.02k|            return;
 2382|  1.02k|         }
 2383|       |
 2384|  6.13k|         const size_t ws_size = size_t(it - ws_start);
 2385|       |
 2386|  6.13k|         static constexpr bool should_append = (resizable<T> || is_inplace_vector<T>) && check_append_arrays(Opts);
  ------------------
  |  Branch (2386:49): [Folded, False: 0]
  |  Branch (2386:65): [Folded, False: 0]
  |  Branch (2386:90): [Folded, False: 0]
  ------------------
 2387|  6.13k|         if constexpr (not should_append) {
 2388|  6.13k|            const auto n = value.size();
 2389|       |
 2390|  6.13k|            auto value_it = value.begin();
 2391|       |
 2392|  13.5k|            for (size_t i = 0; i < n; ++i) {
  ------------------
  |  Branch (2392:32): [True: 13.5k, False: 5]
  ------------------
 2393|  13.5k|               parse<JSON>::op<ws_handled<Opts>()>(*value_it++, ctx, it, end);
 2394|  13.5k|               if (bool(ctx.error)) [[unlikely]]
  ------------------
  |  Branch (2394:20): [True: 490, False: 13.0k]
  ------------------
 2395|    490|                  return;
 2396|  13.0k|               if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (2396:20): [True: 18, False: 13.0k]
  ------------------
 2397|     18|                  return;
 2398|     18|               }
 2399|  13.0k|               if (*it == ',') {
  ------------------
  |  Branch (2399:20): [True: 7.39k, False: 5.61k]
  ------------------
 2400|  7.39k|                  ++it;
 2401|       |
 2402|       |                  if constexpr (!Opts.minified && !Opts.comments) {
 2403|       |                     if (ws_size && ws_size < size_t(end - it)) {
 2404|       |                        skip_matching_ws(ws_start, it, ws_size);
 2405|       |                     }
 2406|       |                  }
 2407|       |
 2408|  7.39k|                  if (skip_ws<Opts>(ctx, it, end)) {
  ------------------
  |  Branch (2408:23): [True: 8, False: 7.39k]
  ------------------
 2409|      8|                     return;
 2410|      8|                  }
 2411|  7.39k|               }
 2412|  5.61k|               else if (*it == ']') {
  ------------------
  |  Branch (2412:25): [True: 5.06k, False: 550]
  ------------------
 2413|  5.06k|                  --ctx.depth;
 2414|  5.06k|                  ++it;
 2415|       |                  if constexpr (erasable<T>) {
 2416|       |                     value.erase(value_it,
 2417|       |                                 value.end()); // use erase rather than resize for non-default constructible elements
 2418|       |
 2419|       |                     if constexpr (check_shrink_to_fit(Opts) && has_shrink_to_fit<T>) {
 2420|       |                        value.shrink_to_fit();
 2421|       |                     }
 2422|       |                  }
 2423|  5.06k|                  return;
 2424|  5.06k|               }
 2425|    550|               else [[unlikely]] {
 2426|    550|                  ctx.error = error_code::expected_bracket;
 2427|    550|                  return;
 2428|    550|               }
 2429|  13.0k|            }
 2430|  6.13k|         }
 2431|       |
 2432|       |         if constexpr (Opts.partial_read) {
 2433|       |            // partial_read stops early on a success path, so give the level back like the
 2434|       |            // syntactic-close paths do; otherwise it accumulates across reads sharing a context.
 2435|       |            --ctx.depth;
 2436|       |            return;
 2437|       |         }
 2438|  6.13k|         else {
 2439|       |            // growing
 2440|       |            if constexpr (emplace_backable<T> || has_try_emplace_back<T>) {
 2441|       |               while (it < end) {
 2442|       |                  // Streaming refill point: at start of each iteration, ensure buffer has data
 2443|       |                  if constexpr (has_streaming_state<decltype(ctx)>) {
 2444|       |                     if (ctx.stream.enabled()) {
 2445|       |                        const size_t consumed = static_cast<size_t>(it - ctx.stream.data());
 2446|       |                        const size_t remaining = ctx.stream.size() - consumed;
 2447|       |                        // Refill when less than half of buffer remains to ensure space for next element
 2448|       |                        if (remaining <= ctx.stream.size() / 2 || it >= end) {
 2449|       |                           const char* new_it;
 2450|       |                           const char* new_end;
 2451|       |                           ctx.stream.consume_and_refill(consumed, new_it, new_end);
 2452|       |                           it = new_it;
 2453|       |                           end = new_end;
 2454|       |                           if (it >= end && ctx.stream.at_eof()) {
 2455|       |                              break; // No more data, exit loop normally
 2456|       |                           }
 2457|       |                        }
 2458|       |                     }
 2459|       |                  }
 2460|       |
 2461|       |                  if constexpr (has_try_emplace_back<T>) {
 2462|       |                     if (value.try_emplace_back())
 2463|       |                        parse<JSON>::op<ws_handled<Opts>()>(value.back(), ctx, it, end);
 2464|       |                     else
 2465|       |                        ctx.error = error_code::exceeded_static_array_size;
 2466|       |                  }
 2467|       |                  else {
 2468|       |                     parse<JSON>::op<ws_handled<Opts>()>(value.emplace_back(), ctx, it, end);
 2469|       |                  }
 2470|       |
 2471|       |                  if (bool(ctx.error)) [[unlikely]]
 2472|       |                     return;
 2473|       |
 2474|       |                  // Streaming refill point: after parsing each element, refill if buffer is low
 2475|       |                  if constexpr (has_streaming_state<decltype(ctx)>) {
 2476|       |                     if (ctx.stream.enabled()) {
 2477|       |                        const size_t consumed = static_cast<size_t>(it - ctx.stream.data());
 2478|       |                        // Refill when less than 25% of buffer remains to ensure enough space for next element
 2479|       |                        if (ctx.stream.size() - consumed <= ctx.stream.size() / 4 || it >= end) {
 2480|       |                           const char* new_it;
 2481|       |                           const char* new_end;
 2482|       |                           ctx.stream.consume_and_refill(consumed, new_it, new_end);
 2483|       |                           it = new_it;
 2484|       |                           end = new_end;
 2485|       |                           if (it >= end && ctx.stream.at_eof()) {
 2486|       |                              ctx.error = error_code::unexpected_end;
 2487|       |                              return;
 2488|       |                           }
 2489|       |                        }
 2490|       |                     }
 2491|       |                  }
 2492|       |
 2493|       |                  if (skip_ws<Opts>(ctx, it, end)) {
 2494|       |                     return;
 2495|       |                  }
 2496|       |                  if (*it == ',') [[likely]] {
 2497|       |                     ++it;
 2498|       |
 2499|       |                     if constexpr (!Opts.minified && !Opts.comments) {
 2500|       |                        if (ws_size && ws_size < size_t(end - it)) {
 2501|       |                           skip_matching_ws(ws_start, it, ws_size);
 2502|       |                        }
 2503|       |                     }
 2504|       |
 2505|       |                     if (skip_ws<Opts>(ctx, it, end)) {
 2506|       |                        return;
 2507|       |                     }
 2508|       |                  }
 2509|       |                  else if (*it == ']') {
 2510|       |                     --ctx.depth;
 2511|       |                     ++it;
 2512|       |                     if constexpr (check_shrink_to_fit(Opts) && has_shrink_to_fit<T>) {
 2513|       |                        value.shrink_to_fit();
 2514|       |                     }
 2515|       |                     return;
 2516|       |                  }
 2517|       |                  else [[unlikely]] {
 2518|       |                     ctx.error = error_code::expected_bracket;
 2519|       |                     return;
 2520|       |                  }
 2521|       |               }
 2522|       |
 2523|       |               // A valid array always returns from inside the loop upon reaching ']'.
 2524|       |               // For a null-terminated buffer the loop can only exit here by falling
 2525|       |               // through when `it` reaches the terminator without a closing bracket,
 2526|       |               // which means the input was truncated (e.g. "[", "[1," or "[1,2,").
 2527|       |               // Non-null-terminated buffers surface this through skip_ws/depth
 2528|       |               // tracking (or the streaming refill break), so this guard is limited
 2529|       |               // to the null-terminated case.
 2530|       |               if constexpr (Opts.null_terminated) {
 2531|       |                  ctx.error = error_code::unexpected_end;
 2532|       |               }
 2533|       |            }
 2534|  6.13k|            else {
 2535|  6.13k|               ctx.error = error_code::exceeded_static_array_size;
 2536|  6.13k|            }
 2537|  6.13k|         }
 2538|  6.13k|      }
_ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb1ELb1ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEERmTkNS_10is_contextERNS_7contextERPKcS8_EEvOT0_OT1_OT2_T3_:
   49|  13.5k|      {
   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|  13.5k|         else {
   60|  13.5k|            using V = std::remove_cvref_t<T>;
   61|  13.5k|            from<JSON, V>::template op<Opts>(std::forward<T>(value), std::forward<Ctx>(ctx), std::forward<It0>(it),
   62|  13.5k|                                             end);
   63|  13.5k|         }
   64|  13.5k|      }
_ZN3glz4fromILj10EmE2opITnDaXtlNS_4optsELj10ELb1ELb1ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEERPKcRmTkNS_10is_contextERNS_7contextES5_EEvOT1_OT2_OT0_T3_:
  808|  13.5k|      {
  809|       |         if constexpr (check_quoted_num(Opts)) {
  810|       |            if (skip_ws<Opts>(ctx, it, end)) {
  811|       |               return;
  812|       |            }
  813|       |            if (match_invalid_end<'"', Opts>(ctx, it, end)) {
  814|       |               return;
  815|       |            }
  816|       |         }
  817|       |
  818|       |         if constexpr (!check_ws_handled(Opts)) {
  819|       |            if (skip_ws<Opts>(ctx, it, end)) {
  820|       |               return;
  821|       |            }
  822|       |         }
  823|       |
  824|  13.5k|         using V = std::decay_t<decltype(value)>;
  825|  13.5k|         if constexpr (int_t<V>) {
  826|  13.5k|            static_assert(sizeof(*it) == sizeof(char));
  827|       |
  828|  13.5k|            if constexpr (Opts.null_terminated) {
  829|  13.5k|               if (not glz::atoi(value, it)) [[unlikely]] {
  ------------------
  |  Branch (829:20): [True: 490, False: 13.0k]
  ------------------
  830|    490|                  ctx.error = error_code::parse_number_failure;
  831|    490|                  return;
  832|    490|               }
  833|       |            }
  834|       |            else {
  835|       |               if (not glz::atoi(value, it, end)) [[unlikely]] {
  836|       |                  ctx.error = error_code::parse_number_failure;
  837|       |                  return;
  838|       |               }
  839|       |            }
  840|       |         }
  841|       |         else {
  842|       |// float128_t requires std::from_chars for floating-point, unavailable on older Apple platforms (iOS < 16.3)
  843|       |#if !defined(_LIBCPP_VERSION) || defined(_LIBCPP_AVAILABILITY_HAS_TO_CHARS_FLOATING_POINT)
  844|       |            if constexpr (is_float128<V>) {
  845|       |               auto [ptr, ec] = std::from_chars(it, end, value);
  846|       |               if (ec != std::errc()) {
  847|       |                  ctx.error = error_code::parse_number_failure;
  848|       |                  return;
  849|       |               }
  850|       |               it = ptr;
  851|       |            }
  852|       |            else
  853|       |#endif
  854|       |            {
  855|       |               if constexpr (std::is_volatile_v<std::remove_reference_t<decltype(value)>>) {
  856|       |                  // Hardware may interact with value changes, so we parse into a temporary and assign in one
  857|       |                  // place
  858|       |                  V temp;
  859|       |                  if constexpr (is_size_optimized(Opts)) {
  860|       |                     auto [ptr, ec] = simple_float::from_chars<Opts.null_terminated>(it, end, temp);
  861|       |                     if (ec != std::errc{}) [[unlikely]] {
  862|       |                        ctx.error = error_code::parse_number_failure;
  863|       |                        return;
  864|       |                     }
  865|       |                     it = ptr;
  866|       |                  }
  867|       |                  else {
  868|       |                     auto [ptr, ec] = glz::from_chars<Opts.null_terminated>(it, end, temp);
  869|       |                     if (ec != std::errc()) [[unlikely]] {
  870|       |                        ctx.error = error_code::parse_number_failure;
  871|       |                        return;
  872|       |                     }
  873|       |                     it = ptr;
  874|       |                  }
  875|       |                  value = temp;
  876|       |               }
  877|       |               else {
  878|       |                  if constexpr (is_size_optimized(Opts)) {
  879|       |                     auto [ptr, ec] = simple_float::from_chars<Opts.null_terminated>(it, end, value);
  880|       |                     if (ec != std::errc{}) [[unlikely]] {
  881|       |                        ctx.error = error_code::parse_number_failure;
  882|       |                        return;
  883|       |                     }
  884|       |                     it = ptr;
  885|       |                  }
  886|       |                  else {
  887|       |                     auto [ptr, ec] = glz::from_chars<Opts.null_terminated>(it, end, value);
  888|       |                     if (ec != std::errc()) [[unlikely]] {
  889|       |                        ctx.error = error_code::parse_number_failure;
  890|       |                        return;
  891|       |                     }
  892|       |                     it = ptr;
  893|       |                  }
  894|       |               }
  895|       |            }
  896|       |         }
  897|       |
  898|       |         if constexpr (check_quoted_num(Opts)) {
  899|       |            if constexpr (not Opts.null_terminated) {
  900|       |               if (it == end) [[unlikely]] {
  901|       |                  ctx.error = error_code::unexpected_end;
  902|       |                  return;
  903|       |               }
  904|       |            }
  905|       |            if (match<'"'>(ctx, it)) {
  906|       |               return;
  907|       |            }
  908|       |            if constexpr (not Opts.null_terminated) {
  909|       |               if (it == end) {
  910|       |                  ctx.error = error_code::end_reached;
  911|       |                  return;
  912|       |               }
  913|       |            }
  914|       |         }
  915|  13.5k|         else {
  916|       |            if constexpr (not Opts.null_terminated) {
  917|       |               if (it == end) {
  918|       |                  ctx.error = error_code::end_reached;
  919|       |                  return;
  920|       |               }
  921|       |            }
  922|  13.5k|         }
  923|  13.5k|      }

_ZN3glz6to_tieIR9my_structLm4EQleT0_L_ZNS_6detail25max_pure_reflection_countEEEEDcOT_:
  137|  43.7k|   {
  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|  43.7k|      else if constexpr (N == 4) {
  154|  43.7k|         auto& [p0, p1, p2, p3] = t;
  155|  43.7k|         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|  43.7k|   }

_ZN3glz3getILm0ETkNS_6tuplet9indexableENS_5tupleIJRiRdRNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEERNS5_5arrayImLm3EEEEEEEEDcOT0_:
  432|  8.07k|   {
  433|  8.07k|      return static_cast<Tup&&>(tup)[tuplet::tag<I>()];
  434|  8.07k|   }
_ZNO3glz6tuplet10tuple_elemILm0ERiEixENSt3__117integral_constantImLm0EEE:
  113|  8.07k|         constexpr decltype(auto) operator[](tag<I>) && { return (std::move(*this).value); }
_ZN3glz3tieIJidNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS1_5arrayImLm3EEEEEENS_5tupleIJDpRT_EEESD_:
  442|  43.7k|   {
  443|  43.7k|      return {t...};
  444|  43.7k|   }
_ZN3glz3getILm1ETkNS_6tuplet9indexableENS_5tupleIJRiRdRNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEERNS5_5arrayImLm3EEEEEEEEDcOT0_:
  432|  23.1k|   {
  433|  23.1k|      return static_cast<Tup&&>(tup)[tuplet::tag<I>()];
  434|  23.1k|   }
_ZNO3glz6tuplet10tuple_elemILm1ERdEixENSt3__117integral_constantImLm1EEE:
  113|  23.1k|         constexpr decltype(auto) operator[](tag<I>) && { return (std::move(*this).value); }
_ZN3glz3getILm2ETkNS_6tuplet9indexableENS_5tupleIJRiRdRNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEERNS5_5arrayImLm3EEEEEEEEDcOT0_:
  432|  5.17k|   {
  433|  5.17k|      return static_cast<Tup&&>(tup)[tuplet::tag<I>()];
  434|  5.17k|   }
_ZNO3glz6tuplet10tuple_elemILm2ERNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEixENS2_17integral_constantImLm2EEE:
  113|  5.17k|         constexpr decltype(auto) operator[](tag<I>) && { return (std::move(*this).value); }
_ZN3glz3getILm3ETkNS_6tuplet9indexableENS_5tupleIJRiRdRNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEERNS5_5arrayImLm3EEEEEEEEDcOT0_:
  432|  7.27k|   {
  433|  7.27k|      return static_cast<Tup&&>(tup)[tuplet::tag<I>()];
  434|  7.27k|   }
_ZNO3glz6tuplet10tuple_elemILm3ERNSt3__15arrayImLm3EEEEixENS2_17integral_constantImLm3EEE:
  113|  7.27k|         constexpr decltype(auto) operator[](tag<I>) && { return (std::move(*this).value); }

_ZN3glz4atoiITkNSt3__18integralEiKcQsr3stdE11is_signed_vIT_EEEbRS3_RPT0_:
  715|  8.07k|   {
  716|  8.07k|      using X = std::decay_t<T>;
  717|  8.07k|      using utype = std::make_unsigned_t<X>;
  718|       |
  719|  8.07k|      const uint8_t sign = *c == '-';
  720|  8.07k|      if (auto ptr = parse_int(v, reinterpret_cast<const uint8_t*>(c))) [[likely]] {
  ------------------
  |  Branch (720:16): [True: 7.92k, False: 145]
  ------------------
  721|  7.92k|         c = reinterpret_cast<const Char*>(ptr);
  722|  7.92k|         if (*c == 'e' || *c == 'E') {
  ------------------
  |  Branch (722:14): [True: 1.45k, False: 6.47k]
  |  Branch (722:27): [True: 1.36k, False: 5.10k]
  ------------------
  723|  2.82k|            ++c;
  724|  2.82k|         }
  725|  5.10k|         else {
  726|  5.10k|            if (*c == '.') [[unlikely]] {
  ------------------
  |  Branch (726:17): [True: 7, False: 5.10k]
  ------------------
  727|      7|               return false;
  728|      7|            }
  729|  5.10k|            return true;
  730|  5.10k|         }
  731|       |
  732|  2.82k|         c += (*c == '+');
  733|       |
  734|  2.82k|         if (not is_digit(*c)) [[unlikely]] {
  ------------------
  |  Branch (734:14): [True: 65, False: 2.75k]
  ------------------
  735|     65|            return false;
  736|     65|         }
  737|  2.75k|         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|  2.75k|         else if constexpr (sizeof(T) == 4) {
  752|  2.75k|            if (exp > 9) [[unlikely]] {
  ------------------
  |  Branch (752:17): [True: 253, False: 2.50k]
  ------------------
  753|    253|               return v == 0;
  754|    253|            }
  755|       |         }
  756|       |         else {
  757|       |            if (exp > 18) [[unlikely]] {
  758|       |               return v == 0;
  759|       |            }
  760|       |         }
  761|       |
  762|  2.50k|         utype i = utype((utype(v) ^ -sign) + sign);
  763|  2.75k|         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|  2.75k|            const uint64_t scaled = uint64_t(i) * powers_of_ten_int[exp];
  770|  2.75k|            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|  2.75k|            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|  2.75k|      }
  795|  2.90k|      return false;
  796|  8.07k|   }
_ZN3glz9parse_intITkNSt3__18integralEiQaasr3stdE11is_signed_vIT_ElestS2_Li8EEEPKhRS2_S4_:
  476|  8.07k|   {
  477|  8.07k|      const uint8_t sign = *c == '-';
  478|  8.07k|      c += sign;
  479|       |
  480|  8.07k|      if (is_digit(*c)) [[likely]] {
  ------------------
  |  Branch (480:11): [True: 7.96k, False: 108]
  ------------------
  481|  7.96k|         v = *c - '0';
  482|  7.96k|         ++c;
  483|  7.96k|      }
  484|    108|      else [[unlikely]] {
  485|    108|         return {};
  486|    108|      }
  487|       |
  488|  7.96k|      if (is_digit(*c)) {
  ------------------
  |  Branch (488:11): [True: 6.17k, False: 1.78k]
  ------------------
  489|  6.17k|         v = v * 10 + (*c - '0');
  490|  6.17k|         ++c;
  491|  6.17k|      }
  492|  1.78k|      else {
  493|  1.78k|         if (sign) {
  ------------------
  |  Branch (493:14): [True: 209, False: 1.57k]
  ------------------
  494|    209|            v = -v;
  495|    209|         }
  496|  1.78k|         return c;
  497|  1.78k|      }
  498|       |
  499|  6.17k|      if (c[-2] == '0') [[unlikely]] {
  ------------------
  |  Branch (499:11): [True: 2, False: 6.17k]
  ------------------
  500|      2|         return {};
  501|      2|      }
  502|       |
  503|  6.17k|      if constexpr (sizeof(T) > 1) {
  504|  6.17k|         if (is_digit(*c)) {
  ------------------
  |  Branch (504:14): [True: 5.36k, False: 807]
  ------------------
  505|  5.36k|            v = v * 10 + (*c - '0');
  506|  5.36k|            ++c;
  507|  5.36k|         }
  508|    807|         else {
  509|    807|            if (sign) {
  ------------------
  |  Branch (509:17): [True: 201, False: 606]
  ------------------
  510|    201|               v = -v;
  511|    201|            }
  512|    807|            return c;
  513|    807|         }
  514|       |
  515|  5.36k|         if (is_digit(*c)) {
  ------------------
  |  Branch (515:14): [True: 4.68k, False: 679]
  ------------------
  516|  4.68k|            v = v * 10 + (*c - '0');
  517|  4.68k|            ++c;
  518|  4.68k|         }
  519|    679|         else {
  520|    679|            if (sign) {
  ------------------
  |  Branch (520:17): [True: 195, False: 484]
  ------------------
  521|    195|               v = -v;
  522|    195|            }
  523|    679|            return c;
  524|    679|         }
  525|       |
  526|  4.68k|         if constexpr (sizeof(T) > 2) {
  527|  4.68k|            if (is_digit(*c)) {
  ------------------
  |  Branch (527:17): [True: 4.02k, False: 662]
  ------------------
  528|  4.02k|               v = v * 10 + (*c - '0');
  529|  4.02k|               ++c;
  530|  4.02k|            }
  531|    662|            else {
  532|    662|               if (sign) {
  ------------------
  |  Branch (532:20): [True: 199, False: 463]
  ------------------
  533|    199|                  v = -v;
  534|    199|               }
  535|    662|               return c;
  536|    662|            }
  537|       |
  538|  4.02k|            if (is_digit(*c)) {
  ------------------
  |  Branch (538:17): [True: 3.30k, False: 718]
  ------------------
  539|  3.30k|               v = v * 10 + (*c - '0');
  540|  3.30k|               ++c;
  541|  3.30k|            }
  542|    718|            else {
  543|    718|               if (sign) {
  ------------------
  |  Branch (543:20): [True: 198, False: 520]
  ------------------
  544|    198|                  v = -v;
  545|    198|               }
  546|    718|               return c;
  547|    718|            }
  548|       |
  549|  3.30k|            if (is_digit(*c)) {
  ------------------
  |  Branch (549:17): [True: 2.66k, False: 648]
  ------------------
  550|  2.66k|               v = v * 10 + (*c - '0');
  551|  2.66k|               ++c;
  552|  2.66k|            }
  553|    648|            else {
  554|    648|               if (sign) {
  ------------------
  |  Branch (554:20): [True: 198, False: 450]
  ------------------
  555|    198|                  v = -v;
  556|    198|               }
  557|    648|               return c;
  558|    648|            }
  559|       |
  560|  2.66k|            if (is_digit(*c)) {
  ------------------
  |  Branch (560:17): [True: 1.97k, False: 688]
  ------------------
  561|  1.97k|               v = v * 10 + (*c - '0');
  562|  1.97k|               ++c;
  563|  1.97k|            }
  564|    688|            else {
  565|    688|               if (sign) {
  ------------------
  |  Branch (565:20): [True: 198, False: 490]
  ------------------
  566|    198|                  v = -v;
  567|    198|               }
  568|    688|               return c;
  569|    688|            }
  570|       |
  571|  1.97k|            if (is_digit(*c)) {
  ------------------
  |  Branch (571:17): [True: 1.34k, False: 628]
  ------------------
  572|  1.34k|               v = v * 10 + (*c - '0');
  573|  1.34k|               ++c;
  574|  1.34k|            }
  575|    628|            else {
  576|    628|               if (sign) {
  ------------------
  |  Branch (576:20): [True: 197, False: 431]
  ------------------
  577|    197|                  v = -v;
  578|    197|               }
  579|    628|               return c;
  580|    628|            }
  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|  1.34k|         }
  683|  4.68k|      }
  684|       |
  685|  6.17k|      if (is_digit(*c)) {
  ------------------
  |  Branch (685:11): [True: 687, False: 5.48k]
  ------------------
  686|    687|         if (sign) {
  ------------------
  |  Branch (686:14): [True: 239, False: 448]
  ------------------
  687|    239|            if (would_overflow_negative<T>(v, *c)) [[unlikely]] {
  ------------------
  |  Branch (687:17): [True: 15, False: 224]
  ------------------
  688|     15|               return {};
  689|     15|            }
  690|    224|            v = -1 * v;
  691|    224|            v = v * 10 - (*c - '0');
  692|    224|         }
  693|    448|         else {
  694|    448|            if (would_overflow_positive<T>(v, *c)) [[unlikely]] {
  ------------------
  |  Branch (694:17): [True: 15, False: 433]
  ------------------
  695|     15|               return {};
  696|     15|            }
  697|    433|            v = v * 10 + (*c - '0');
  698|    433|         }
  699|    657|         ++c;
  700|    657|         if (is_digit(*c)) [[unlikely]] {
  ------------------
  |  Branch (700:14): [True: 5, False: 652]
  ------------------
  701|      5|            return {};
  702|      5|         }
  703|    652|         return c;
  704|    657|      }
  705|       |
  706|  5.48k|      if (sign) {
  ------------------
  |  Branch (706:11): [True: 197, False: 5.29k]
  ------------------
  707|    197|         v = -v;
  708|    197|      }
  709|  5.48k|      return c;
  710|  6.17k|   }
_ZN3glz23would_overflow_negativeIiEEbu17__remove_volatileIT_Eh:
  151|    239|   {
  152|       |      // For negative: max magnitude is max + 1 (e.g., -2147483648 for int32)
  153|    239|      using U = std::remove_volatile_t<T>;
  154|    239|      constexpr auto max_val = static_cast<uint64_t>((std::numeric_limits<U>::max)()) + 1;
  155|    239|      constexpr auto threshold = max_val / 10;
  156|    239|      constexpr auto last_digit = max_val % 10;
  157|    239|      const auto uv = static_cast<uint64_t>(v);
  158|    239|      const auto digit = static_cast<uint64_t>(next_digit - '0');
  159|       |      // When digit > last_digit, effective threshold is one less
  160|    239|      return uv > (threshold - uint64_t(digit > last_digit));
  161|    239|   }
_ZN3glz23would_overflow_positiveIiEEbu17__remove_volatileIT_Eh:
  137|    448|   {
  138|    448|      using U = std::remove_volatile_t<T>;
  139|    448|      constexpr auto max_val = static_cast<uint64_t>((std::numeric_limits<U>::max)());
  140|    448|      constexpr auto threshold = max_val / 10;
  141|    448|      constexpr auto last_digit = max_val % 10;
  142|    448|      const auto uv = static_cast<uint64_t>(v);
  143|    448|      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|    448|      return uv > (threshold - uint64_t(digit > last_digit));
  147|    448|   }
_ZN3glz8is_digitEh:
  103|   192k|   GLZ_ALWAYS_INLINE constexpr bool is_digit(const uint8_t c) noexcept { return c <= '9' && c >= '0'; }
  ------------------
  |  Branch (103:81): [True: 181k, False: 11.1k]
  |  Branch (103:93): [True: 164k, False: 16.3k]
  ------------------
_ZN3glz14parse_exponentIKcEEjRPT_:
  121|  5.83k|   {
  122|  5.83k|      uint32_t exp = uint32_t(*c - '0');
  123|  5.83k|      ++c;
  124|  8.28k|      while (is_digit(*c)) {
  ------------------
  |  Branch (124:14): [True: 2.44k, False: 5.83k]
  ------------------
  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|  2.44k|         exp = exp < exponent_clamp ? exp * 10 + uint32_t(*c - '0') : exp;
  ------------------
  |  Branch (127:16): [True: 1.82k, False: 627]
  ------------------
  128|  2.44k|         ++c;
  129|  2.44k|      }
  130|  5.83k|      return exp;
  131|  5.83k|   }
_ZN3glz4atoiITkNSt3__18integralEmKcQsr3stdE13is_unsigned_vIT_EEEbRS3_RPT0_:
  397|  13.5k|   {
  398|  13.5k|      if (auto ptr = parse_int(v, reinterpret_cast<const uint8_t*>(c))) [[likely]] {
  ------------------
  |  Branch (398:16): [True: 13.2k, False: 281]
  ------------------
  399|  13.2k|         c = reinterpret_cast<const Char*>(ptr);
  400|  13.2k|         if (*c == 'e' || *c == 'E') {
  ------------------
  |  Branch (400:14): [True: 730, False: 12.5k]
  |  Branch (400:27): [True: 2.42k, False: 10.0k]
  ------------------
  401|  3.15k|            ++c;
  402|  3.15k|         }
  403|  10.0k|         else {
  404|  10.0k|            if (*c == '.') [[unlikely]] {
  ------------------
  |  Branch (404:17): [True: 11, False: 10.0k]
  ------------------
  405|     11|               return false;
  406|     11|            }
  407|  10.0k|            return true;
  408|  10.0k|         }
  409|       |
  410|  3.15k|         c += (*c == '+');
  411|       |
  412|  3.15k|         if (not is_digit(*c)) [[unlikely]] {
  ------------------
  |  Branch (412:14): [True: 74, False: 3.07k]
  ------------------
  413|     74|            return false;
  414|     74|         }
  415|  3.07k|         const uint32_t exp = parse_exponent(c);
  416|       |         // An exponent past the width's limit overflows any non-zero magnitude, but zero stays zero
  417|       |         // however far it is scaled, so "0e19" is in range for every width. Testing the magnitude
  418|       |         // here rather than ahead of the dispatch keeps it off the hot path: it only runs once the
  419|       |         // exponent has already failed the range check.
  420|       |         if constexpr (sizeof(T) == 1) {
  421|       |            if (exp > 2) [[unlikely]] {
  422|       |               return v == 0;
  423|       |            }
  424|       |         }
  425|       |         else if constexpr (sizeof(T) == 2) {
  426|       |            if (exp > 4) [[unlikely]] {
  427|       |               return v == 0;
  428|       |            }
  429|       |         }
  430|       |         else if constexpr (sizeof(T) == 4) {
  431|       |            if (exp > 9) [[unlikely]] {
  432|       |               return v == 0;
  433|       |            }
  434|       |         }
  435|  3.07k|         else {
  436|  3.07k|            if (exp > 19) [[unlikely]] {
  ------------------
  |  Branch (436:17): [True: 316, False: 2.76k]
  ------------------
  437|    316|               return v == 0;
  438|    316|            }
  439|  3.07k|         }
  440|       |
  441|       |         if constexpr (sizeof(T) == 1) {
  442|       |            static constexpr std::array<uint8_t, 3> powers_of_ten{1, 10, 100};
  443|       |            const uint64_t i = v * powers_of_ten[exp];
  444|       |            v = T(i);
  445|       |            return i <= (std::numeric_limits<T>::max)();
  446|       |         }
  447|       |         else if constexpr (sizeof(T) == 2) {
  448|       |            static constexpr std::array<uint16_t, 5> powers_of_ten{1, 10, 100, 1000, 10000};
  449|       |            const uint64_t i = v * powers_of_ten[exp];
  450|       |            v = T(i);
  451|       |            return i <= (std::numeric_limits<T>::max)();
  452|       |         }
  453|       |         else if constexpr (sizeof(T) < 8) {
  454|       |            const uint64_t i = v * powers_of_ten_int[exp];
  455|       |            v = T(i);
  456|       |            return i <= (std::numeric_limits<T>::max)();
  457|       |         }
  458|  3.07k|         else {
  459|  3.07k|#if defined(__SIZEOF_INT128__)
  460|  3.07k|            const __uint128_t res = __uint128_t(v) * powers_of_ten_int[exp];
  461|  3.07k|            v = T(res);
  462|  3.07k|            return res <= (std::numeric_limits<T>::max)();
  463|       |#else
  464|       |            const auto res = full_multiplication(v, powers_of_ten_int[exp]);
  465|       |            v = T(res.low);
  466|       |            return res.high == 0;
  467|       |#endif
  468|  3.07k|         }
  469|  3.07k|      }
  470|  3.36k|      return false;
  471|  13.5k|   }
_ZN3glz9parse_intITkNSt3__18integralEmQaasr3stdE13is_unsigned_vIT_ElestS2_Li8EEEPKhRS2_S4_:
  212|  13.5k|   {
  213|  13.5k|      if (is_digit(*c)) [[likely]] {
  ------------------
  |  Branch (213:11): [True: 13.3k, False: 197]
  ------------------
  214|  13.3k|         v = *c - '0';
  215|  13.3k|         ++c;
  216|  13.3k|      }
  217|    197|      else [[unlikely]] {
  218|    197|         return {};
  219|    197|      }
  220|       |
  221|  13.3k|      if (is_digit(*c)) {
  ------------------
  |  Branch (221:11): [True: 10.5k, False: 2.74k]
  ------------------
  222|  10.5k|         v = v * 10 + (*c - '0');
  223|  10.5k|         ++c;
  224|  10.5k|      }
  225|  2.74k|      else {
  226|  2.74k|         return c;
  227|  2.74k|      }
  228|       |
  229|  10.5k|      if (c[-2] == '0') [[unlikely]] {
  ------------------
  |  Branch (229:11): [True: 2, False: 10.5k]
  ------------------
  230|      2|         return {};
  231|      2|      }
  232|       |
  233|  10.5k|      if constexpr (sizeof(T) > 1) {
  234|  10.5k|         if (is_digit(*c)) {
  ------------------
  |  Branch (234:14): [True: 10.0k, False: 568]
  ------------------
  235|  10.0k|            v = v * 10 + (*c - '0');
  236|  10.0k|            ++c;
  237|  10.0k|         }
  238|    568|         else {
  239|    568|            return c;
  240|    568|         }
  241|       |
  242|  10.0k|         if (is_digit(*c)) {
  ------------------
  |  Branch (242:14): [True: 9.40k, False: 597]
  ------------------
  243|  9.40k|            v = v * 10 + (*c - '0');
  244|  9.40k|            ++c;
  245|  9.40k|         }
  246|    597|         else {
  247|    597|            return c;
  248|    597|         }
  249|       |
  250|  9.40k|         if constexpr (sizeof(T) > 2) {
  251|  9.40k|            if (is_digit(*c)) {
  ------------------
  |  Branch (251:17): [True: 8.80k, False: 604]
  ------------------
  252|  8.80k|               v = v * 10 + (*c - '0');
  253|  8.80k|               ++c;
  254|  8.80k|            }
  255|    604|            else {
  256|    604|               return c;
  257|    604|            }
  258|       |
  259|  8.80k|            if (is_digit(*c)) {
  ------------------
  |  Branch (259:17): [True: 8.29k, False: 510]
  ------------------
  260|  8.29k|               v = v * 10 + (*c - '0');
  261|  8.29k|               ++c;
  262|  8.29k|            }
  263|    510|            else {
  264|    510|               return c;
  265|    510|            }
  266|       |
  267|  8.29k|            if (is_digit(*c)) {
  ------------------
  |  Branch (267:17): [True: 7.64k, False: 649]
  ------------------
  268|  7.64k|               v = v * 10 + (*c - '0');
  269|  7.64k|               ++c;
  270|  7.64k|            }
  271|    649|            else {
  272|    649|               return c;
  273|    649|            }
  274|       |
  275|  7.64k|            if (is_digit(*c)) {
  ------------------
  |  Branch (275:17): [True: 7.09k, False: 551]
  ------------------
  276|  7.09k|               v = v * 10 + (*c - '0');
  277|  7.09k|               ++c;
  278|  7.09k|            }
  279|    551|            else {
  280|    551|               return c;
  281|    551|            }
  282|       |
  283|  7.09k|            if (is_digit(*c)) {
  ------------------
  |  Branch (283:17): [True: 6.51k, False: 577]
  ------------------
  284|  6.51k|               v = v * 10 + (*c - '0');
  285|  6.51k|               ++c;
  286|  6.51k|            }
  287|    577|            else {
  288|    577|               return c;
  289|    577|            }
  290|       |
  291|  6.51k|            if constexpr (sizeof(T) > 4) {
  292|  6.51k|               if (is_digit(*c)) {
  ------------------
  |  Branch (292:20): [True: 5.96k, False: 553]
  ------------------
  293|  5.96k|                  v = v * 10 + (*c - '0');
  294|  5.96k|                  ++c;
  295|  5.96k|               }
  296|    553|               else {
  297|    553|                  return c;
  298|    553|               }
  299|       |
  300|  5.96k|               if (is_digit(*c)) {
  ------------------
  |  Branch (300:20): [True: 5.37k, False: 590]
  ------------------
  301|  5.37k|                  v = v * 10 + (*c - '0');
  302|  5.37k|                  ++c;
  303|  5.37k|               }
  304|    590|               else {
  305|    590|                  return c;
  306|    590|               }
  307|       |
  308|  5.37k|               if (is_digit(*c)) {
  ------------------
  |  Branch (308:20): [True: 4.94k, False: 427]
  ------------------
  309|  4.94k|                  v = v * 10 + (*c - '0');
  310|  4.94k|                  ++c;
  311|  4.94k|               }
  312|    427|               else {
  313|    427|                  return c;
  314|    427|               }
  315|       |
  316|  4.94k|               if (is_digit(*c)) {
  ------------------
  |  Branch (316:20): [True: 4.30k, False: 644]
  ------------------
  317|  4.30k|                  v = v * 10 + (*c - '0');
  318|  4.30k|                  ++c;
  319|  4.30k|               }
  320|    644|               else {
  321|    644|                  return c;
  322|    644|               }
  323|       |
  324|  4.30k|               if (is_digit(*c)) {
  ------------------
  |  Branch (324:20): [True: 3.76k, False: 538]
  ------------------
  325|  3.76k|                  v = v * 10 + (*c - '0');
  326|  3.76k|                  ++c;
  327|  3.76k|               }
  328|    538|               else {
  329|    538|                  return c;
  330|    538|               }
  331|       |
  332|  3.76k|               if (is_digit(*c)) {
  ------------------
  |  Branch (332:20): [True: 3.32k, False: 438]
  ------------------
  333|  3.32k|                  v = v * 10 + (*c - '0');
  334|  3.32k|                  ++c;
  335|  3.32k|               }
  336|    438|               else {
  337|    438|                  return c;
  338|    438|               }
  339|       |
  340|  3.32k|               if (is_digit(*c)) {
  ------------------
  |  Branch (340:20): [True: 2.86k, False: 468]
  ------------------
  341|  2.86k|                  v = v * 10 + (*c - '0');
  342|  2.86k|                  ++c;
  343|  2.86k|               }
  344|    468|               else {
  345|    468|                  return c;
  346|    468|               }
  347|       |
  348|  2.86k|               if (is_digit(*c)) {
  ------------------
  |  Branch (348:20): [True: 2.25k, False: 610]
  ------------------
  349|  2.25k|                  v = v * 10 + (*c - '0');
  350|  2.25k|                  ++c;
  351|  2.25k|               }
  352|    610|               else {
  353|    610|                  return c;
  354|    610|               }
  355|       |
  356|  2.25k|               if (is_digit(*c)) {
  ------------------
  |  Branch (356:20): [True: 1.75k, False: 493]
  ------------------
  357|  1.75k|                  v = v * 10 + (*c - '0');
  358|  1.75k|                  ++c;
  359|  1.75k|               }
  360|    493|               else {
  361|    493|                  return c;
  362|    493|               }
  363|       |
  364|  1.75k|               if (is_digit(*c)) {
  ------------------
  |  Branch (364:20): [True: 1.32k, False: 435]
  ------------------
  365|  1.32k|                  v = v * 10 + (*c - '0');
  366|  1.32k|                  ++c;
  367|  1.32k|               }
  368|    435|               else {
  369|    435|                  return c;
  370|    435|               }
  371|  1.75k|            }
  372|  6.51k|         }
  373|  9.40k|      }
  374|       |
  375|  10.5k|      if (is_digit(*c)) {
  ------------------
  |  Branch (375:11): [True: 691, False: 9.88k]
  ------------------
  376|       |         // Test before multiplying. The previous guard multiplied first and then compared the
  377|       |         // already-wrapped value against max/10 - 10, which only caught wraps that happened to land
  378|       |         // below that threshold: "300" wraps to 44 for uint8_t and sailed through, as did most
  379|       |         // out-of-range values. would_overflow_positive is the same branch-free check the signed
  380|       |         // path above already uses, so the two paths now reject on the same rule.
  381|    691|         if (would_overflow_positive<T>(v, *c)) [[unlikely]] {
  ------------------
  |  Branch (381:14): [True: 79, False: 612]
  ------------------
  382|     79|            return {};
  383|     79|         }
  384|    612|         v = v * 10 + (*c - '0');
  385|    612|         ++c;
  386|    612|         if (is_digit(*c)) [[unlikely]] {
  ------------------
  |  Branch (386:14): [True: 3, False: 609]
  ------------------
  387|      3|            return {};
  388|      3|         }
  389|    612|      }
  390|       |
  391|  10.4k|      return c;
  392|  10.5k|   }
_ZN3glz23would_overflow_positiveImEEbu17__remove_volatileIT_Eh:
  137|    691|   {
  138|    691|      using U = std::remove_volatile_t<T>;
  139|    691|      constexpr auto max_val = static_cast<uint64_t>((std::numeric_limits<U>::max)());
  140|    691|      constexpr auto threshold = max_val / 10;
  141|    691|      constexpr auto last_digit = max_val % 10;
  142|    691|      const auto uv = static_cast<uint64_t>(v);
  143|    691|      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|    691|      return uv > (threshold - uint64_t(digit > last_digit));
  147|    691|   }

_ZN3glz11countr_zeroEm:
   29|  7.30k|   {
   30|       |#ifdef _MSC_VER
   31|       |      return std::countr_zero(x);
   32|       |#else
   33|  7.30k|#if __has_builtin(__builtin_ctzll)
   34|  7.30k|      return __builtin_ctzll(x);
   35|       |#else
   36|       |      return std::countr_zero(x);
   37|       |#endif
   38|  7.30k|#endif
   39|  7.30k|   }

_ZN3glz10comparitorIL_ZZNS_12decode_indexITnDaXtlNS_4optsELj10ELb1ELb1ELb1ELb1EEE9my_structLm0ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT2_OT4_OT5_OT6_DpOT3_E15KeyWithEndQuoteELm2EcEEbPKT1_:
  245|  8.21k|   {
  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|  8.21k|      else if constexpr (N == 2) {
  304|  8.21k|         static constexpr auto packed = pack<Str, 2>();
  305|  8.21k|         uint16_t in;
  306|  8.21k|         std::memcpy(&in, other, 2);
  307|       |         if constexpr (std::endian::native == std::endian::big) {
  308|       |            in = std::byteswap(in);
  309|       |         }
  310|  8.21k|         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.21k|   }
_ZN3glz10comparitorIL_ZZNS_12decode_indexITnDaXtlNS_4optsELj10ELb1ELb1ELb1ELb1EEE9my_structLm1ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT2_OT4_OT5_OT6_DpOT3_E15KeyWithEndQuoteELm2EcEEbPKT1_:
  245|  23.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|       |      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|  23.3k|      else if constexpr (N == 2) {
  304|  23.3k|         static constexpr auto packed = pack<Str, 2>();
  305|  23.3k|         uint16_t in;
  306|  23.3k|         std::memcpy(&in, other, 2);
  307|       |         if constexpr (std::endian::native == std::endian::big) {
  308|       |            in = std::byteswap(in);
  309|       |         }
  310|  23.3k|         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|  23.3k|   }
_ZN3glz10comparitorIL_ZZNS_12decode_indexITnDaXtlNS_4optsELj10ELb1ELb1ELb1ELb1EEE9my_structLm2ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT2_OT4_OT5_OT6_DpOT3_E15KeyWithEndQuoteELm6EcEEbPKT1_:
  245|  5.30k|   {
  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|  5.30k|      else if constexpr (N == 6) {
  268|  5.30k|         static constexpr auto packed = pack_buffered<Str, 8>();
  269|  5.30k|         uint64_t in{};
  270|  5.30k|         std::memcpy(&in, other, 6);
  271|       |         if constexpr (std::endian::native == std::endian::big) {
  272|       |            in = std::byteswap(in);
  273|       |         }
  274|  5.30k|         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|  5.30k|   }
_ZN3glz10comparitorIL_ZZNS_12decode_indexITnDaXtlNS_4optsELj10ELb1ELb1ELb1ELb1EEE9my_structLm3ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT2_OT4_OT5_OT6_DpOT3_E15KeyWithEndQuoteELm4EcEEbPKT1_:
  245|  7.44k|   {
  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|  7.44k|      else if constexpr (N == 4) {
  286|  7.44k|         static constexpr auto packed = pack<Str, 4>();
  287|  7.44k|         uint32_t in;
  288|  7.44k|         std::memcpy(&in, other, 4);
  289|       |         if constexpr (std::endian::native == std::endian::big) {
  290|       |            in = std::byteswap(in);
  291|       |         }
  292|  7.44k|         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|  7.44k|   }

_ZN3glz10fast_float4spanIKcEC2Ev:
  438|  46.3k|  constexpr span() : ptr(nullptr), length(0) {}
_ZN3glz10fast_float10is_integerIcEEbT_:
 1481|    715|fastfloat_really_inline constexpr bool is_integer(UC c) noexcept {
 1482|    715|  return !(c > UC('9') || c < UC('0'));
  ------------------
  |  Branch (1482:12): [True: 1, False: 714]
  |  Branch (1482:27): [True: 18, False: 696]
  ------------------
 1483|    715|}
_ZN3glz10fast_float11digit_valueIcEEmT_:
 1489|  3.69M|fastfloat_really_inline constexpr uint64_t digit_value(UC c) noexcept {
 1490|  3.69M|  return uint64_t(uint8_t(c) - uint8_t('0'));
 1491|  3.69M|}
_ZN3glz10fast_float4spanIKcEC2EPS2_m:
  436|  33.4k|  constexpr span(T const *_ptr, size_t _length) : ptr(_ptr), length(_length) {}
_ZN3glz10fast_float26loop_parse_if_eight_digitsERPKcS2_Rm:
 1679|  10.2k|                           uint64_t &i) {
 1680|       |  // optimizes better than parse_if_eight_digits_unrolled() for UC = char.
 1681|  2.07M|  while ((std::distance(p, pend) >= 8) &&
  ------------------
  |  Branch (1681:10): [True: 2.07M, False: 1.15k]
  ------------------
 1682|  2.07M|         is_made_of_eight_digits_fast(read8_to_u64(p))) {
  ------------------
  |  Branch (1682:10): [True: 2.06M, False: 9.12k]
  ------------------
 1683|  2.06M|    i = i * 100000000 +
 1684|  2.06M|        parse_eight_digits_unrolled(read8_to_u64(
 1685|  2.06M|            p)); // in rare cases, this will overflow, but that's ok
 1686|  2.06M|    p += 8;
 1687|  2.06M|  }
 1688|  10.2k|}
_ZN3glz10fast_float28is_made_of_eight_digits_fastEm:
 1597|  2.07M|is_made_of_eight_digits_fast(uint64_t val) noexcept {
 1598|  2.07M|  return !((((val + 0x4646464646464646) | (val - 0x3030303030303030)) &
 1599|  2.07M|            0x8080808080808080));
 1600|  2.07M|}
_ZN3glz10fast_float12read8_to_u64IcEEmPKT_:
 1503|  4.57M|read8_to_u64(UC const *chars) {
 1504|  4.57M|  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|  4.57M|  uint64_t val;
 1513|  4.57M|  ::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|  4.57M|  return val;
 1519|  4.57M|}
_ZN3glz10fast_float27parse_eight_digits_unrolledEm:
 1575|  2.50M|parse_eight_digits_unrolled(uint64_t val) {
 1576|  2.50M|  uint64_t const mask = 0x000000FF000000FF;
 1577|  2.50M|  uint64_t const mul1 = 0x000F424000000064; // 100 + (1000000ULL << 32)
 1578|  2.50M|  uint64_t const mul2 = 0x0000271000000001; // 1 + (10000ULL << 32)
 1579|  2.50M|  val -= 0x3030303030303030;
 1580|  2.50M|  val = (val * 10) + (val >> 8); // val = (val * 2561) >> 8;
 1581|  2.50M|  val = (((val & mask) * mul1) + (((val >> 16) & mask) * mul2)) >> 32;
 1582|  2.50M|  return uint32_t(val);
 1583|  2.50M|}
_ZNK3glz10fast_float4spanIKcE3lenEv:
  440|  44.9k|  constexpr size_t len() const noexcept { return length; }
_ZN3glz10fast_float19from_chars_advancedIdcEENS0_19from_chars_result_tIT0_EERNS0_22parsed_number_string_tIS3_EERT_:
 4249|  23.0k|from_chars_advanced(parsed_number_string_t<UC> &pns, T &value) noexcept {
 4250|       |
 4251|  23.0k|  static_assert(is_supported_float_type<T>::value,
 4252|  23.0k|                "only some floating-point types are supported");
 4253|  23.0k|  static_assert(is_supported_char_type<UC>::value,
 4254|  23.0k|                "only char, wchar_t, char16_t and char32_t are supported");
 4255|       |
 4256|  23.0k|  from_chars_result_t<UC> answer;
 4257|       |
 4258|  23.0k|  answer.ec = std::errc(); // be optimistic
 4259|  23.0k|  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|  23.0k|  if (binary_format<T>::min_exponent_fast_path() <= pns.exponent &&
  ------------------
  |  Branch (4265:7): [True: 18.3k, False: 4.68k]
  ------------------
 4266|  18.3k|      pns.exponent <= binary_format<T>::max_exponent_fast_path() &&
  ------------------
  |  Branch (4266:7): [True: 14.5k, False: 3.77k]
  ------------------
 4267|  14.5k|      !pns.too_many_digits) {
  ------------------
  |  Branch (4267:7): [True: 4.84k, False: 9.73k]
  ------------------
 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|  4.84k|    if (!cpp20_and_in_constexpr() && detail::rounds_to_nearest()) {
  ------------------
  |  Branch (4275:9): [True: 4.84k, Folded]
  |  Branch (4275:38): [True: 4.84k, False: 0]
  ------------------
 4276|       |      // We have that fegetround() == FE_TONEAREST.
 4277|       |      // Next is Clinger's fast path.
 4278|  4.84k|      if (pns.mantissa <= binary_format<T>::max_mantissa_fast_path()) {
  ------------------
  |  Branch (4278:11): [True: 4.23k, False: 607]
  ------------------
 4279|  4.23k|        value = T(pns.mantissa);
 4280|  4.23k|        if (pns.exponent < 0) {
  ------------------
  |  Branch (4280:13): [True: 726, False: 3.51k]
  ------------------
 4281|    726|          value = value / binary_format<T>::exact_power_of_ten(-pns.exponent);
 4282|  3.51k|        } else {
 4283|  3.51k|          value = value * binary_format<T>::exact_power_of_ten(pns.exponent);
 4284|  3.51k|        }
 4285|  4.23k|        if (pns.negative) {
  ------------------
  |  Branch (4285:13): [True: 373, False: 3.86k]
  ------------------
 4286|    373|          value = -value;
 4287|    373|        }
 4288|  4.23k|        return answer;
 4289|  4.23k|      }
 4290|  4.84k|    } 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|  4.84k|  }
 4313|  18.8k|  adjusted_mantissa am =
 4314|  18.8k|      compute_float<binary_format<T>>(pns.exponent, pns.mantissa);
 4315|  18.8k|  if (pns.too_many_digits && am.power2 >= 0) {
  ------------------
  |  Branch (4315:7): [True: 15.7k, False: 3.06k]
  |  Branch (4315:30): [True: 15.7k, False: 0]
  ------------------
 4316|  15.7k|    if (am != compute_float<binary_format<T>>(pns.exponent, pns.mantissa + 1)) {
  ------------------
  |  Branch (4316:9): [True: 14.0k, False: 1.68k]
  ------------------
 4317|  14.0k|      am = compute_error<binary_format<T>>(pns.exponent, pns.mantissa);
 4318|  14.0k|    }
 4319|  15.7k|  }
 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|  18.8k|  if (am.power2 < 0) {
  ------------------
  |  Branch (4323:7): [True: 14.0k, False: 4.74k]
  ------------------
 4324|  14.0k|    am = digit_comp<T>(pns, am);
 4325|  14.0k|  }
 4326|  18.8k|  to_float(pns.negative, am, value);
 4327|       |  // Test for over/underflow.
 4328|  18.8k|  if ((pns.mantissa != 0 && am.mantissa == 0 && am.power2 == 0) ||
  ------------------
  |  Branch (4328:8): [True: 18.5k, False: 240]
  |  Branch (4328:29): [True: 1.47k, False: 17.0k]
  |  Branch (4328:49): [True: 90, False: 1.38k]
  ------------------
 4329|  18.7k|      am.power2 == binary_format<T>::infinite_power()) {
  ------------------
  |  Branch (4329:7): [True: 131, False: 18.5k]
  ------------------
 4330|    221|    answer.ec = std::errc::result_out_of_range;
 4331|    221|  }
 4332|  18.8k|  return answer;
 4333|  23.0k|}
_ZN3glz10fast_float13binary_formatIdE22min_exponent_fast_pathEv:
  695|  23.0k|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|  23.0k|  return -22;
  700|  23.0k|#endif
  701|  23.0k|}
_ZN3glz10fast_float13binary_formatIdE22max_exponent_fast_pathEv:
  767|  18.3k|inline constexpr int binary_format<double>::max_exponent_fast_path() {
  768|  18.3k|  return 22;
  769|  18.3k|}
_ZN3glz10fast_float6detail17rounds_to_nearestEv:
 4129|  4.84k|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|  4.84k|  static float volatile fmin = (std::numeric_limits<float>::min)();
 4151|  4.84k|  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|  4.84k|#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|  4.84k|  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|  4.84k|}
_ZN3glz10fast_float13binary_formatIdE22max_mantissa_fast_pathEv:
  777|  4.84k|inline constexpr uint64_t binary_format<double>::max_mantissa_fast_path() {
  778|  4.84k|  return uint64_t(2) << mantissa_explicit_bits();
  779|  4.84k|}
_ZN3glz10fast_float13binary_formatIdE22mantissa_explicit_bitsEv:
  713|   246k|inline constexpr int binary_format<double>::mantissa_explicit_bits() {
  714|   246k|  return 52;
  715|   246k|}
_ZN3glz10fast_float13binary_formatIdE18exact_power_of_tenEl:
 1057|  4.23k|binary_format<double>::exact_power_of_ten(int64_t power) {
 1058|       |  // Work around clang bug https://godbolt.org/z/zedh7rrhc
 1059|  4.23k|  return (void)powers_of_ten[0], powers_of_ten[power];
 1060|  4.23k|}
_ZN3glz10fast_float13compute_floatINS0_13binary_formatIdEEEENS0_17adjusted_mantissaElm:
 2852|  34.5k|compute_float(int64_t q, uint64_t w) noexcept {
 2853|  34.5k|  adjusted_mantissa answer;
 2854|  34.5k|  if ((w == 0) || (q < binary::smallest_power_of_ten())) {
  ------------------
  |  Branch (2854:7): [True: 240, False: 34.3k]
  |  Branch (2854:19): [True: 118, False: 34.1k]
  ------------------
 2855|    358|    answer.power2 = 0;
 2856|    358|    answer.mantissa = 0;
 2857|       |    // result should be zero
 2858|    358|    return answer;
 2859|    358|  }
 2860|  34.1k|  if (q > binary::largest_power_of_ten()) {
  ------------------
  |  Branch (2860:7): [True: 160, False: 34.0k]
  ------------------
 2861|       |    // we want to get infinity:
 2862|    160|    answer.power2 = binary::infinite_power();
 2863|    160|    answer.mantissa = 0;
 2864|    160|    return answer;
 2865|    160|  }
 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|  34.0k|  int lz = leading_zeroes(w);
 2871|  34.0k|  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|  34.0k|  value128 product =
 2880|  34.0k|      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|  34.0k|  int upperbit = int(product.high >> 63);
 2891|  34.0k|  int shift = upperbit + 64 - binary::mantissa_explicit_bits() - 3;
 2892|       |
 2893|  34.0k|  answer.mantissa = product.high >> shift;
 2894|       |
 2895|  34.0k|  answer.power2 = int32_t(detail::power(int32_t(q)) + upperbit - lz -
 2896|  34.0k|                          binary::minimum_exponent());
 2897|  34.0k|  if (answer.power2 <= 0) { // we have a subnormal?
  ------------------
  |  Branch (2897:7): [True: 1.66k, False: 32.3k]
  ------------------
 2898|       |    // Here have that answer.power2 <= 0 so -answer.power2 >= 0
 2899|  1.66k|    if (-answer.power2 + 1 >=
  ------------------
  |  Branch (2899:9): [True: 4, False: 1.65k]
  ------------------
 2900|  1.66k|        64) { // if we have more than 64 bits below the minimum exponent, you
 2901|       |              // have a zero for sure.
 2902|      4|      answer.power2 = 0;
 2903|      4|      answer.mantissa = 0;
 2904|       |      // result should be zero
 2905|      4|      return answer;
 2906|      4|    }
 2907|       |    // next line is safe because -answer.power2 + 1 < 64
 2908|  1.65k|    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|  1.65k|    answer.mantissa += (answer.mantissa & 1); // round up
 2913|  1.65k|    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|  1.65k|    answer.power2 =
 2922|  1.65k|        (answer.mantissa < (uint64_t(1) << binary::mantissa_explicit_bits()))
  ------------------
  |  Branch (2922:9): [True: 1.65k, False: 5]
  ------------------
 2923|  1.65k|            ? 0
 2924|  1.65k|            : 1;
 2925|  1.65k|    return answer;
 2926|  1.66k|  }
 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|  32.3k|  if ((product.low <= 1) && (q >= binary::min_exponent_round_to_even()) &&
  ------------------
  |  Branch (2931:7): [True: 6.72k, False: 25.6k]
  |  Branch (2931:29): [True: 6.25k, False: 465]
  ------------------
 2932|  6.25k|      (q <= binary::max_exponent_round_to_even()) &&
  ------------------
  |  Branch (2932:7): [True: 5.80k, False: 456]
  ------------------
 2933|  5.80k|      ((answer.mantissa & 3) == 1)) { // we may fall between two floats!
  ------------------
  |  Branch (2933:7): [True: 3.89k, False: 1.90k]
  ------------------
 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|  3.89k|    if ((answer.mantissa << shift) == product.high) {
  ------------------
  |  Branch (2939:9): [True: 2.51k, False: 1.38k]
  ------------------
 2940|  2.51k|      answer.mantissa &= ~uint64_t(1); // flip it so that we do not round up
 2941|  2.51k|    }
 2942|  3.89k|  }
 2943|       |
 2944|  32.3k|  answer.mantissa += (answer.mantissa & 1); // round up
 2945|  32.3k|  answer.mantissa >>= 1;
 2946|  32.3k|  if (answer.mantissa >= (uint64_t(2) << binary::mantissa_explicit_bits())) {
  ------------------
  |  Branch (2946:7): [True: 1.24k, False: 31.1k]
  ------------------
 2947|  1.24k|    answer.mantissa = (uint64_t(1) << binary::mantissa_explicit_bits());
 2948|  1.24k|    answer.power2++; // undo previous addition
 2949|  1.24k|  }
 2950|       |
 2951|  32.3k|  answer.mantissa &= ~(uint64_t(1) << binary::mantissa_explicit_bits());
 2952|  32.3k|  if (answer.power2 >= binary::infinite_power()) { // infinity
  ------------------
  |  Branch (2952:7): [True: 10, False: 32.3k]
  ------------------
 2953|     10|    answer.power2 = binary::infinite_power();
 2954|     10|    answer.mantissa = 0;
 2955|     10|  }
 2956|  32.3k|  return answer;
 2957|  34.0k|}
_ZN3glz10fast_float17adjusted_mantissaC2Ev:
  568|  62.6k|  adjusted_mantissa() = default;
_ZN3glz10fast_float13binary_formatIdE21smallest_power_of_tenEv:
 1077|  34.3k|inline constexpr int binary_format<double>::smallest_power_of_ten() {
 1078|  34.3k|  return -342;
 1079|  34.3k|}
_ZN3glz10fast_float13binary_formatIdE20largest_power_of_tenEv:
 1068|  34.1k|template <> inline constexpr int binary_format<double>::largest_power_of_ten() {
 1069|  34.1k|  return 308;
 1070|  34.1k|}
_ZN3glz10fast_float14leading_zeroesEm:
  488|  55.5k|leading_zeroes(uint64_t input_num) {
  489|  55.5k|  assert(input_num > 0);
  ------------------
  |  Branch (489:3): [True: 55.5k, False: 0]
  ------------------
  490|  55.5k|  if (cpp20_and_in_constexpr()) {
  ------------------
  |  Branch (490:7): [Folded, False: 55.5k]
  ------------------
  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|  55.5k|  return __builtin_clzll(input_num);
  505|  55.5k|#endif
  506|  55.5k|}
_ZN3glz10fast_float29compute_product_approximationILi55EEENS0_8value128Elm:
 2771|  48.0k|compute_product_approximation(int64_t q, uint64_t w) {
 2772|  48.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|  48.0k|  value128 firstproduct =
 2777|  48.0k|      full_multiplication(w, powers::power_of_five_128[index]);
 2778|  48.0k|  static_assert((bit_precision >= 0) && (bit_precision <= 64),
 2779|  48.0k|                " precision should  be in (0,64]");
 2780|  48.0k|  constexpr uint64_t precision_mask =
 2781|  48.0k|      (bit_precision < 64) ? (uint64_t(0xFFFFFFFFFFFFFFFF) >> bit_precision)
  ------------------
  |  Branch (2781:7): [True: 0, Folded]
  ------------------
 2782|  48.0k|                           : uint64_t(0xFFFFFFFFFFFFFFFF);
 2783|  48.0k|  if ((firstproduct.high & precision_mask) ==
  ------------------
  |  Branch (2783:7): [True: 8.61k, False: 39.4k]
  ------------------
 2784|  48.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.61k|    value128 secondproduct =
 2789|  8.61k|        full_multiplication(w, powers::power_of_five_128[index + 1]);
 2790|  8.61k|    firstproduct.low += secondproduct.high;
 2791|  8.61k|    if (secondproduct.high > firstproduct.low) {
  ------------------
  |  Branch (2791:9): [True: 2.76k, False: 5.85k]
  ------------------
 2792|  2.76k|      firstproduct.high++;
 2793|  2.76k|    }
 2794|  8.61k|  }
 2795|  48.0k|  return firstproduct;
 2796|  48.0k|}
_ZN3glz10fast_float19full_multiplicationEmm:
  540|  56.7k|full_multiplication(uint64_t a, uint64_t b) {
  541|  56.7k|  if (cpp20_and_in_constexpr()) {
  ------------------
  |  Branch (541:7): [Folded, False: 56.7k]
  ------------------
  542|      0|    value128 answer;
  543|      0|    answer.low = umul128_generic(a, b, &answer.high);
  544|      0|    return answer;
  545|      0|  }
  546|  56.7k|  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|  56.7k|  answer.low = uint64_t(r);
  558|  56.7k|  answer.high = uint64_t(r >> 64);
  559|       |#else
  560|       |  answer.low = umul128_generic(a, b, &answer.high);
  561|       |#endif
  562|  56.7k|  return answer;
  563|  56.7k|}
_ZN3glz10fast_float8value128C2Ev:
  454|  56.7k|  constexpr value128() : low(0), high(0) {}
_ZN3glz10fast_float6detail5powerEi:
 2814|  48.0k|constexpr fastfloat_really_inline int32_t power(int32_t q) noexcept {
 2815|  48.0k|  return (((152170 + 65536) * q) >> 16) + 63;
 2816|  48.0k|}
_ZN3glz10fast_float13binary_formatIdE16minimum_exponentEv:
  742|  62.1k|template <> inline constexpr int binary_format<double>::minimum_exponent() {
  743|  62.1k|  return -1023;
  744|  62.1k|}
_ZN3glz10fast_float13binary_formatIdE26min_exponent_round_to_evenEv:
  733|  6.72k|inline constexpr int binary_format<double>::min_exponent_round_to_even() {
  734|  6.72k|  return -4;
  735|  6.72k|}
_ZN3glz10fast_float13binary_formatIdE26max_exponent_round_to_evenEv:
  723|  6.25k|inline constexpr int binary_format<double>::max_exponent_round_to_even() {
  724|  6.25k|  return 23;
  725|  6.25k|}
_ZNK3glz10fast_float17adjusted_mantissaneERKS1_:
  574|  15.7k|  constexpr bool operator!=(adjusted_mantissa const &o) const {
  575|  15.7k|    return mantissa != o.mantissa || power2 != o.power2;
  ------------------
  |  Branch (575:12): [True: 14.0k, False: 1.68k]
  |  Branch (575:38): [True: 0, False: 1.68k]
  ------------------
  576|  15.7k|  }
_ZN3glz10fast_float13compute_errorINS0_13binary_formatIdEEEENS0_17adjusted_mantissaElm:
 2837|  14.0k|compute_error(int64_t q, uint64_t w) noexcept {
 2838|  14.0k|  int lz = leading_zeroes(w);
 2839|  14.0k|  w <<= lz;
 2840|  14.0k|  value128 product =
 2841|  14.0k|      compute_product_approximation<binary::mantissa_explicit_bits() + 3>(q, w);
 2842|  14.0k|  return compute_error_scaled<binary>(q, product.high, lz);
 2843|  14.0k|}
_ZN3glz10fast_float20compute_error_scaledINS0_13binary_formatIdEEEENS0_17adjusted_mantissaElmi:
 2823|  14.0k|compute_error_scaled(int64_t q, uint64_t w, int lz) noexcept {
 2824|  14.0k|  int hilz = int(w >> 63) ^ 1;
 2825|  14.0k|  adjusted_mantissa answer;
 2826|  14.0k|  answer.mantissa = w << hilz;
 2827|  14.0k|  int bias = binary::mantissa_explicit_bits() - binary::minimum_exponent();
 2828|  14.0k|  answer.power2 = int32_t(detail::power(int32_t(q)) + bias - hilz - lz - 62 +
 2829|  14.0k|                          invalid_am_bias);
 2830|  14.0k|  return answer;
 2831|  14.0k|}
_ZN3glz10fast_float10digit_compIdcEENS0_17adjusted_mantissaERNS0_22parsed_number_string_tIT0_EES2_:
 4034|  14.0k|digit_comp(parsed_number_string_t<UC> &num, adjusted_mantissa am) noexcept {
 4035|       |  // remove the invalid exponent bias
 4036|  14.0k|  am.power2 -= invalid_am_bias;
 4037|       |
 4038|  14.0k|  int32_t sci_exp = scientific_exponent(num);
 4039|  14.0k|  size_t max_digits = binary_format<T>::max_digits();
 4040|  14.0k|  size_t digits = 0;
 4041|  14.0k|  bigint bigmant;
 4042|  14.0k|  parse_mantissa(bigmant, num, max_digits, digits);
 4043|       |  // can't underflow, since digits is at most max_digits.
 4044|  14.0k|  int32_t exponent = sci_exp + 1 - int32_t(digits);
 4045|  14.0k|  if (exponent >= 0) {
  ------------------
  |  Branch (4045:7): [True: 3.71k, False: 10.3k]
  ------------------
 4046|  3.71k|    return positive_digit_comp<T>(bigmant, exponent);
 4047|  10.3k|  } else {
 4048|  10.3k|    return negative_digit_comp<T>(bigmant, am, exponent);
 4049|  10.3k|  }
 4050|  14.0k|}
_ZN3glz10fast_float19scientific_exponentIcEEiRNS0_22parsed_number_string_tIT_EE:
 3640|  14.0k|scientific_exponent(parsed_number_string_t<UC> &num) noexcept {
 3641|  14.0k|  uint64_t mantissa = num.mantissa;
 3642|  14.0k|  int32_t exponent = int32_t(num.exponent);
 3643|  70.2k|  while (mantissa >= 10000) {
  ------------------
  |  Branch (3643:10): [True: 56.2k, False: 14.0k]
  ------------------
 3644|  56.2k|    mantissa /= 10000;
 3645|  56.2k|    exponent += 4;
 3646|  56.2k|  }
 3647|  28.1k|  while (mantissa >= 100) {
  ------------------
  |  Branch (3647:10): [True: 14.0k, False: 14.0k]
  ------------------
 3648|  14.0k|    mantissa /= 100;
 3649|  14.0k|    exponent += 2;
 3650|  14.0k|  }
 3651|  14.0k|  while (mantissa >= 10) {
  ------------------
  |  Branch (3651:10): [True: 0, False: 14.0k]
  ------------------
 3652|      0|    mantissa /= 10;
 3653|      0|    exponent += 1;
 3654|      0|  }
 3655|  14.0k|  return exponent;
 3656|  14.0k|}
_ZN3glz10fast_float13binary_formatIdE10max_digitsEv:
 1085|  14.0k|template <> inline constexpr size_t binary_format<double>::max_digits() {
 1086|  14.0k|  return 769;
 1087|  14.0k|}
_ZN3glz10fast_float6bigintC2Ev:
 3399|  14.0k|  GLZ_FASTFLOAT_CONSTEXPR20 bigint() : vec() {}
_ZN3glz10fast_float8stackvecILt62EEC2Ev:
 3006|   158k|  stackvec() = default;
_ZN3glz10fast_float14parse_mantissaIcEEvRNS0_6bigintERNS0_22parsed_number_string_tIT_EEmRm:
 3859|  14.0k|               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|  14.0k|  size_t counter = 0;
 3864|  14.0k|  digits = 0;
 3865|  14.0k|  limb value = 0;
 3866|  14.0k|#ifdef GLZ_FASTFLOAT_64BIT_LIMB
 3867|  14.0k|  size_t step = 19;
 3868|       |#else
 3869|       |  size_t step = 9;
 3870|       |#endif
 3871|       |
 3872|       |  // process all integer digits.
 3873|  14.0k|  UC const *p = num.integer.ptr;
 3874|  14.0k|  UC const *pend = p + num.integer.len();
 3875|  14.0k|  skip_zeros(p, pend);
 3876|       |  // process all digits, in increments of step per loop
 3877|   141k|  while (p != pend) {
  ------------------
  |  Branch (3877:10): [True: 129k, False: 11.3k]
  ------------------
 3878|   369k|    while ((std::distance(p, pend) >= 8) && (step - counter >= 8) &&
  ------------------
  |  Branch (3878:12): [True: 351k, False: 17.5k]
  |  Branch (3878:45): [True: 240k, False: 111k]
  ------------------
 3879|   240k|           (max_digits - digits >= 8)) {
  ------------------
  |  Branch (3879:12): [True: 239k, False: 651]
  ------------------
 3880|   239k|      parse_eight_digits(p, value, counter, digits);
 3881|   239k|    }
 3882|   502k|    while (counter < step && p != pend && digits < max_digits) {
  ------------------
  |  Branch (3882:12): [True: 386k, False: 116k]
  |  Branch (3882:30): [True: 374k, False: 12.1k]
  |  Branch (3882:43): [True: 372k, False: 1.31k]
  ------------------
 3883|   372k|      parse_one_digit(p, value, counter, digits);
 3884|   372k|    }
 3885|   129k|    if (digits == max_digits) {
  ------------------
  |  Branch (3885:9): [True: 2.73k, False: 127k]
  ------------------
 3886|       |      // add the temporary value, then check if we've truncated any digits
 3887|  2.73k|      add_native(result, limb(powers_of_ten_uint64[counter]), value);
 3888|  2.73k|      bool truncated = is_truncated(p, pend);
 3889|  2.73k|      if (num.fraction.ptr != nullptr) {
  ------------------
  |  Branch (3889:11): [True: 1.55k, False: 1.17k]
  ------------------
 3890|  1.55k|        truncated |= is_truncated(num.fraction);
 3891|  1.55k|      }
 3892|  2.73k|      if (truncated) {
  ------------------
  |  Branch (3892:11): [True: 1.39k, False: 1.33k]
  ------------------
 3893|  1.39k|        round_up_bigint(result, digits);
 3894|  1.39k|      }
 3895|  2.73k|      return;
 3896|   127k|    } else {
 3897|   127k|      add_native(result, limb(powers_of_ten_uint64[counter]), value);
 3898|   127k|      counter = 0;
 3899|   127k|      value = 0;
 3900|   127k|    }
 3901|   129k|  }
 3902|       |
 3903|       |  // add our fraction digits, if they're available.
 3904|  11.3k|  if (num.fraction.ptr != nullptr) {
  ------------------
  |  Branch (3904:7): [True: 7.18k, False: 4.14k]
  ------------------
 3905|  7.18k|    p = num.fraction.ptr;
 3906|  7.18k|    pend = p + num.fraction.len();
 3907|  7.18k|    if (digits == 0) {
  ------------------
  |  Branch (3907:9): [True: 517, False: 6.66k]
  ------------------
 3908|    517|      skip_zeros(p, pend);
 3909|    517|    }
 3910|       |    // process all digits, in increments of step per loop
 3911|   111k|    while (p != pend) {
  ------------------
  |  Branch (3911:12): [True: 106k, False: 4.77k]
  ------------------
 3912|   310k|      while ((std::distance(p, pend) >= 8) && (step - counter >= 8) &&
  ------------------
  |  Branch (3912:14): [True: 303k, False: 6.95k]
  |  Branch (3912:47): [True: 204k, False: 98.6k]
  ------------------
 3913|   204k|             (max_digits - digits >= 8)) {
  ------------------
  |  Branch (3913:14): [True: 203k, False: 992]
  ------------------
 3914|   203k|        parse_eight_digits(p, value, counter, digits);
 3915|   203k|      }
 3916|   428k|      while (counter < step && p != pend && digits < max_digits) {
  ------------------
  |  Branch (3916:14): [True: 328k, False: 99.7k]
  |  Branch (3916:32): [True: 323k, False: 5.01k]
  |  Branch (3916:45): [True: 321k, False: 1.88k]
  ------------------
 3917|   321k|        parse_one_digit(p, value, counter, digits);
 3918|   321k|      }
 3919|   106k|      if (digits == max_digits) {
  ------------------
  |  Branch (3919:11): [True: 2.41k, False: 104k]
  ------------------
 3920|       |        // add the temporary value, then check if we've truncated any digits
 3921|  2.41k|        add_native(result, limb(powers_of_ten_uint64[counter]), value);
 3922|  2.41k|        bool truncated = is_truncated(p, pend);
 3923|  2.41k|        if (truncated) {
  ------------------
  |  Branch (3923:13): [True: 1.29k, False: 1.11k]
  ------------------
 3924|  1.29k|          round_up_bigint(result, digits);
 3925|  1.29k|        }
 3926|  2.41k|        return;
 3927|   104k|      } else {
 3928|   104k|        add_native(result, limb(powers_of_ten_uint64[counter]), value);
 3929|   104k|        counter = 0;
 3930|   104k|        value = 0;
 3931|   104k|      }
 3932|   106k|    }
 3933|  7.18k|  }
 3934|       |
 3935|  8.91k|  if (counter != 0) {
  ------------------
  |  Branch (3935:7): [True: 0, False: 8.91k]
  ------------------
 3936|      0|    add_native(result, limb(powers_of_ten_uint64[counter]), value);
 3937|      0|  }
 3938|  8.91k|}
_ZN3glz10fast_float10skip_zerosIcEEvRPKT_S4_:
 3773|  14.5k|skip_zeros(UC const *&first, UC const *last) noexcept {
 3774|  14.5k|  uint64_t val;
 3775|  14.9k|  while (!cpp20_and_in_constexpr() &&
  ------------------
  |  Branch (3775:10): [True: 14.9k, Folded]
  ------------------
 3776|  14.9k|         std::distance(first, last) >= int_cmp_len<UC>()) {
  ------------------
  |  Branch (3776:10): [True: 11.4k, False: 3.48k]
  ------------------
 3777|  11.4k|    ::memcpy(&val, first, sizeof(uint64_t));
 3778|  11.4k|    if (val != int_cmp_zeros<UC>()) {
  ------------------
  |  Branch (3778:9): [True: 11.0k, False: 348]
  ------------------
 3779|  11.0k|      break;
 3780|  11.0k|    }
 3781|    348|    first += int_cmp_len<UC>();
 3782|    348|  }
 3783|  15.5k|  while (first != last) {
  ------------------
  |  Branch (3783:10): [True: 14.9k, False: 517]
  ------------------
 3784|  14.9k|    if (*first != UC('0')) {
  ------------------
  |  Branch (3784:9): [True: 14.0k, False: 930]
  ------------------
 3785|  14.0k|      break;
 3786|  14.0k|    }
 3787|    930|    first++;
 3788|    930|  }
 3789|  14.5k|}
_ZN3glz10fast_float11int_cmp_lenIcEEiv:
 1180|   245k|template <typename UC> constexpr int int_cmp_len() {
 1181|   245k|  return sizeof(uint64_t) / sizeof(UC);
 1182|   245k|}
_ZN3glz10fast_float13int_cmp_zerosIcEEmv:
 1170|   124k|template <typename UC> constexpr uint64_t int_cmp_zeros() {
 1171|   124k|  static_assert((sizeof(UC) == 1) || (sizeof(UC) == 2) || (sizeof(UC) == 4),
 1172|   124k|                "Unsupported character size");
 1173|   124k|  return (sizeof(UC) == 1) ? 0x3030303030303030
  ------------------
  |  Branch (1173:10): [True: 124k, Folded]
  ------------------
 1174|   124k|         : (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|   124k|}
_ZN3glz10fast_float18parse_eight_digitsIcEEvRPKT_RmS6_S6_:
 3824|   443k|                   size_t &count) noexcept {
 3825|   443k|  value = value * 100000000 + parse_eight_digits_unrolled(p);
 3826|   443k|  p += 8;
 3827|   443k|  counter += 8;
 3828|   443k|  count += 8;
 3829|   443k|}
_ZN3glz10fast_float27parse_eight_digits_unrolledIcEEjPKT_:
 1588|   443k|parse_eight_digits_unrolled(UC const *chars) noexcept {
 1589|   443k|  if (cpp20_and_in_constexpr() || !has_simd_opt<UC>()) {
  ------------------
  |  Branch (1589:7): [Folded, False: 0]
  |  Branch (1589:35): [True: 0, Folded]
  ------------------
 1590|   443k|    return parse_eight_digits_unrolled(read8_to_u64(chars)); // truncation okay
 1591|   443k|  }
 1592|      0|  return parse_eight_digits_unrolled(simd_read8_to_u64(chars));
 1593|   443k|}
_ZN3glz10fast_float15parse_one_digitIcEEvRPKT_RmS6_S6_:
 3834|   694k|                size_t &count) noexcept {
 3835|   694k|  value = value * 10 + limb(*p - UC('0'));
 3836|   694k|  p++;
 3837|   694k|  counter++;
 3838|   694k|  count++;
 3839|   694k|}
_ZN3glz10fast_float10add_nativeERNS0_6bigintEmm:
 3842|   239k|add_native(bigint &big, limb power, limb value) noexcept {
 3843|   239k|  big.mul(power);
 3844|   239k|  big.add(value);
 3845|   239k|}
_ZN3glz10fast_float6bigint3mulEm:
 3552|   239k|  GLZ_FASTFLOAT_CONSTEXPR20 bool mul(limb y) noexcept { return small_mul(vec, y); }
_ZN3glz10fast_float9small_mulILt62EEEbRNS0_8stackvecIXT_EEEm:
 3249|   433k|                                            limb y) noexcept {
 3250|   433k|  limb carry = 0;
 3251|  7.51M|  for (size_t index = 0; index < vec.len(); index++) {
  ------------------
  |  Branch (3251:26): [True: 7.07M, False: 433k]
  ------------------
 3252|  7.07M|    vec[index] = scalar_mul(vec[index], y, carry);
 3253|  7.07M|  }
 3254|   433k|  if (carry != 0) {
  ------------------
  |  Branch (3254:7): [True: 394k, False: 39.5k]
  ------------------
 3255|   394k|    GLZ_FASTFLOAT_TRY(vec.try_push(carry));
  ------------------
  |  |  354|   394k|  {                                                                            \
  |  |  355|   394k|    if (!(x))                                                                  \
  |  |  ------------------
  |  |  |  Branch (355:9): [True: 0, False: 394k]
  |  |  ------------------
  |  |  356|   394k|      return false;                                                            \
  |  |  357|   394k|  }
  ------------------
 3256|   394k|  }
 3257|   433k|  return true;
 3258|   433k|}
_ZNK3glz10fast_float8stackvecILt62EE3lenEv:
 3039|  9.53M|  constexpr size_t len() const noexcept { return length; }
_ZN3glz10fast_float10scalar_mulEmmRm:
 3196|  7.07M|scalar_mul(limb x, limb y, limb &carry) noexcept {
 3197|  7.07M|#ifdef GLZ_FASTFLOAT_64BIT_LIMB
 3198|  7.07M|#if defined(__SIZEOF_INT128__)
 3199|       |  // GCC and clang both define it as an extension.
 3200|  7.07M|  __uint128_t z = __uint128_t(x) * __uint128_t(y) + __uint128_t(carry);
 3201|  7.07M|  carry = limb(z >> limb_bits);
 3202|  7.07M|  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|  7.07M|}
_ZN3glz10fast_float8stackvecILt62EEixEm:
 3017|  18.3M|  GLZ_FASTFLOAT_CONSTEXPR14 limb &operator[](size_t index) noexcept {
 3018|  18.3M|    GLZ_FASTFLOAT_DEBUG_ASSERT(index < length);
  ------------------
  |  |  349|  18.3M|  { ((void)(x)); }
  ------------------
 3019|  18.3M|    return data[index];
 3020|  18.3M|  }
_ZN3glz10fast_float8stackvecILt62EE8try_pushEm:
 3052|   412k|  GLZ_FASTFLOAT_CONSTEXPR14 bool try_push(limb value) noexcept {
 3053|   412k|    if (len() < capacity()) {
  ------------------
  |  Branch (3053:9): [True: 412k, False: 0]
  ------------------
 3054|   412k|      push_unchecked(value);
 3055|   412k|      return true;
 3056|   412k|    } else {
 3057|      0|      return false;
 3058|      0|    }
 3059|   412k|  }
_ZNK3glz10fast_float8stackvecILt62EE8capacityEv:
 3043|   721k|  constexpr size_t capacity() const noexcept { return size; }
_ZN3glz10fast_float8stackvecILt62EE14push_uncheckedEm:
 3046|   423k|  GLZ_FASTFLOAT_CONSTEXPR14 void push_unchecked(limb value) noexcept {
 3047|   423k|    data[length] = value;
 3048|   423k|    length++;
 3049|   423k|  }
_ZN3glz10fast_float6bigint3addEm:
 3554|   239k|  GLZ_FASTFLOAT_CONSTEXPR20 bool add(limb y) noexcept { return small_add(vec, y); }
_ZN3glz10fast_float9small_addILt62EEEbRNS0_8stackvecIXT_EEEm:
 3242|   239k|small_add(stackvec<size> &vec, limb y) noexcept {
 3243|   239k|  return small_add_from(vec, y, 0);
 3244|   239k|}
_ZN3glz10fast_float14small_add_fromILt62EEEbRNS0_8stackvecIXT_EEEmm:
 3224|   239k|                                                 size_t start) noexcept {
 3225|   239k|  size_t index = start;
 3226|   239k|  limb carry = y;
 3227|   239k|  bool overflow;
 3228|   290k|  while (carry != 0 && index < vec.len()) {
  ------------------
  |  Branch (3228:10): [True: 67.9k, False: 222k]
  |  Branch (3228:24): [True: 51.8k, False: 16.1k]
  ------------------
 3229|  51.8k|    vec[index] = scalar_add(vec[index], carry, overflow);
 3230|  51.8k|    carry = limb(overflow);
 3231|  51.8k|    index += 1;
 3232|  51.8k|  }
 3233|   239k|  if (carry != 0) {
  ------------------
  |  Branch (3233:7): [True: 16.1k, False: 222k]
  ------------------
 3234|  16.1k|    GLZ_FASTFLOAT_TRY(vec.try_push(carry));
  ------------------
  |  |  354|  16.1k|  {                                                                            \
  |  |  355|  16.1k|    if (!(x))                                                                  \
  |  |  ------------------
  |  |  |  Branch (355:9): [True: 0, False: 16.1k]
  |  |  ------------------
  |  |  356|  16.1k|      return false;                                                            \
  |  |  357|  16.1k|  }
  ------------------
 3235|  16.1k|  }
 3236|   239k|  return true;
 3237|   239k|}
_ZN3glz10fast_float10scalar_addEmmRb:
 3176|  2.73M|scalar_add(limb x, limb y, bool &overflow) noexcept {
 3177|  2.73M|  limb z;
 3178|       |// gcc and clang
 3179|  2.73M|#if defined(__has_builtin)
 3180|  2.73M|#if __has_builtin(__builtin_add_overflow)
 3181|  2.73M|  if (!cpp20_and_in_constexpr()) {
  ------------------
  |  Branch (3181:7): [True: 2.73M, Folded]
  ------------------
 3182|  2.73M|    overflow = __builtin_add_overflow(x, y, &z);
 3183|  2.73M|    return z;
 3184|  2.73M|  }
 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|  2.73M|}
_ZN3glz10fast_float12is_truncatedIcEEbPKT_S4_:
 3795|  6.70k|is_truncated(UC const *first, UC const *last) noexcept {
 3796|       |  // do 8-bit optimizations, can just compare to 8 literal 0s.
 3797|  6.70k|  uint64_t val;
 3798|   118k|  while (!cpp20_and_in_constexpr() &&
  ------------------
  |  Branch (3798:10): [True: 118k, Folded]
  ------------------
 3799|   118k|         std::distance(first, last) >= int_cmp_len<UC>()) {
  ------------------
  |  Branch (3799:10): [True: 112k, False: 5.68k]
  ------------------
 3800|   112k|    ::memcpy(&val, first, sizeof(uint64_t));
 3801|   112k|    if (val != int_cmp_zeros<UC>()) {
  ------------------
  |  Branch (3801:9): [True: 1.01k, False: 111k]
  ------------------
 3802|  1.01k|      return true;
 3803|  1.01k|    }
 3804|   111k|    first += int_cmp_len<UC>();
 3805|   111k|  }
 3806|  13.0k|  while (first != last) {
  ------------------
  |  Branch (3806:10): [True: 9.17k, False: 3.84k]
  ------------------
 3807|  9.17k|    if (*first != UC('0')) {
  ------------------
  |  Branch (3807:9): [True: 1.84k, False: 7.32k]
  ------------------
 3808|  1.84k|      return true;
 3809|  1.84k|    }
 3810|  7.32k|    ++first;
 3811|  7.32k|  }
 3812|  3.84k|  return false;
 3813|  5.68k|}
_ZN3glz10fast_float12is_truncatedIcEEbNS0_4spanIKT_EE:
 3817|  1.55k|is_truncated(span<UC const> s) noexcept {
 3818|  1.55k|  return is_truncated(s.ptr, s.ptr + s.len());
 3819|  1.55k|}
_ZN3glz10fast_float15round_up_bigintERNS0_6bigintERm:
 3848|  2.69k|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|  2.69k|  add_native(big, 10, 1);
 3852|  2.69k|  count++;
 3853|  2.69k|}
_ZN3glz10fast_float19positive_digit_compIdEENS0_17adjusted_mantissaERNS0_6bigintEi:
 3942|  3.71k|positive_digit_comp(bigint &bigmant, int32_t exponent) noexcept {
 3943|  3.71k|  GLZ_FASTFLOAT_ASSERT(bigmant.pow10(uint32_t(exponent)));
  ------------------
  |  |  344|  3.71k|  { ((void)(x)); }
  ------------------
 3944|  3.71k|  adjusted_mantissa answer;
 3945|  3.71k|  bool truncated;
 3946|  3.71k|  answer.mantissa = bigmant.hi64(truncated);
 3947|  3.71k|  int bias = binary_format<T>::mantissa_explicit_bits() -
 3948|  3.71k|             binary_format<T>::minimum_exponent();
 3949|  3.71k|  answer.power2 = bigmant.bit_length() - 64 + bias;
 3950|       |
 3951|  3.71k|  round<T>(answer, [truncated](adjusted_mantissa &a, int32_t shift) {
 3952|  3.71k|    round_nearest_tie_even(
 3953|  3.71k|        a, shift,
 3954|  3.71k|        [truncated](bool is_odd, bool is_halfway, bool is_above) -> bool {
 3955|  3.71k|          return is_above || (is_halfway && truncated) ||
 3956|  3.71k|                 (is_odd && is_halfway);
 3957|  3.71k|        });
 3958|  3.71k|  });
 3959|       |
 3960|  3.71k|  return answer;
 3961|  3.71k|}
_ZN3glz10fast_float6bigint5pow10Ej:
 3591|  3.71k|  GLZ_FASTFLOAT_CONSTEXPR20 bool pow10(uint32_t exp) noexcept {
 3592|  3.71k|    GLZ_FASTFLOAT_TRY(pow5(exp));
  ------------------
  |  |  354|  3.71k|  {                                                                            \
  |  |  355|  3.71k|    if (!(x))                                                                  \
  |  |  ------------------
  |  |  |  Branch (355:9): [True: 0, False: 3.71k]
  |  |  ------------------
  |  |  356|  3.71k|      return false;                                                            \
  |  |  357|  3.71k|  }
  ------------------
 3593|  3.71k|    return pow2(exp);
 3594|  3.71k|  }
_ZN3glz10fast_float6bigint4pow5Ej:
 3560|  14.0k|  GLZ_FASTFLOAT_CONSTEXPR20 bool pow5(uint32_t exp) noexcept {
 3561|       |    // multiply by a power of 5
 3562|  14.0k|    size_t large_length = sizeof(large_power_of_5) / sizeof(limb);
 3563|  14.0k|    limb_span large = limb_span(large_power_of_5, large_length);
 3564|  47.5k|    while (exp >= large_step) {
  ------------------
  |  Branch (3564:12): [True: 33.5k, False: 14.0k]
  ------------------
 3565|  33.5k|      GLZ_FASTFLOAT_TRY(large_mul(vec, large));
  ------------------
  |  |  354|  33.5k|  {                                                                            \
  |  |  355|  33.5k|    if (!(x))                                                                  \
  |  |  ------------------
  |  |  |  Branch (355:9): [True: 0, False: 33.5k]
  |  |  ------------------
  |  |  356|  33.5k|      return false;                                                            \
  |  |  357|  33.5k|  }
  ------------------
 3566|  33.5k|      exp -= large_step;
 3567|  33.5k|    }
 3568|  14.0k|#ifdef GLZ_FASTFLOAT_64BIT_LIMB
 3569|  14.0k|    uint32_t small_step = 27;
 3570|  14.0k|    limb max_native = 7450580596923828125UL;
 3571|       |#else
 3572|       |    uint32_t small_step = 13;
 3573|       |    limb max_native = 1220703125U;
 3574|       |#endif
 3575|  28.8k|    while (exp >= small_step) {
  ------------------
  |  Branch (3575:12): [True: 14.7k, False: 14.0k]
  ------------------
 3576|  14.7k|      GLZ_FASTFLOAT_TRY(small_mul(vec, max_native));
  ------------------
  |  |  354|  14.7k|  {                                                                            \
  |  |  355|  14.7k|    if (!(x))                                                                  \
  |  |  ------------------
  |  |  |  Branch (355:9): [True: 0, False: 14.7k]
  |  |  ------------------
  |  |  356|  14.7k|      return false;                                                            \
  |  |  357|  14.7k|  }
  ------------------
 3577|  14.7k|      exp -= small_step;
 3578|  14.7k|    }
 3579|  14.0k|    if (exp != 0) {
  ------------------
  |  Branch (3579:9): [True: 12.3k, False: 1.72k]
  ------------------
 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|  12.3k|      GLZ_FASTFLOAT_TRY(small_mul(
  ------------------
  |  |  354|  12.3k|  {                                                                            \
  |  |  355|  12.3k|    if (!(x))                                                                  \
  |  |  ------------------
  |  |  |  Branch (355:9): [True: 0, False: 12.3k]
  |  |  ------------------
  |  |  356|  12.3k|      return false;                                                            \
  |  |  357|  12.3k|  }
  ------------------
 3584|  12.3k|          vec, limb(((void)small_power_of_5[0], small_power_of_5[exp]))));
 3585|  12.3k|    }
 3586|       |
 3587|  14.0k|    return true;
 3588|  14.0k|  }
_ZN3glz10fast_float4spanImEC2EPKmm:
  436|   215k|  constexpr span(T const *_ptr, size_t _length) : ptr(_ptr), length(_length) {}
_ZN3glz10fast_float9large_mulILt62EEEbRNS0_8stackvecIXT_EEENS0_4spanImEE:
 3329|  33.5k|GLZ_FASTFLOAT_CONSTEXPR20 bool large_mul(stackvec<size> &x, limb_span y) noexcept {
 3330|  33.5k|  if (y.len() == 1) {
  ------------------
  |  Branch (3330:7): [True: 0, False: 33.5k]
  ------------------
 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|  33.5k|  } else {
 3333|  33.5k|    GLZ_FASTFLOAT_TRY(long_mul(x, y));
  ------------------
  |  |  354|  33.5k|  {                                                                            \
  |  |  355|  33.5k|    if (!(x))                                                                  \
  |  |  ------------------
  |  |  |  Branch (355:9): [True: 0, False: 33.5k]
  |  |  ------------------
  |  |  356|  33.5k|      return false;                                                            \
  |  |  357|  33.5k|  }
  ------------------
 3334|  33.5k|  }
 3335|  33.5k|  return true;
 3336|  33.5k|}
_ZNK3glz10fast_float4spanImE3lenEv:
  440|  3.01M|  constexpr size_t len() const noexcept { return length; }
_ZNK3glz10fast_float4spanImEixEm:
  442|  2.04M|  GLZ_FASTFLOAT_CONSTEXPR14 const T &operator[](size_t index) const noexcept {
  443|  2.04M|    GLZ_FASTFLOAT_DEBUG_ASSERT(index < length);
  ------------------
  |  |  349|  2.04M|  { ((void)(x)); }
  ------------------
  444|  2.04M|    return ptr[index];
  445|  2.04M|  }
_ZN3glz10fast_float8long_mulILt62EEEbRNS0_8stackvecIXT_EEENS0_4spanImEE:
 3301|  33.5k|GLZ_FASTFLOAT_CONSTEXPR20 bool long_mul(stackvec<size> &x, limb_span y) noexcept {
 3302|  33.5k|  limb_span xs = limb_span(x.data, x.len());
 3303|  33.5k|  stackvec<size> z(xs);
 3304|  33.5k|  limb_span zs = limb_span(z.data, z.len());
 3305|       |
 3306|  33.5k|  if (y.len() != 0) {
  ------------------
  |  Branch (3306:7): [True: 33.5k, False: 0]
  ------------------
 3307|  33.5k|    limb y0 = y[0];
 3308|  33.5k|    GLZ_FASTFLOAT_TRY(small_mul(x, y0));
  ------------------
  |  |  354|  33.5k|  {                                                                            \
  |  |  355|  33.5k|    if (!(x))                                                                  \
  |  |  ------------------
  |  |  |  Branch (355:9): [True: 0, False: 33.5k]
  |  |  ------------------
  |  |  356|  33.5k|      return false;                                                            \
  |  |  357|  33.5k|  }
  ------------------
 3309|   167k|    for (size_t index = 1; index < y.len(); index++) {
  ------------------
  |  Branch (3309:28): [True: 134k, False: 33.5k]
  ------------------
 3310|   134k|      limb yi = y[index];
 3311|   134k|      stackvec<size> zi;
 3312|   134k|      if (yi != 0) {
  ------------------
  |  Branch (3312:11): [True: 134k, False: 0]
  ------------------
 3313|       |        // re-use the same buffer throughout
 3314|   134k|        zi.set_len(0);
 3315|   134k|        GLZ_FASTFLOAT_TRY(zi.try_extend(zs));
  ------------------
  |  |  354|   134k|  {                                                                            \
  |  |  355|   134k|    if (!(x))                                                                  \
  |  |  ------------------
  |  |  |  Branch (355:9): [True: 0, False: 134k]
  |  |  ------------------
  |  |  356|   134k|      return false;                                                            \
  |  |  357|   134k|  }
  ------------------
 3316|   134k|        GLZ_FASTFLOAT_TRY(small_mul(zi, yi));
  ------------------
  |  |  354|   134k|  {                                                                            \
  |  |  355|   134k|    if (!(x))                                                                  \
  |  |  ------------------
  |  |  |  Branch (355:9): [True: 0, False: 134k]
  |  |  ------------------
  |  |  356|   134k|      return false;                                                            \
  |  |  357|   134k|  }
  ------------------
 3317|   134k|        limb_span zis = limb_span(zi.data, zi.len());
 3318|   134k|        GLZ_FASTFLOAT_TRY(large_add_from(x, zis, index));
  ------------------
  |  |  354|   134k|  {                                                                            \
  |  |  355|   134k|    if (!(x))                                                                  \
  |  |  ------------------
  |  |  |  Branch (355:9): [True: 0, False: 134k]
  |  |  ------------------
  |  |  356|   134k|      return false;                                                            \
  |  |  357|   134k|  }
  ------------------
 3319|   134k|      }
 3320|   134k|    }
 3321|  33.5k|  }
 3322|       |
 3323|  33.5k|  x.normalize();
 3324|  33.5k|  return true;
 3325|  33.5k|}
_ZN3glz10fast_float8stackvecILt62EEC2ENS0_4spanImEE:
 3013|  33.5k|  GLZ_FASTFLOAT_CONSTEXPR20 stackvec(limb_span s) {
 3014|  33.5k|    GLZ_FASTFLOAT_ASSERT(try_extend(s));
  ------------------
  |  |  344|  33.5k|  { ((void)(x)); }
  ------------------
 3015|  33.5k|  }
_ZN3glz10fast_float8stackvecILt62EE7set_lenEm:
 3035|   442k|  GLZ_FASTFLOAT_CONSTEXPR14 void set_len(size_t len) noexcept {
 3036|   442k|    length = uint16_t(len);
 3037|   442k|  }
_ZN3glz10fast_float8stackvecILt62EE10try_extendENS0_4spanImEE:
 3069|   167k|  GLZ_FASTFLOAT_CONSTEXPR20 bool try_extend(limb_span s) noexcept {
 3070|   167k|    if (len() + s.len() <= capacity()) {
  ------------------
  |  Branch (3070:9): [True: 167k, False: 0]
  ------------------
 3071|   167k|      extend_unchecked(s);
 3072|   167k|      return true;
 3073|   167k|    } else {
 3074|      0|      return false;
 3075|      0|    }
 3076|   167k|  }
_ZN3glz10fast_float8stackvecILt62EE16extend_uncheckedENS0_4spanImEE:
 3062|   167k|  GLZ_FASTFLOAT_CONSTEXPR20 void extend_unchecked(limb_span s) noexcept {
 3063|   167k|    limb *ptr = data + length;
 3064|   167k|    std::copy_n(s.ptr, s.len(), ptr);
 3065|   167k|    set_len(len() + s.len());
 3066|   167k|  }
_ZN3glz10fast_float14large_add_fromILt62EEEbRNS0_8stackvecIXT_EEENS0_4spanImEEm:
 3264|   134k|                                          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|   134k|  if (x.len() < start || y.len() > x.len() - start) {
  ------------------
  |  Branch (3267:7): [True: 0, False: 134k]
  |  Branch (3267:26): [True: 133k, False: 659]
  ------------------
 3268|   133k|    GLZ_FASTFLOAT_TRY(x.try_resize(y.len() + start, 0));
  ------------------
  |  |  354|   133k|  {                                                                            \
  |  |  355|   133k|    if (!(x))                                                                  \
  |  |  ------------------
  |  |  |  Branch (355:9): [True: 0, False: 133k]
  |  |  ------------------
  |  |  356|   133k|      return false;                                                            \
  |  |  357|   133k|  }
  ------------------
 3269|   133k|  }
 3270|       |
 3271|   134k|  bool carry = false;
 3272|  2.01M|  for (size_t index = 0; index < y.len(); index++) {
  ------------------
  |  Branch (3272:26): [True: 1.87M, False: 134k]
  ------------------
 3273|  1.87M|    limb xi = x[index + start];
 3274|  1.87M|    limb yi = y[index];
 3275|  1.87M|    bool c1 = false;
 3276|  1.87M|    bool c2 = false;
 3277|  1.87M|    xi = scalar_add(xi, yi, c1);
 3278|  1.87M|    if (carry) {
  ------------------
  |  Branch (3278:9): [True: 800k, False: 1.07M]
  ------------------
 3279|   800k|      xi = scalar_add(xi, 1, c2);
 3280|   800k|    }
 3281|  1.87M|    x[index + start] = xi;
 3282|  1.87M|    carry = c1 | c2;
 3283|  1.87M|  }
 3284|       |
 3285|       |  // handle overflow
 3286|   134k|  if (carry) {
  ------------------
  |  Branch (3286:7): [True: 0, False: 134k]
  ------------------
 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|   134k|  return true;
 3290|   134k|}
_ZN3glz10fast_float8stackvecILt62EE10try_resizeEmm:
 3095|   133k|  GLZ_FASTFLOAT_CONSTEXPR20 bool try_resize(size_t new_len, limb value) noexcept {
 3096|   133k|    if (new_len > capacity()) {
  ------------------
  |  Branch (3096:9): [True: 0, False: 133k]
  ------------------
 3097|      0|      return false;
 3098|   133k|    } else {
 3099|   133k|      resize_unchecked(new_len, value);
 3100|   133k|      return true;
 3101|   133k|    }
 3102|   133k|  }
_ZN3glz10fast_float8stackvecILt62EE16resize_uncheckedEmm:
 3082|   133k|  void resize_unchecked(size_t new_len, limb value) noexcept {
 3083|   133k|    if (new_len > len()) {
  ------------------
  |  Branch (3083:9): [True: 133k, False: 0]
  ------------------
 3084|   133k|      size_t count = new_len - len();
 3085|   133k|      limb *first = data + len();
 3086|   133k|      limb *last = first + count;
 3087|   133k|      ::std::fill(first, last, value);
 3088|   133k|      set_len(new_len);
 3089|   133k|    } else {
 3090|      0|      set_len(new_len);
 3091|      0|    }
 3092|   133k|  }
_ZN3glz10fast_float8stackvecILt62EE9normalizeEv:
 3118|  43.8k|  GLZ_FASTFLOAT_CONSTEXPR14 void normalize() noexcept {
 3119|  43.8k|    while (len() > 0 && rindex(0) == 0) {
  ------------------
  |  Branch (3119:12): [True: 43.8k, False: 0]
  |  Branch (3119:25): [True: 0, False: 43.8k]
  ------------------
 3120|      0|      length--;
 3121|      0|    }
 3122|  43.8k|  }
_ZNK3glz10fast_float8stackvecILt62EE6rindexEm:
 3028|  56.6k|  GLZ_FASTFLOAT_CONSTEXPR14 const limb &rindex(size_t index) const noexcept {
 3029|  56.6k|    GLZ_FASTFLOAT_DEBUG_ASSERT(index < length);
  ------------------
  |  |  349|  56.6k|  { ((void)(x)); }
  ------------------
 3030|  56.6k|    size_t rindex = length - index - 1;
 3031|  56.6k|    return data[rindex];
 3032|  56.6k|  }
_ZN3glz10fast_float6bigint4pow2Ej:
 3557|  12.6k|  GLZ_FASTFLOAT_CONSTEXPR20 bool pow2(uint32_t exp) noexcept { return shl(exp); }
_ZN3glz10fast_float6bigint3shlEm:
 3519|  12.6k|  GLZ_FASTFLOAT_CONSTEXPR20 bool shl(size_t n) noexcept {
 3520|  12.6k|    size_t rem = n % limb_bits;
 3521|  12.6k|    size_t div = n / limb_bits;
 3522|  12.6k|    if (rem != 0) {
  ------------------
  |  Branch (3522:9): [True: 10.5k, False: 2.06k]
  ------------------
 3523|  10.5k|      GLZ_FASTFLOAT_TRY(shl_bits(rem));
  ------------------
  |  |  354|  10.5k|  {                                                                            \
  |  |  355|  10.5k|    if (!(x))                                                                  \
  |  |  ------------------
  |  |  |  Branch (355:9): [True: 0, False: 10.5k]
  |  |  ------------------
  |  |  356|  10.5k|      return false;                                                            \
  |  |  357|  10.5k|  }
  ------------------
 3524|  10.5k|    }
 3525|  12.6k|    if (div != 0) {
  ------------------
  |  Branch (3525:9): [True: 7.33k, False: 5.32k]
  ------------------
 3526|  7.33k|      GLZ_FASTFLOAT_TRY(shl_limbs(div));
  ------------------
  |  |  354|  7.33k|  {                                                                            \
  |  |  355|  7.33k|    if (!(x))                                                                  \
  |  |  ------------------
  |  |  |  Branch (355:9): [True: 0, False: 7.33k]
  |  |  ------------------
  |  |  356|  7.33k|      return false;                                                            \
  |  |  357|  7.33k|  }
  ------------------
 3527|  7.33k|    }
 3528|  12.6k|    return true;
 3529|  12.6k|  }
_ZN3glz10fast_float6bigint8shl_bitsEm:
 3472|  10.5k|  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|  10.5k|    GLZ_FASTFLOAT_DEBUG_ASSERT(n != 0);
  ------------------
  |  |  349|  10.5k|  { ((void)(x)); }
  ------------------
 3479|  10.5k|    GLZ_FASTFLOAT_DEBUG_ASSERT(n < sizeof(limb) * 8);
  ------------------
  |  |  349|  10.5k|  { ((void)(x)); }
  ------------------
 3480|       |
 3481|  10.5k|    size_t shl = n;
 3482|  10.5k|    size_t shr = limb_bits - shl;
 3483|  10.5k|    limb prev = 0;
 3484|   200k|    for (size_t index = 0; index < vec.len(); index++) {
  ------------------
  |  Branch (3484:28): [True: 189k, False: 10.5k]
  ------------------
 3485|   189k|      limb xi = vec[index];
 3486|   189k|      vec[index] = (xi << shl) | (prev >> shr);
 3487|   189k|      prev = xi;
 3488|   189k|    }
 3489|       |
 3490|  10.5k|    limb carry = prev >> shr;
 3491|  10.5k|    if (carry != 0) {
  ------------------
  |  Branch (3491:9): [True: 2.41k, False: 8.17k]
  ------------------
 3492|  2.41k|      return vec.try_push(carry);
 3493|  2.41k|    }
 3494|  8.17k|    return true;
 3495|  10.5k|  }
_ZN3glz10fast_float6bigint9shl_limbsEm:
 3498|  7.33k|  GLZ_FASTFLOAT_CONSTEXPR20 bool shl_limbs(size_t n) noexcept {
 3499|  7.33k|    GLZ_FASTFLOAT_DEBUG_ASSERT(n != 0);
  ------------------
  |  |  349|  7.33k|  { ((void)(x)); }
  ------------------
 3500|  7.33k|    if (n + vec.len() > vec.capacity()) {
  ------------------
  |  Branch (3500:9): [True: 0, False: 7.33k]
  ------------------
 3501|      0|      return false;
 3502|  7.33k|    } else if (!vec.is_empty()) {
  ------------------
  |  Branch (3502:16): [True: 7.33k, False: 0]
  ------------------
 3503|       |      // move limbs
 3504|  7.33k|      limb *dst = vec.data + n;
 3505|  7.33k|      limb const *src = vec.data;
 3506|  7.33k|      std::copy_backward(src, src + vec.len(), dst + vec.len());
 3507|       |      // fill in empty limbs
 3508|  7.33k|      limb *first = vec.data;
 3509|  7.33k|      limb *last = first + n;
 3510|  7.33k|      ::std::fill(first, last, 0);
 3511|  7.33k|      vec.set_len(n + vec.len());
 3512|  7.33k|      return true;
 3513|  7.33k|    } else {
 3514|      0|      return true;
 3515|      0|    }
 3516|  7.33k|  }
_ZNK3glz10fast_float8stackvecILt62EE8is_emptyEv:
 3041|  11.0k|  constexpr bool is_empty() const noexcept { return length == 0; }
_ZNK3glz10fast_float6bigint4hi64ERb:
 3418|  3.71k|  GLZ_FASTFLOAT_CONSTEXPR20 uint64_t hi64(bool &truncated) const noexcept {
 3419|  3.71k|#ifdef GLZ_FASTFLOAT_64BIT_LIMB
 3420|  3.71k|    if (vec.len() == 0) {
  ------------------
  |  Branch (3420:9): [True: 0, False: 3.71k]
  ------------------
 3421|      0|      return empty_hi64(truncated);
 3422|  3.71k|    } else if (vec.len() == 1) {
  ------------------
  |  Branch (3422:16): [True: 447, False: 3.27k]
  ------------------
 3423|    447|      return uint64_hi64(vec.rindex(0), truncated);
 3424|  3.27k|    } else {
 3425|  3.27k|      uint64_t result = uint64_hi64(vec.rindex(0), vec.rindex(1), truncated);
 3426|  3.27k|      truncated |= vec.nonzero(2);
 3427|  3.27k|      return result;
 3428|  3.27k|    }
 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.71k|  }
_ZN3glz10fast_float11uint64_hi64EmRb:
 3132|    447|uint64_hi64(uint64_t r0, bool &truncated) noexcept {
 3133|    447|  truncated = false;
 3134|    447|  int shl = leading_zeroes(r0);
 3135|    447|  return r0 << shl;
 3136|    447|}
_ZN3glz10fast_float11uint64_hi64EmmRb:
 3139|  3.27k|uint64_hi64(uint64_t r0, uint64_t r1, bool &truncated) noexcept {
 3140|  3.27k|  int shl = leading_zeroes(r0);
 3141|  3.27k|  if (shl == 0) {
  ------------------
  |  Branch (3141:7): [True: 332, False: 2.94k]
  ------------------
 3142|    332|    truncated = r1 != 0;
 3143|    332|    return r0;
 3144|  2.94k|  } else {
 3145|  2.94k|    int shr = 64 - shl;
 3146|  2.94k|    truncated = (r1 << shl) != 0;
 3147|  2.94k|    return (r0 << shl) | (r1 >> shr);
 3148|  2.94k|  }
 3149|  3.27k|}
_ZNK3glz10fast_float8stackvecILt62EE7nonzeroEm:
 3107|  3.27k|  GLZ_FASTFLOAT_CONSTEXPR14 bool nonzero(size_t index) const noexcept {
 3108|  4.17k|    while (index < len()) {
  ------------------
  |  Branch (3108:12): [True: 2.11k, False: 2.06k]
  ------------------
 3109|  2.11k|      if (rindex(index) != 0) {
  ------------------
  |  Branch (3109:11): [True: 1.21k, False: 905]
  ------------------
 3110|  1.21k|        return true;
 3111|  1.21k|      }
 3112|    905|      index++;
 3113|    905|    }
 3114|  2.06k|    return false;
 3115|  3.27k|  }
_ZNK3glz10fast_float6bigint10bit_lengthEv:
 3547|  3.71k|  GLZ_FASTFLOAT_CONSTEXPR20 int bit_length() const noexcept {
 3548|  3.71k|    int lz = ctlz();
 3549|  3.71k|    return int(limb_bits * vec.len()) - lz;
 3550|  3.71k|  }
_ZNK3glz10fast_float6bigint4ctlzEv:
 3532|  3.71k|  GLZ_FASTFLOAT_CONSTEXPR20 int ctlz() const noexcept {
 3533|  3.71k|    if (vec.is_empty()) {
  ------------------
  |  Branch (3533:9): [True: 0, False: 3.71k]
  ------------------
 3534|      0|      return 0;
 3535|  3.71k|    } else {
 3536|  3.71k|#ifdef GLZ_FASTFLOAT_64BIT_LIMB
 3537|  3.71k|      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.71k|    }
 3544|  3.71k|  }
_ZN3glz10fast_float5roundIdZNS0_19positive_digit_compIdEENS0_17adjusted_mantissaERNS0_6bigintEiEUlRS3_iE_EEvS6_T0_:
 3707|  3.71k|                                                         callback cb) noexcept {
 3708|  3.71k|  int32_t mantissa_shift = 64 - binary_format<T>::mantissa_explicit_bits() - 1;
 3709|  3.71k|  if (-am.power2 >= mantissa_shift) {
  ------------------
  |  Branch (3709:7): [True: 0, False: 3.71k]
  ------------------
 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.71k|  cb(am, mantissa_shift);
 3723|       |
 3724|       |  // check for carry
 3725|  3.71k|  if (am.mantissa >=
  ------------------
  |  Branch (3725:7): [True: 305, False: 3.41k]
  ------------------
 3726|  3.71k|      (uint64_t(2) << binary_format<T>::mantissa_explicit_bits())) {
 3727|    305|    am.mantissa = (uint64_t(1) << binary_format<T>::mantissa_explicit_bits());
 3728|    305|    am.power2++;
 3729|    305|  }
 3730|       |
 3731|       |  // check for infinite: we could have carried to an infinite power
 3732|  3.71k|  am.mantissa &= ~(uint64_t(1) << binary_format<T>::mantissa_explicit_bits());
 3733|  3.71k|  if (am.power2 >= binary_format<T>::infinite_power()) {
  ------------------
  |  Branch (3733:7): [True: 0, False: 3.71k]
  ------------------
 3734|      0|    am.power2 = binary_format<T>::infinite_power();
 3735|      0|    am.mantissa = 0;
 3736|      0|  }
 3737|  3.71k|}
_ZZN3glz10fast_float19positive_digit_compIdEENS0_17adjusted_mantissaERNS0_6bigintEiENKUlRS2_iE_clES5_i:
 3951|  3.71k|  round<T>(answer, [truncated](adjusted_mantissa &a, int32_t shift) {
 3952|  3.71k|    round_nearest_tie_even(
 3953|  3.71k|        a, shift,
 3954|  3.71k|        [truncated](bool is_odd, bool is_halfway, bool is_above) -> bool {
 3955|  3.71k|          return is_above || (is_halfway && truncated) ||
 3956|  3.71k|                 (is_odd && is_halfway);
 3957|  3.71k|        });
 3958|  3.71k|  });
_ZN3glz10fast_float22round_nearest_tie_evenIZZNS0_19positive_digit_compIdEENS0_17adjusted_mantissaERNS0_6bigintEiENKUlRS3_iE_clES6_iEUlbbbE_EEvS6_iT_:
 3742|  3.71k|                       callback cb) noexcept {
 3743|  3.71k|  uint64_t const mask = (shift == 64) ? UINT64_MAX : (uint64_t(1) << shift) - 1;
  ------------------
  |  Branch (3743:25): [True: 0, False: 3.71k]
  ------------------
 3744|  3.71k|  uint64_t const halfway = (shift == 0) ? 0 : uint64_t(1) << (shift - 1);
  ------------------
  |  Branch (3744:28): [True: 0, False: 3.71k]
  ------------------
 3745|  3.71k|  uint64_t truncated_bits = am.mantissa & mask;
 3746|  3.71k|  bool is_above = truncated_bits > halfway;
 3747|  3.71k|  bool is_halfway = truncated_bits == halfway;
 3748|       |
 3749|       |  // shift digits into position
 3750|  3.71k|  if (shift == 64) {
  ------------------
  |  Branch (3750:7): [True: 0, False: 3.71k]
  ------------------
 3751|      0|    am.mantissa = 0;
 3752|  3.71k|  } else {
 3753|  3.71k|    am.mantissa >>= shift;
 3754|  3.71k|  }
 3755|  3.71k|  am.power2 += shift;
 3756|       |
 3757|  3.71k|  bool is_odd = (am.mantissa & 1) == 1;
 3758|  3.71k|  am.mantissa += uint64_t(cb(is_odd, is_halfway, is_above));
 3759|  3.71k|}
_ZZZN3glz10fast_float19positive_digit_compIdEENS0_17adjusted_mantissaERNS0_6bigintEiENKUlRS2_iE_clES5_iENKUlbbbE_clEbbb:
 3954|  3.71k|        [truncated](bool is_odd, bool is_halfway, bool is_above) -> bool {
 3955|  3.71k|          return is_above || (is_halfway && truncated) ||
  ------------------
  |  Branch (3955:18): [True: 702, False: 3.01k]
  |  Branch (3955:31): [True: 1.58k, False: 1.43k]
  |  Branch (3955:45): [True: 630, False: 951]
  ------------------
 3956|  2.38k|                 (is_odd && is_halfway);
  ------------------
  |  Branch (3956:19): [True: 1.00k, False: 1.38k]
  |  Branch (3956:29): [True: 15, False: 988]
  ------------------
 3957|  3.71k|        });
_ZN3glz10fast_float19negative_digit_compIdEENS0_17adjusted_mantissaERNS0_6bigintES2_i:
 3970|  10.3k|    bigint &bigmant, adjusted_mantissa am, int32_t exponent) noexcept {
 3971|  10.3k|  bigint &real_digits = bigmant;
 3972|  10.3k|  int32_t real_exp = exponent;
 3973|       |
 3974|       |  // get the value of `b`, rounded down, and get a bigint representation of b+h
 3975|  10.3k|  adjusted_mantissa am_b = am;
 3976|       |  // gcc7 buf: use a lambda to remove the noexcept qualifier bug with
 3977|       |  // -Wnoexcept-type.
 3978|  10.3k|  round<T>(am_b,
 3979|  10.3k|           [](adjusted_mantissa &a, int32_t shift) { round_down(a, shift); });
 3980|  10.3k|  T b;
 3981|  10.3k|  to_float(false, am_b, b);
 3982|  10.3k|  adjusted_mantissa theor = to_extended_halfway(b);
 3983|  10.3k|  bigint theor_digits(theor.mantissa);
 3984|  10.3k|  int32_t theor_exp = theor.power2;
 3985|       |
 3986|       |  // scale real digits and theor digits to be same power.
 3987|  10.3k|  int32_t pow2_exp = theor_exp - real_exp;
 3988|  10.3k|  uint32_t pow5_exp = uint32_t(-real_exp);
 3989|  10.3k|  if (pow5_exp != 0) {
  ------------------
  |  Branch (3989:7): [True: 10.3k, False: 0]
  ------------------
 3990|  10.3k|    GLZ_FASTFLOAT_ASSERT(theor_digits.pow5(pow5_exp));
  ------------------
  |  |  344|  10.3k|  { ((void)(x)); }
  ------------------
 3991|  10.3k|  }
 3992|  10.3k|  if (pow2_exp > 0) {
  ------------------
  |  Branch (3992:7): [True: 6.48k, False: 3.85k]
  ------------------
 3993|  6.48k|    GLZ_FASTFLOAT_ASSERT(theor_digits.pow2(uint32_t(pow2_exp)));
  ------------------
  |  |  344|  6.48k|  { ((void)(x)); }
  ------------------
 3994|  6.48k|  } else if (pow2_exp < 0) {
  ------------------
  |  Branch (3994:14): [True: 2.45k, False: 1.40k]
  ------------------
 3995|  2.45k|    GLZ_FASTFLOAT_ASSERT(real_digits.pow2(uint32_t(-pow2_exp)));
  ------------------
  |  |  344|  2.45k|  { ((void)(x)); }
  ------------------
 3996|  2.45k|  }
 3997|       |
 3998|       |  // compare digits, and use it to director rounding
 3999|  10.3k|  int ord = real_digits.compare(theor_digits);
 4000|  10.3k|  adjusted_mantissa answer = am;
 4001|  10.3k|  round<T>(answer, [ord](adjusted_mantissa &a, int32_t shift) {
 4002|  10.3k|    round_nearest_tie_even(
 4003|  10.3k|        a, shift, [ord](bool is_odd, bool _, bool __) -> bool {
 4004|  10.3k|          (void)_;  // not needed, since we've done our comparison
 4005|  10.3k|          (void)__; // not needed, since we've done our comparison
 4006|  10.3k|          if (ord > 0) {
 4007|  10.3k|            return true;
 4008|  10.3k|          } else if (ord < 0) {
 4009|  10.3k|            return false;
 4010|  10.3k|          } else {
 4011|  10.3k|            return is_odd;
 4012|  10.3k|          }
 4013|  10.3k|        });
 4014|  10.3k|  });
 4015|       |
 4016|  10.3k|  return answer;
 4017|  10.3k|}
_ZN3glz10fast_float5roundIdZNS0_19negative_digit_compIdEENS0_17adjusted_mantissaERNS0_6bigintES3_iEUlRS3_iE_EEvS6_T0_:
 3707|  10.3k|                                                         callback cb) noexcept {
 3708|  10.3k|  int32_t mantissa_shift = 64 - binary_format<T>::mantissa_explicit_bits() - 1;
 3709|  10.3k|  if (-am.power2 >= mantissa_shift) {
  ------------------
  |  Branch (3709:7): [True: 633, False: 9.70k]
  ------------------
 3710|       |    // have a denormal float
 3711|    633|    int32_t shift = -am.power2 + 1;
 3712|    633|    cb(am, (std::min<int32_t>)(shift, 64));
 3713|       |    // check for round-up: if rounding-nearest carried us to the hidden bit.
 3714|    633|    am.power2 = (am.mantissa <
  ------------------
  |  Branch (3714:17): [True: 633, False: 0]
  ------------------
 3715|    633|                 (uint64_t(1) << binary_format<T>::mantissa_explicit_bits()))
 3716|    633|                    ? 0
 3717|    633|                    : 1;
 3718|    633|    return;
 3719|    633|  }
 3720|       |
 3721|       |  // have a normal float, use the default shift.
 3722|  9.70k|  cb(am, mantissa_shift);
 3723|       |
 3724|       |  // check for carry
 3725|  9.70k|  if (am.mantissa >=
  ------------------
  |  Branch (3725:7): [True: 0, False: 9.70k]
  ------------------
 3726|  9.70k|      (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|  9.70k|  am.mantissa &= ~(uint64_t(1) << binary_format<T>::mantissa_explicit_bits());
 3733|  9.70k|  if (am.power2 >= binary_format<T>::infinite_power()) {
  ------------------
  |  Branch (3733:7): [True: 0, False: 9.70k]
  ------------------
 3734|      0|    am.power2 = binary_format<T>::infinite_power();
 3735|      0|    am.mantissa = 0;
 3736|      0|  }
 3737|  9.70k|}
_ZZN3glz10fast_float19negative_digit_compIdEENS0_17adjusted_mantissaERNS0_6bigintES2_iENKUlRS2_iE_clES5_i:
 3979|  10.3k|           [](adjusted_mantissa &a, int32_t shift) { round_down(a, shift); });
_ZN3glz10fast_float10round_downERNS0_17adjusted_mantissaEi:
 3762|  10.3k|round_down(adjusted_mantissa &am, int32_t shift) noexcept {
 3763|  10.3k|  if (shift == 64) {
  ------------------
  |  Branch (3763:7): [True: 0, False: 10.3k]
  ------------------
 3764|      0|    am.mantissa = 0;
 3765|  10.3k|  } else {
 3766|  10.3k|    am.mantissa >>= shift;
 3767|  10.3k|  }
 3768|  10.3k|  am.power2 += shift;
 3769|  10.3k|}
_ZN3glz10fast_float19to_extended_halfwayIdEENS0_17adjusted_mantissaET_:
 3696|  10.3k|to_extended_halfway(T value) noexcept {
 3697|  10.3k|  adjusted_mantissa am = to_extended(value);
 3698|  10.3k|  am.mantissa <<= 1;
 3699|  10.3k|  am.mantissa += 1;
 3700|  10.3k|  am.power2 -= 1;
 3701|  10.3k|  return am;
 3702|  10.3k|}
_ZN3glz10fast_float11to_extendedIdEENS0_17adjusted_mantissaET_:
 3661|  10.3k|to_extended(T value) noexcept {
 3662|  10.3k|  using equiv_uint = equiv_uint_t<T>;
 3663|  10.3k|  constexpr equiv_uint exponent_mask = binary_format<T>::exponent_mask();
 3664|  10.3k|  constexpr equiv_uint mantissa_mask = binary_format<T>::mantissa_mask();
 3665|  10.3k|  constexpr equiv_uint hidden_bit_mask = binary_format<T>::hidden_bit_mask();
 3666|       |
 3667|  10.3k|  adjusted_mantissa am;
 3668|  10.3k|  int32_t bias = binary_format<T>::mantissa_explicit_bits() -
 3669|  10.3k|                 binary_format<T>::minimum_exponent();
 3670|  10.3k|  equiv_uint bits;
 3671|  10.3k|#if GLZ_FASTFLOAT_HAS_BIT_CAST
 3672|  10.3k|  bits = std::bit_cast<equiv_uint>(value);
 3673|       |#else
 3674|       |  ::memcpy(&bits, &value, sizeof(T));
 3675|       |#endif
 3676|  10.3k|  if ((bits & exponent_mask) == 0) {
  ------------------
  |  Branch (3676:7): [True: 633, False: 9.70k]
  ------------------
 3677|       |    // denormal
 3678|    633|    am.power2 = 1 - bias;
 3679|    633|    am.mantissa = bits & mantissa_mask;
 3680|  9.70k|  } else {
 3681|       |    // normal
 3682|  9.70k|    am.power2 = int32_t((bits & exponent_mask) >>
 3683|  9.70k|                        binary_format<T>::mantissa_explicit_bits());
 3684|  9.70k|    am.power2 -= bias;
 3685|  9.70k|    am.mantissa = (bits & mantissa_mask) | hidden_bit_mask;
 3686|  9.70k|  }
 3687|       |
 3688|  10.3k|  return am;
 3689|  10.3k|}
_ZN3glz10fast_float6bigintC2Em:
 3406|  10.3k|  GLZ_FASTFLOAT_CONSTEXPR20 bigint(uint64_t value) : vec() {
 3407|  10.3k|#ifdef GLZ_FASTFLOAT_64BIT_LIMB
 3408|  10.3k|    vec.push_unchecked(value);
 3409|       |#else
 3410|       |    vec.push_unchecked(uint32_t(value));
 3411|       |    vec.push_unchecked(uint32_t(value >> 32));
 3412|       |#endif
 3413|  10.3k|    vec.normalize();
 3414|  10.3k|  }
_ZNK3glz10fast_float6bigint7compareERKS1_:
 3451|  10.3k|  GLZ_FASTFLOAT_CONSTEXPR20 int compare(bigint const &other) const noexcept {
 3452|  10.3k|    if (vec.len() > other.vec.len()) {
  ------------------
  |  Branch (3452:9): [True: 0, False: 10.3k]
  ------------------
 3453|      0|      return 1;
 3454|  10.3k|    } else if (vec.len() < other.vec.len()) {
  ------------------
  |  Branch (3454:16): [True: 0, False: 10.3k]
  ------------------
 3455|      0|      return -1;
 3456|  10.3k|    } else {
 3457|  22.3k|      for (size_t index = vec.len(); index > 0; index--) {
  ------------------
  |  Branch (3457:38): [True: 21.9k, False: 427]
  ------------------
 3458|  21.9k|        limb xi = vec[index - 1];
 3459|  21.9k|        limb yi = other.vec[index - 1];
 3460|  21.9k|        if (xi > yi) {
  ------------------
  |  Branch (3460:13): [True: 3.43k, False: 18.5k]
  ------------------
 3461|  3.43k|          return 1;
 3462|  18.5k|        } else if (xi < yi) {
  ------------------
  |  Branch (3462:20): [True: 6.48k, False: 12.0k]
  ------------------
 3463|  6.48k|          return -1;
 3464|  6.48k|        }
 3465|  21.9k|      }
 3466|    427|      return 0;
 3467|  10.3k|    }
 3468|  10.3k|  }
_ZNK3glz10fast_float8stackvecILt62EEixEm:
 3022|  43.8k|  GLZ_FASTFLOAT_CONSTEXPR14 const limb &operator[](size_t index) const noexcept {
 3023|  43.8k|    GLZ_FASTFLOAT_DEBUG_ASSERT(index < length);
  ------------------
  |  |  349|  43.8k|  { ((void)(x)); }
  ------------------
 3024|  43.8k|    return data[index];
 3025|  43.8k|  }
_ZN3glz10fast_float5roundIdZNS0_19negative_digit_compIdEENS0_17adjusted_mantissaERNS0_6bigintES3_iEUlRS3_iE0_EEvS6_T0_:
 3707|  10.3k|                                                         callback cb) noexcept {
 3708|  10.3k|  int32_t mantissa_shift = 64 - binary_format<T>::mantissa_explicit_bits() - 1;
 3709|  10.3k|  if (-am.power2 >= mantissa_shift) {
  ------------------
  |  Branch (3709:7): [True: 633, False: 9.70k]
  ------------------
 3710|       |    // have a denormal float
 3711|    633|    int32_t shift = -am.power2 + 1;
 3712|    633|    cb(am, (std::min<int32_t>)(shift, 64));
 3713|       |    // check for round-up: if rounding-nearest carried us to the hidden bit.
 3714|    633|    am.power2 = (am.mantissa <
  ------------------
  |  Branch (3714:17): [True: 631, False: 2]
  ------------------
 3715|    633|                 (uint64_t(1) << binary_format<T>::mantissa_explicit_bits()))
 3716|    633|                    ? 0
 3717|    633|                    : 1;
 3718|    633|    return;
 3719|    633|  }
 3720|       |
 3721|       |  // have a normal float, use the default shift.
 3722|  9.70k|  cb(am, mantissa_shift);
 3723|       |
 3724|       |  // check for carry
 3725|  9.70k|  if (am.mantissa >=
  ------------------
  |  Branch (3725:7): [True: 661, False: 9.04k]
  ------------------
 3726|  9.70k|      (uint64_t(2) << binary_format<T>::mantissa_explicit_bits())) {
 3727|    661|    am.mantissa = (uint64_t(1) << binary_format<T>::mantissa_explicit_bits());
 3728|    661|    am.power2++;
 3729|    661|  }
 3730|       |
 3731|       |  // check for infinite: we could have carried to an infinite power
 3732|  9.70k|  am.mantissa &= ~(uint64_t(1) << binary_format<T>::mantissa_explicit_bits());
 3733|  9.70k|  if (am.power2 >= binary_format<T>::infinite_power()) {
  ------------------
  |  Branch (3733:7): [True: 0, False: 9.70k]
  ------------------
 3734|      0|    am.power2 = binary_format<T>::infinite_power();
 3735|      0|    am.mantissa = 0;
 3736|      0|  }
 3737|  9.70k|}
_ZZN3glz10fast_float19negative_digit_compIdEENS0_17adjusted_mantissaERNS0_6bigintES2_iENKUlRS2_iE0_clES5_i:
 4001|  10.3k|  round<T>(answer, [ord](adjusted_mantissa &a, int32_t shift) {
 4002|  10.3k|    round_nearest_tie_even(
 4003|  10.3k|        a, shift, [ord](bool is_odd, bool _, bool __) -> bool {
 4004|  10.3k|          (void)_;  // not needed, since we've done our comparison
 4005|  10.3k|          (void)__; // not needed, since we've done our comparison
 4006|  10.3k|          if (ord > 0) {
 4007|  10.3k|            return true;
 4008|  10.3k|          } else if (ord < 0) {
 4009|  10.3k|            return false;
 4010|  10.3k|          } else {
 4011|  10.3k|            return is_odd;
 4012|  10.3k|          }
 4013|  10.3k|        });
 4014|  10.3k|  });
_ZN3glz10fast_float22round_nearest_tie_evenIZZNS0_19negative_digit_compIdEENS0_17adjusted_mantissaERNS0_6bigintES3_iENKUlRS3_iE0_clES6_iEUlbbbE_EEvS6_iT_:
 3742|  10.3k|                       callback cb) noexcept {
 3743|  10.3k|  uint64_t const mask = (shift == 64) ? UINT64_MAX : (uint64_t(1) << shift) - 1;
  ------------------
  |  Branch (3743:25): [True: 0, False: 10.3k]
  ------------------
 3744|  10.3k|  uint64_t const halfway = (shift == 0) ? 0 : uint64_t(1) << (shift - 1);
  ------------------
  |  Branch (3744:28): [True: 0, False: 10.3k]
  ------------------
 3745|  10.3k|  uint64_t truncated_bits = am.mantissa & mask;
 3746|  10.3k|  bool is_above = truncated_bits > halfway;
 3747|  10.3k|  bool is_halfway = truncated_bits == halfway;
 3748|       |
 3749|       |  // shift digits into position
 3750|  10.3k|  if (shift == 64) {
  ------------------
  |  Branch (3750:7): [True: 0, False: 10.3k]
  ------------------
 3751|      0|    am.mantissa = 0;
 3752|  10.3k|  } else {
 3753|  10.3k|    am.mantissa >>= shift;
 3754|  10.3k|  }
 3755|  10.3k|  am.power2 += shift;
 3756|       |
 3757|  10.3k|  bool is_odd = (am.mantissa & 1) == 1;
 3758|  10.3k|  am.mantissa += uint64_t(cb(is_odd, is_halfway, is_above));
 3759|  10.3k|}
_ZZZN3glz10fast_float19negative_digit_compIdEENS0_17adjusted_mantissaERNS0_6bigintES2_iENKUlRS2_iE0_clES5_iENKUlbbbE_clEbbb:
 4003|  10.3k|        a, shift, [ord](bool is_odd, bool _, bool __) -> bool {
 4004|  10.3k|          (void)_;  // not needed, since we've done our comparison
 4005|  10.3k|          (void)__; // not needed, since we've done our comparison
 4006|  10.3k|          if (ord > 0) {
  ------------------
  |  Branch (4006:15): [True: 3.43k, False: 6.90k]
  ------------------
 4007|  3.43k|            return true;
 4008|  6.90k|          } else if (ord < 0) {
  ------------------
  |  Branch (4008:22): [True: 6.48k, False: 427]
  ------------------
 4009|  6.48k|            return false;
 4010|  6.48k|          } else {
 4011|    427|            return is_odd;
 4012|    427|          }
 4013|  10.3k|        });
_ZN3glz10fast_float8to_floatIdEEvbNS0_17adjusted_mantissaERT_:
 1131|  29.1k|to_float(bool negative, adjusted_mantissa am, T &value) {
 1132|  29.1k|  using equiv_uint = equiv_uint_t<T>;
 1133|  29.1k|  equiv_uint word = equiv_uint(am.mantissa);
 1134|  29.1k|  word = equiv_uint(word | equiv_uint(am.power2)
 1135|  29.1k|                               << binary_format<T>::mantissa_explicit_bits());
 1136|  29.1k|  word =
 1137|  29.1k|      equiv_uint(word | equiv_uint(negative) << binary_format<T>::sign_index());
 1138|  29.1k|#if GLZ_FASTFLOAT_HAS_BIT_CAST
 1139|  29.1k|  value = std::bit_cast<T>(word);
 1140|       |#else
 1141|       |  ::memcpy(&value, &word, sizeof(T));
 1142|       |#endif
 1143|  29.1k|}
_ZN3glz10fast_float13binary_formatIdE10sign_indexEv:
  758|  29.1k|template <> inline constexpr int binary_format<double>::sign_index() {
  759|  29.1k|  return 63;
  760|  29.1k|}
_ZN3glz10fast_float13binary_formatIdE14infinite_powerEv:
  750|  74.3k|template <> inline constexpr int binary_format<double>::infinite_power() {
  751|  74.3k|  return 0x7FF;
  752|  74.3k|}

_ZN3glz5visitILm4EZNS_16parse_and_invokeITnDaXtlNS_4optsELj10ELb1ELb1ELb1ELb1EEE9my_structRS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT3_OT4_OT5_DpOT2_EUlTnmvE_EEvOSA_m:
   81|  44.3k|   {
   82|  44.3k|      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|  44.3k|         else if constexpr (N == 4) {
  116|  44.3k|            switch (index) {
  117|  8.21k|            case 0:
  ------------------
  |  Branch (117:13): [True: 8.21k, False: 36.1k]
  ------------------
  118|  8.21k|               lambda.template operator()<0>();
  119|  8.21k|               break;
  120|  23.3k|            case 1:
  ------------------
  |  Branch (120:13): [True: 23.3k, False: 21.0k]
  ------------------
  121|  23.3k|               lambda.template operator()<1>();
  122|  23.3k|               break;
  123|  5.33k|            case 2:
  ------------------
  |  Branch (123:13): [True: 5.33k, False: 39.0k]
  ------------------
  124|  5.33k|               lambda.template operator()<2>();
  125|  5.33k|               break;
  126|  7.45k|            case 3:
  ------------------
  |  Branch (126:13): [True: 7.45k, False: 36.9k]
  ------------------
  127|  7.45k|               lambda.template operator()<3>();
  128|  7.45k|               break;
  129|      0|            default:
  ------------------
  |  Branch (129:13): [True: 0, False: 44.3k]
  ------------------
  130|      0|               std::unreachable();
  131|  44.3k|            }
  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|  44.3k|      }
  329|  44.3k|   }

_ZN3glz10from_charsILb1EdcEENS_10fast_float19from_chars_result_tIT1_EEPKS3_S6_RT0_:
  236|  23.1k|   {
  237|  23.1k|      using namespace glz::fast_float;
  238|  23.1k|      static_assert(is_supported_float_type<T>(), "only some floating-point types are supported");
  239|  23.1k|      static_assert(is_supported_char_type<UC>(), "only char, wchar_t, char16_t and char32_t are supported");
  240|       |
  241|  23.1k|      parsed_number_string_t<UC> pns = glz::parse_number_string<null_terminated, UC>(first, last);
  242|  23.1k|      if (!pns.valid) [[unlikely]] {
  ------------------
  |  Branch (242:11): [True: 153, False: 23.0k]
  ------------------
  243|    153|         return {.ptr = first, .ec = std::errc::invalid_argument};
  244|    153|      }
  245|       |
  246|  23.0k|      return from_chars_advanced(pns, value);
  247|  23.1k|   }
_ZN3glz19parse_number_stringILb1EcEENS_10fast_float22parsed_number_string_tIT0_EEPKS3_S6_:
   18|  23.1k|   {
   19|  23.1k|      using namespace glz::fast_float;
   20|  23.1k|      static constexpr UC decimal_point = '.';
   21|       |
   22|  23.1k|      parsed_number_string_t<UC> answer;
   23|  23.1k|      answer.valid = false;
   24|  23.1k|      answer.too_many_digits = false;
   25|  23.1k|      answer.negative = (*p == UC('-'));
   26|  23.1k|      if (*p == UC('-')) { // C++17 20.19.3.(7.1) explicitly forbids '+' sign here
  ------------------
  |  Branch (26:11): [True: 715, False: 22.4k]
  ------------------
   27|    715|         ++p;
   28|       |
   29|       |         if constexpr (not null_terminated) {
   30|       |            if (p == pend) [[unlikely]] {
   31|       |               return answer;
   32|       |            }
   33|       |         }
   34|       |
   35|    715|         if (!glz::fast_float::is_integer(*p)) [[unlikely]] { // a sign must be followed by an integer
  ------------------
  |  Branch (35:14): [True: 19, False: 696]
  ------------------
   36|     19|            return answer;
   37|     19|         }
   38|    715|      }
   39|  23.1k|      UC const* const start_digits = p;
   40|       |
   41|  23.1k|      uint64_t i = 0; // an unsigned int avoids signed overflows (which are bad)
   42|       |
   43|  23.1k|      uint64_t digit;
   44|  23.1k|      if constexpr (null_terminated) {
   45|  3.61M|         while ((digit = glz::fast_float::digit_value(*p)) <= 9) {
  ------------------
  |  Branch (45:17): [True: 3.58M, False: 23.1k]
  ------------------
   46|       |            // a multiplication by 10 is cheaper than an arbitrary integer
   47|       |            // multiplication
   48|  3.58M|            i = 10 * i + digit; // might overflow, we will handle the overflow later
   49|  3.58M|            ++p;
   50|  3.58M|         }
   51|       |      }
   52|       |      else {
   53|       |         while ((p != pend) && (digit = glz::fast_float::digit_value(*p)) <= 9) {
   54|       |            // a multiplication by 10 is cheaper than an arbitrary integer
   55|       |            // multiplication
   56|       |            i = 10 * i + digit; // might overflow, we will handle the overflow later
   57|       |            ++p;
   58|       |         }
   59|       |      }
   60|       |
   61|  23.1k|      UC const* const end_of_integer_part = p;
   62|  23.1k|      int64_t digit_count = int64_t(end_of_integer_part - start_digits);
   63|  23.1k|      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|  23.1k|      if (digit_count == 0 || (start_digits[0] == UC('0') && digit_count > 1)) {
  ------------------
  |  Branch (66:11): [True: 111, False: 23.0k]
  |  Branch (66:32): [True: 2.52k, False: 20.5k]
  |  Branch (66:62): [True: 5, False: 2.52k]
  ------------------
   67|    116|         return answer;
   68|    116|      }
   69|       |
   70|  23.0k|      int64_t exponent = 0;
   71|  23.0k|      const bool has_decimal_point = [&] {
   72|  23.0k|         if constexpr (null_terminated) {
   73|  23.0k|            return (*p == decimal_point);
   74|  23.0k|         }
   75|  23.0k|         else {
   76|  23.0k|            return (p != pend) && (*p == decimal_point);
   77|  23.0k|         }
   78|  23.0k|      }();
   79|  23.0k|      if (has_decimal_point) {
  ------------------
  |  Branch (79:11): [True: 10.2k, False: 12.7k]
  ------------------
   80|  10.2k|         ++p;
   81|  10.2k|         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|  10.2k|         loop_parse_if_eight_digits(p, pend, i);
   85|       |
   86|  10.2k|         if constexpr (null_terminated) {
   87|  46.8k|            while ((digit = glz::fast_float::digit_value(*p)) <= 9) {
  ------------------
  |  Branch (87:20): [True: 36.6k, False: 10.2k]
  ------------------
   88|  36.6k|               ++p;
   89|  36.6k|               i = i * 10 + digit; // in rare cases, this will overflow, but that's ok
   90|  36.6k|            }
   91|       |         }
   92|       |         else {
   93|       |            while ((p != pend) && (digit = glz::fast_float::digit_value(*p)) <= 9) {
   94|       |               ++p;
   95|       |               i = i * 10 + digit; // in rare cases, this will overflow, but that's ok
   96|       |            }
   97|       |         }
   98|  10.2k|         exponent = before - p;
   99|  10.2k|         answer.fraction = glz::fast_float::span<const UC>(before, size_t(p - before));
  100|  10.2k|         digit_count -= exponent;
  101|  10.2k|      }
  102|       |      // at least 1 digit in fractional part
  103|  23.0k|      if (has_decimal_point && exponent == 0) {
  ------------------
  |  Branch (103:11): [True: 10.2k, False: 12.7k]
  |  Branch (103:32): [True: 18, False: 10.2k]
  ------------------
  104|     18|         return answer;
  105|     18|      }
  106|       |
  107|  23.0k|      int64_t exp_number = 0; // explicit exponential part
  108|       |
  109|  23.0k|      if constexpr (null_terminated) {
  110|  23.0k|         if ((UC('e') == *p) || (UC('E') == *p)) {
  ------------------
  |  Branch (110:14): [True: 1.93k, False: 21.1k]
  |  Branch (110:33): [True: 7.47k, False: 13.6k]
  ------------------
  111|  9.41k|            UC const* location_of_e = p;
  112|  9.41k|            ++p;
  113|  9.41k|            bool neg_exp = false;
  114|  9.41k|            if (UC('-') == *p) {
  ------------------
  |  Branch (114:17): [True: 4.85k, False: 4.55k]
  ------------------
  115|  4.85k|               neg_exp = true;
  116|  4.85k|               ++p;
  117|  4.85k|            }
  118|  4.55k|            else if (UC('+') == *p) { // '+' on exponent is allowed by C++17 20.19.3.(7.1)
  ------------------
  |  Branch (118:22): [True: 214, False: 4.34k]
  ------------------
  119|    214|               ++p;
  120|    214|            }
  121|  9.41k|            if ((digit = glz::fast_float::digit_value(*p)) > 9) {
  ------------------
  |  Branch (121:17): [True: 39, False: 9.37k]
  ------------------
  122|       |               // Otherwise, we will be ignoring the 'e'.
  123|     39|               p = location_of_e;
  124|     39|            }
  125|  9.37k|            else {
  126|  24.4k|               do {
  127|  24.4k|                  if (exp_number < 0x10000000) {
  ------------------
  |  Branch (127:23): [True: 24.1k, False: 337]
  ------------------
  128|  24.1k|                     exp_number = 10 * exp_number + digit;
  129|  24.1k|                  }
  130|  24.4k|                  ++p;
  131|  24.4k|               } while ((digit = glz::fast_float::digit_value(*p)) <= 9);
  ------------------
  |  Branch (131:25): [True: 15.0k, False: 9.37k]
  ------------------
  132|  9.37k|               if (neg_exp) {
  ------------------
  |  Branch (132:20): [True: 4.85k, False: 4.52k]
  ------------------
  133|  4.85k|                  exp_number = -exp_number;
  134|  4.85k|               }
  135|  9.37k|               exponent += exp_number;
  136|  9.37k|            }
  137|  9.41k|         }
  138|       |      }
  139|       |      else {
  140|       |         if ((p != pend) && ((UC('e') == *p) || (UC('E') == *p))) {
  141|       |            UC const* location_of_e = p;
  142|       |            ++p;
  143|       |            bool neg_exp = false;
  144|       |            if ((p != pend) && (UC('-') == *p)) {
  145|       |               neg_exp = true;
  146|       |               ++p;
  147|       |            }
  148|       |            else if ((p != pend) && (UC('+') == *p)) { // '+' on exponent is allowed by C++17 20.19.3.(7.1)
  149|       |               ++p;
  150|       |            }
  151|       |            if ((p == pend) || (digit = glz::fast_float::digit_value(*p)) > 9) {
  152|       |               // Otherwise, we will be ignoring the 'e'.
  153|       |               p = location_of_e;
  154|       |            }
  155|       |            else {
  156|       |               do {
  157|       |                  if (exp_number < 0x10000000) {
  158|       |                     exp_number = 10 * exp_number + digit;
  159|       |                  }
  160|       |                  ++p;
  161|       |               } while ((p != pend) && (digit = glz::fast_float::digit_value(*p)) <= 9);
  162|       |               if (neg_exp) {
  163|       |                  exp_number = -exp_number;
  164|       |               }
  165|       |               exponent += exp_number;
  166|       |            }
  167|       |         }
  168|       |      }
  169|       |
  170|  23.0k|      answer.lastmatch = p;
  171|  23.0k|      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|  23.0k|      if (digit_count > 19) { // this is uncommon
  ------------------
  |  Branch (178:11): [True: 15.9k, False: 7.05k]
  ------------------
  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|  15.9k|         UC const* start = start_digits;
  184|  15.9k|         if constexpr (null_terminated) {
  185|  1.07M|            while ((*start == UC('0') || *start == decimal_point)) {
  ------------------
  |  Branch (185:21): [True: 1.05M, False: 17.0k]
  |  Branch (185:42): [True: 1.04k, False: 15.9k]
  ------------------
  186|  1.05M|               if (*start == UC('0')) {
  ------------------
  |  Branch (186:20): [True: 1.05M, False: 1.04k]
  ------------------
  187|  1.05M|                  --digit_count;
  188|  1.05M|               }
  189|  1.05M|               ++start;
  190|  1.05M|            }
  191|       |         }
  192|       |         else {
  193|       |            while ((start != pend) && (*start == UC('0') || *start == decimal_point)) {
  194|       |               if (*start == UC('0')) {
  195|       |                  --digit_count;
  196|       |               }
  197|       |               ++start;
  198|       |            }
  199|       |         }
  200|       |
  201|  15.9k|         if (digit_count > 19) {
  ------------------
  |  Branch (201:14): [True: 15.7k, False: 251]
  ------------------
  202|  15.7k|            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|  15.7k|            i = 0;
  207|  15.7k|            p = answer.integer.ptr;
  208|  15.7k|            UC const* int_end = p + answer.integer.len();
  209|  15.7k|            const uint64_t minimal_nineteen_digit_integer{1000000000000000000};
  210|   239k|            while ((i < minimal_nineteen_digit_integer) && (p != int_end)) {
  ------------------
  |  Branch (210:20): [True: 230k, False: 9.30k]
  |  Branch (210:60): [True: 224k, False: 6.43k]
  ------------------
  211|   224k|               i = i * 10 + uint64_t(*p - UC('0'));
  212|   224k|               ++p;
  213|   224k|            }
  214|  15.7k|            if (i >= minimal_nineteen_digit_integer) { // We have a big integers
  ------------------
  |  Branch (214:17): [True: 9.30k, False: 6.43k]
  ------------------
  215|  9.30k|               exponent = end_of_integer_part - p + exp_number;
  216|  9.30k|            }
  217|  6.43k|            else { // We have a value with a fractional component.
  218|  6.43k|               p = answer.fraction.ptr;
  219|  6.43k|               UC const* frac_end = p + answer.fraction.len();
  220|  85.3k|               while ((i < minimal_nineteen_digit_integer) && (p != frac_end)) {
  ------------------
  |  Branch (220:23): [True: 78.9k, False: 6.43k]
  |  Branch (220:63): [True: 78.9k, False: 0]
  ------------------
  221|  78.9k|                  i = i * 10 + uint64_t(*p - UC('0'));
  222|  78.9k|                  ++p;
  223|  78.9k|               }
  224|  6.43k|               exponent = answer.fraction.ptr - p + exp_number;
  225|  6.43k|            }
  226|       |            // We have now corrected both exponent and i, to a truncated value
  227|  15.7k|         }
  228|  15.9k|      }
  229|  23.0k|      answer.exponent = exponent;
  230|  23.0k|      answer.mantissa = i;
  231|  23.0k|      return answer;
  232|  23.0k|   }
_ZZN3glz19parse_number_stringILb1EcEENS_10fast_float22parsed_number_string_tIT0_EEPKS3_S6_ENKUlvE_clEv:
   71|  23.0k|      const bool has_decimal_point = [&] {
   72|  23.0k|         if constexpr (null_terminated) {
   73|  23.0k|            return (*p == decimal_point);
   74|       |         }
   75|       |         else {
   76|       |            return (p != pend) && (*p == decimal_point);
   77|       |         }
   78|  23.0k|      }();

_ZN3glz7skip_wsIXtlNS_7ws_optsELb0ELb1ELb1EEETkNS_10is_contextERNS_7contextERPKcS5_EEbOT0_OT1_T2_:
  622|   208k|   {
  623|   208k|      using namespace glz::detail;
  624|       |
  625|   208k|      if constexpr (not Opts.minified) {
  626|   208k|         if constexpr (Opts.null_terminated) {
  627|   208k|            if constexpr (Opts.comments) {
  628|   240k|               while (whitespace_comment_table[uint8_t(*it)]) {
  ------------------
  |  Branch (628:23): [True: 31.8k, False: 208k]
  ------------------
  629|  31.8k|                  if (*it == '/') [[unlikely]] {
  ------------------
  |  Branch (629:23): [True: 9.41k, False: 22.3k]
  ------------------
  630|  9.41k|                     skip_comment(ctx, it, end);
  631|  9.41k|                     if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (631:26): [True: 209, False: 9.20k]
  ------------------
  632|    209|                        return true;
  633|    209|                     }
  634|  9.41k|                  }
  635|  22.3k|                  else [[likely]] {
  636|  22.3k|                     ++it;
  637|  22.3k|                  }
  638|  31.8k|               }
  639|       |            }
  640|       |            else {
  641|       |               while (whitespace_table[uint8_t(*it)]) {
  642|       |                  ++it;
  643|       |               }
  644|       |            }
  645|       |         }
  646|       |         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|       |            else {
  665|       |               while (it < end && whitespace_table[uint8_t(*it)]) {
  666|       |                  ++it;
  667|       |               }
  668|       |               if (it == end) [[unlikely]] {
  669|       |                  ctx.error = error_code::end_reached;
  670|       |                  return true;
  671|       |               }
  672|       |            }
  673|       |         }
  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|   208k|      return false;
  686|   208k|   }
_ZN3glz12skip_commentITkNS_10is_contextERNS_7contextERPKcS4_EEvOT_OT0_T1_:
  503|  9.41k|   {
  504|  9.41k|      ++it;
  505|  9.41k|      if (it == end) [[unlikely]] {
  ------------------
  |  Branch (505:11): [True: 39, False: 9.37k]
  ------------------
  506|     39|         ctx.error = error_code::unexpected_end;
  507|     39|      }
  508|  9.37k|      else if (*it == '/') {
  ------------------
  |  Branch (508:16): [True: 5.74k, False: 3.63k]
  ------------------
  509|   895k|         while (++it != end && *it != '\n');
  ------------------
  |  Branch (509:17): [True: 894k, False: 341]
  |  Branch (509:32): [True: 889k, False: 5.40k]
  ------------------
  510|  5.74k|      }
  511|  3.63k|      else if (*it == '*') {
  ------------------
  |  Branch (511:16): [True: 3.46k, False: 170]
  ------------------
  512|  11.6k|         while (++it != end) {
  ------------------
  |  Branch (512:17): [True: 11.1k, False: 517]
  ------------------
  513|  11.1k|            if (*it == '*') [[unlikely]] {
  ------------------
  |  Branch (513:17): [True: 5.98k, False: 5.19k]
  ------------------
  514|  5.98k|               if (++it == end) [[unlikely]]
  ------------------
  |  Branch (514:20): [True: 30, False: 5.95k]
  ------------------
  515|     30|                  break;
  516|  5.95k|               else if (*it == '/') [[likely]] {
  ------------------
  |  Branch (516:25): [True: 2.91k, False: 3.03k]
  ------------------
  517|  2.91k|                  ++it;
  518|  2.91k|                  break;
  519|  2.91k|               }
  520|  5.98k|            }
  521|  11.1k|         }
  522|  3.46k|      }
  523|    170|      else [[unlikely]] {
  524|    170|         ctx.error = error_code::expected_end_comment;
  525|    170|      }
  526|  9.41k|   }
_ZN3glz17match_invalid_endILc123EXtlNS_22match_invalid_end_optsELb1EEETkNS_10is_contextENS_7contextERPKcS4_EEbRT1_OT2_T3_:
  411|  7.36k|   {
  412|  7.36k|      if (*it != C) [[unlikely]] {
  ------------------
  |  Branch (412:11): [True: 107, False: 7.26k]
  ------------------
  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|    107|         else if constexpr (C == '{' || C == '}') {
  426|    107|            ctx.error = error_code::expected_brace;
  427|       |         }
  428|       |         else {
  429|       |            ctx.error = error_code::syntax_error;
  430|       |         }
  431|    107|         return true;
  432|    107|      }
  433|  7.26k|      else [[likely]] {
  434|  7.26k|         ++it;
  435|  7.26k|      }
  436|       |      if constexpr (not Opts.null_terminated) {
  437|       |         if (it == end) [[unlikely]] {
  438|       |            ctx.error = error_code::unexpected_end;
  439|       |            return true;
  440|       |         }
  441|       |      }
  442|  7.26k|      return false;
  443|  7.36k|   }
_ZN3glz17match_invalid_endILc44EXtlNS_22match_invalid_end_optsELb1EEETkNS_10is_contextENS_7contextERPKcS4_EEbRT1_OT2_T3_:
  411|  41.2k|   {
  412|  41.2k|      if (*it != C) [[unlikely]] {
  ------------------
  |  Branch (412:11): [True: 3.88k, False: 37.3k]
  ------------------
  413|       |         if constexpr (C == '"') {
  414|       |            ctx.error = error_code::expected_quote;
  415|       |         }
  416|  3.88k|         else if constexpr (C == ',') {
  417|  3.88k|            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|  3.88k|         return true;
  432|  3.88k|      }
  433|  37.3k|      else [[likely]] {
  434|  37.3k|         ++it;
  435|  37.3k|      }
  436|       |      if constexpr (not Opts.null_terminated) {
  437|       |         if (it == end) [[unlikely]] {
  438|       |            ctx.error = error_code::unexpected_end;
  439|       |            return true;
  440|       |         }
  441|       |      }
  442|  37.3k|      return false;
  443|  41.2k|   }
_ZN3glz17match_invalid_endILc58EXtlNS_22match_invalid_end_optsELb1EEETkNS_10is_contextENS_7contextERPKcS4_EEbRT1_OT2_T3_:
  411|  44.1k|   {
  412|  44.1k|      if (*it != C) [[unlikely]] {
  ------------------
  |  Branch (412:11): [True: 410, False: 43.7k]
  ------------------
  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|    410|         else if constexpr (C == ':') {
  420|    410|            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|    410|         return true;
  432|    410|      }
  433|  43.7k|      else [[likely]] {
  434|  43.7k|         ++it;
  435|  43.7k|      }
  436|       |      if constexpr (not Opts.null_terminated) {
  437|       |         if (it == end) [[unlikely]] {
  438|       |            ctx.error = error_code::unexpected_end;
  439|       |            return true;
  440|       |         }
  441|       |      }
  442|  43.7k|      return false;
  443|  44.1k|   }
_ZN3glz17match_invalid_endILc34EXtlNS_22match_invalid_end_optsELb1EEETkNS_10is_contextENS_7contextERPKcS4_EEbRT1_OT2_T3_:
  411|  5.17k|   {
  412|  5.17k|      if (*it != C) [[unlikely]] {
  ------------------
  |  Branch (412:11): [True: 97, False: 5.07k]
  ------------------
  413|     97|         if constexpr (C == '"') {
  414|     97|            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|     97|         return true;
  432|     97|      }
  433|  5.07k|      else [[likely]] {
  434|  5.07k|         ++it;
  435|  5.07k|      }
  436|       |      if constexpr (not Opts.null_terminated) {
  437|       |         if (it == end) [[unlikely]] {
  438|       |            ctx.error = error_code::unexpected_end;
  439|       |            return true;
  440|       |         }
  441|       |      }
  442|  5.07k|      return false;
  443|  5.17k|   }
_ZN3glz9has_quoteEm:
  534|  1.50M|   {
  535|  1.50M|      return has_zero(chunk ^ repeat_byte8('"'));
  536|  1.50M|   }
_ZN3glz8has_zeroEm:
  529|  1.50M|   {
  530|  1.50M|      return (((chunk - 0x0101010101010101u) & ~chunk) & 0x8080808080808080u);
  531|  1.50M|   }
_ZN3glz18validate_utf8_spanITnDaXtlNS_4optsELj10ELb1ELb1ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEETkNS_10is_contextERNS_7contextEccEEbOT0_PKT1_PKT2_m:
  832|  4.99k|   {
  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|  4.99k|      else {
  840|  4.99k|         if ((ascii_acc & repeat_byte8(0b10000000)) == 0) {
  ------------------
  |  Branch (840:14): [True: 2.91k, False: 2.07k]
  ------------------
  841|  2.91k|            return false; // pure ASCII is trivially well formed UTF-8
  842|  2.91k|         }
  843|  2.07k|         if (!validate_utf8(start, size_t(fin - start))) [[unlikely]] {
  ------------------
  |  Branch (843:14): [True: 173, False: 1.90k]
  ------------------
  844|    173|            ctx.error = error_code::invalid_utf8;
  845|    173|            return true;
  846|    173|         }
  847|  1.90k|         return false;
  848|  2.07k|      }
  849|  4.99k|   }
_ZN3glz13validate_utf8IcEEbPKT_m:
  801|  2.07k|   {
  802|  2.07k|      const uint8_t* it = reinterpret_cast<const uint8_t*>(str);
  803|  2.07k|      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|  2.07k|      return validate_utf8_scalar(it, end);
  815|  2.07k|   }
_ZN3glz20validate_utf8_scalarEPKhS1_:
  752|  2.07k|   {
  753|  87.9k|      while (it < end) {
  ------------------
  |  Branch (753:14): [True: 86.0k, False: 1.90k]
  ------------------
  754|       |         // Optimistic SWAR check for ASCII
  755|  86.0k|         if (it + 8 <= end) {
  ------------------
  |  Branch (755:14): [True: 83.6k, False: 2.44k]
  ------------------
  756|  83.6k|            uint64_t chunk;
  757|  83.6k|            std::memcpy(&chunk, it, 8);
  758|  83.6k|            if ((chunk & glz::repeat_byte8(0x80)) == 0) {
  ------------------
  |  Branch (758:17): [True: 75.3k, False: 8.25k]
  ------------------
  759|  75.3k|               it += 8;
  760|  75.3k|               continue;
  761|  75.3k|            }
  762|  83.6k|         }
  763|       |
  764|       |         // Byte-by-byte validation (standard conformant)
  765|  10.7k|         uint8_t byte = *it;
  766|       |
  767|  10.7k|         if (byte < 0x80) {
  ------------------
  |  Branch (767:14): [True: 7.80k, False: 2.89k]
  ------------------
  768|  7.80k|            it++;
  769|  7.80k|         }
  770|  2.89k|         else if ((byte & 0xE0) == 0xC0) {
  ------------------
  |  Branch (770:19): [True: 662, False: 2.23k]
  ------------------
  771|       |            // 2-byte sequence
  772|    662|            if (it + 2 > end || (it[1] & 0xC0) != 0x80) return false;
  ------------------
  |  Branch (772:17): [True: 6, False: 656]
  |  Branch (772:33): [True: 16, False: 640]
  ------------------
  773|    640|            if (byte < 0xC2) return false; // Overlong
  ------------------
  |  Branch (773:17): [True: 6, False: 634]
  ------------------
  774|    634|            it += 2;
  775|    634|         }
  776|  2.23k|         else if ((byte & 0xF0) == 0xE0) {
  ------------------
  |  Branch (776:19): [True: 1.51k, False: 716]
  ------------------
  777|       |            // 3-byte sequence
  778|  1.51k|            if (it + 3 > end || (it[1] & 0xC0) != 0x80 || (it[2] & 0xC0) != 0x80) return false;
  ------------------
  |  Branch (778:17): [True: 4, False: 1.51k]
  |  Branch (778:33): [True: 8, False: 1.50k]
  |  Branch (778:59): [True: 9, False: 1.49k]
  ------------------
  779|  1.49k|            if (byte == 0xE0 && it[1] < 0xA0) return false; // Overlong
  ------------------
  |  Branch (779:17): [True: 400, False: 1.09k]
  |  Branch (779:33): [True: 13, False: 387]
  ------------------
  780|  1.48k|            if (byte == 0xED && it[1] >= 0xA0) return false; // Surrogate
  ------------------
  |  Branch (780:17): [True: 321, False: 1.16k]
  |  Branch (780:33): [True: 5, False: 316]
  ------------------
  781|  1.47k|            it += 3;
  782|  1.47k|         }
  783|    716|         else if ((byte & 0xF8) == 0xF0) {
  ------------------
  |  Branch (783:19): [True: 669, False: 47]
  ------------------
  784|       |            // 4-byte sequence
  785|    669|            if (it + 4 > end || (it[1] & 0xC0) != 0x80 || (it[2] & 0xC0) != 0x80 || (it[3] & 0xC0) != 0x80)
  ------------------
  |  Branch (785:17): [True: 6, False: 663]
  |  Branch (785:33): [True: 18, False: 645]
  |  Branch (785:59): [True: 5, False: 640]
  |  Branch (785:85): [True: 7, False: 633]
  ------------------
  786|     36|               return false;
  787|    633|            if (byte == 0xF0 && it[1] < 0x90) return false; // Overlong
  ------------------
  |  Branch (787:17): [True: 228, False: 405]
  |  Branch (787:33): [True: 10, False: 218]
  ------------------
  788|    623|            if (byte == 0xF4 && it[1] >= 0x90) return false; // > U+10FFFF
  ------------------
  |  Branch (788:17): [True: 348, False: 275]
  |  Branch (788:33): [True: 5, False: 343]
  ------------------
  789|    618|            if (byte > 0xF4) return false; // > U+10FFFF
  ------------------
  |  Branch (789:17): [True: 8, False: 610]
  ------------------
  790|    610|            it += 4;
  791|    610|         }
  792|     47|         else {
  793|     47|            return false;
  794|     47|         }
  795|  10.7k|      }
  796|       |
  797|  1.90k|      return true;
  798|  2.07k|   }
_ZN3glz25handle_unicode_code_pointIccEEjRPKT_RPT0_S3_:
  288|  2.04k|   {
  289|  2.04k|      using namespace unicode;
  290|       |
  291|  2.04k|      if (it + 4 >= end) [[unlikely]] {
  ------------------
  |  Branch (291:11): [True: 2, False: 2.04k]
  ------------------
  292|      2|         return false;
  293|      2|      }
  294|  2.04k|      const uint32_t high = hex_to_u32(it);
  295|  2.04k|      if (high == 0xFFFFFFFFu) [[unlikely]] {
  ------------------
  |  Branch (295:11): [True: 28, False: 2.01k]
  ------------------
  296|     28|         return false;
  297|     28|      }
  298|  2.01k|      it += 4; // skip the code point characters
  299|       |
  300|  2.01k|      uint32_t code_point;
  301|       |
  302|  2.01k|      if ((high & generic_surrogate_mask) == generic_surrogate_value) {
  ------------------
  |  Branch (302:11): [True: 515, False: 1.50k]
  ------------------
  303|       |         // surrogate pair code points
  304|    515|         if ((high & surrogate_mask) != high_surrogate_value) {
  ------------------
  |  Branch (304:14): [True: 6, False: 509]
  ------------------
  305|      6|            return false;
  306|      6|         }
  307|       |
  308|    509|         if (it + 6 >= end) [[unlikely]] {
  ------------------
  |  Branch (308:14): [True: 3, False: 506]
  ------------------
  309|      3|            return false;
  310|      3|         }
  311|       |         // The next two characters must be `\u`
  312|    506|         uint16_t u;
  313|    506|         std::memcpy(&u, it, 2);
  314|    506|         if (u != to_uint16_t(R"(\u)")) [[unlikely]] {
  ------------------
  |  Branch (314:14): [True: 33, False: 473]
  ------------------
  315|     33|            return false;
  316|     33|         }
  317|    473|         it += 2;
  318|       |         // verify that second unicode escape sequence is present
  319|    473|         const uint32_t low = hex_to_u32(it);
  320|    473|         if (low == 0xFFFFFFFFu) [[unlikely]] {
  ------------------
  |  Branch (320:14): [True: 5, False: 468]
  ------------------
  321|      5|            return false;
  322|      5|         }
  323|    468|         it += 4;
  324|       |
  325|    468|         if ((low & surrogate_mask) != low_surrogate_value) [[unlikely]] {
  ------------------
  |  Branch (325:14): [True: 20, False: 448]
  ------------------
  326|     20|            return false;
  327|     20|         }
  328|       |
  329|    448|         code_point = (high & surrogate_codepoint_mask) << surrogate_codepoint_bits;
  330|    448|         code_point |= (low & surrogate_codepoint_mask);
  331|    448|         code_point += surrogate_codepoint_offset;
  332|    448|      }
  333|  1.50k|      else {
  334|  1.50k|         code_point = high;
  335|  1.50k|      }
  336|  1.95k|      const uint32_t offset = code_point_to_utf8(code_point, dst);
  337|  1.95k|      dst += offset;
  338|  1.95k|      return offset;
  339|  2.01k|   }
_ZN3glz10hex_to_u32EPKc:
  203|  2.51k|   {
  204|  2.51k|      constexpr auto& t = digit_hex_table;
  205|  2.51k|      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|  2.51k|      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|  2.51k|      if (chunk & repeat_byte4(0b11110000u)) [[unlikely]] {
  ------------------
  |  Branch (213:11): [True: 33, False: 2.48k]
  ------------------
  214|     33|         return 0xFFFFFFFFu;
  215|     33|      }
  216|       |
  217|       |      // now pack into first four bytes of uint32_t
  218|  2.48k|      uint32_t packed{};
  219|  2.48k|      packed |= (chunk & 0x0000000F);
  220|  2.48k|      packed |= (chunk & 0x00000F00) >> 4;
  221|  2.48k|      packed |= (chunk & 0x000F0000) >> 8;
  222|  2.48k|      packed |= (chunk & 0x0F000000) >> 12;
  223|  2.48k|      return packed;
  224|  2.51k|   }
_ZN3glz18code_point_to_utf8IcEEjjPT_:
  228|  1.95k|   {
  229|  1.95k|      if (code_point <= 0x7F) {
  ------------------
  |  Branch (229:11): [True: 419, False: 1.53k]
  ------------------
  230|    419|         c[0] = Char(code_point);
  231|    419|         return 1;
  232|    419|      }
  233|  1.53k|      if (code_point <= 0x7FF) {
  ------------------
  |  Branch (233:11): [True: 461, False: 1.07k]
  ------------------
  234|    461|         c[0] = Char(0xC0 | ((code_point >> 6) & 0x1F));
  235|    461|         c[1] = Char(0x80 | (code_point & 0x3F));
  236|    461|         return 2;
  237|    461|      }
  238|  1.07k|      if (code_point <= 0xFFFF) {
  ------------------
  |  Branch (238:11): [True: 622, False: 448]
  ------------------
  239|    622|         c[0] = Char(0xE0 | ((code_point >> 12) & 0x0F));
  240|    622|         c[1] = Char(0x80 | ((code_point >> 6) & 0x3F));
  241|    622|         c[2] = Char(0x80 | (code_point & 0x3F));
  242|    622|         return 3;
  243|    622|      }
  244|    448|      if (code_point <= 0x10FFFF) {
  ------------------
  |  Branch (244:11): [True: 448, False: 0]
  ------------------
  245|    448|         c[0] = Char(0xF0 | ((code_point >> 18) & 0x07));
  246|    448|         c[1] = Char(0x80 | ((code_point >> 12) & 0x3F));
  247|    448|         c[2] = Char(0x80 | ((code_point >> 6) & 0x3F));
  248|    448|         c[3] = Char(0x80 | (code_point & 0x3F));
  249|    448|         return 4;
  250|    448|      }
  251|      0|      return 0;
  252|    448|   }
_ZN3glz17match_invalid_endILc91EXtlNS_22match_invalid_end_optsELb1EEETkNS_10is_contextENS_7contextERPKcS4_EEbRT1_OT2_T3_:
  411|  7.27k|   {
  412|  7.27k|      if (*it != C) [[unlikely]] {
  ------------------
  |  Branch (412:11): [True: 108, False: 7.17k]
  ------------------
  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|    108|         else if constexpr (C == '[' || C == ']') {
  423|    108|            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|    108|         return true;
  432|    108|      }
  433|  7.17k|      else [[likely]] {
  434|  7.17k|         ++it;
  435|  7.17k|      }
  436|       |      if constexpr (not Opts.null_terminated) {
  437|       |         if (it == end) [[unlikely]] {
  438|       |            ctx.error = error_code::unexpected_end;
  439|       |            return true;
  440|       |         }
  441|       |      }
  442|  7.17k|      return false;
  443|  7.27k|   }