LLVMFuzzerTestOneInput:
   16|  12.0k|{
   17|       |   // use a vector with null termination instead of a std::string to avoid
   18|       |   // small string optimization to hide bounds problems
   19|  12.0k|   std::vector<char> buffer{Data, Data + Size};
   20|       |
   21|       |   // non-null terminated
   22|  12.0k|   {
   23|  12.0k|      const auto& input = buffer;
   24|  12.0k|      [[maybe_unused]] auto s = glz::read_beve<my_struct>(input);
   25|       |
   26|  12.0k|      std::string json_output{};
   27|  12.0k|      [[maybe_unused]] auto ec = glz::beve_to_json(input, json_output);
   28|  12.0k|   }
   29|       |
   30|       |   // null terminated
   31|  12.0k|   {
   32|  12.0k|      buffer.push_back('\0');
   33|  12.0k|      const auto& input = buffer;
   34|  12.0k|      [[maybe_unused]] auto s = glz::read_beve<my_struct>(input);
   35|  12.0k|   }
   36|       |
   37|  12.0k|   return 0;
   38|  12.0k|}

_ZN3glz12beve_to_jsonITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEENSt3__16vectorIcNS2_9allocatorIcEEEENS2_12basic_stringIcNS2_11char_traitsIcEES5_EEEENS_9error_ctxERKT0_RT1_:
  789|  12.0k|   {
  790|  12.0k|      size_t ix{}; // write index
  791|       |
  792|  12.0k|      auto* it = beve.data();
  793|  12.0k|      auto* end = it + beve.size();
  794|       |
  795|  12.0k|      context ctx{};
  796|       |
  797|  12.0k|      if (it >= end) {
  ------------------
  |  Branch (797:11): [True: 0, False: 12.0k]
  ------------------
  798|      0|         return {0, error_code::unexpected_end};
  799|      0|      }
  800|       |
  801|  12.0k|      bool needs_separator = false;
  802|       |
  803|  6.78M|      while (it < end) {
  ------------------
  |  Branch (803:14): [True: 6.77M, False: 3.42k]
  ------------------
  804|  6.77M|         const bool is_delimiter = uint8_t(*it) == tag::delimiter;
  805|       |
  806|  6.77M|         if (needs_separator && !is_delimiter) {
  ------------------
  |  Branch (806:14): [True: 6.74M, False: 37.6k]
  |  Branch (806:33): [True: 6.74M, False: 1.17k]
  ------------------
  807|  6.74M|            if (!detail::emit_char(ctx, '\n', out, ix)) {
  ------------------
  |  Branch (807:17): [True: 0, False: 6.74M]
  ------------------
  808|      0|               return {ix, ctx.error};
  809|      0|            }
  810|  6.74M|         }
  811|  6.77M|         needs_separator = !is_delimiter;
  812|       |
  813|  6.77M|         detail::beve_to_json_value<Opts>(ctx, it, end, out, ix, 0);
  814|  6.77M|         if (bool(ctx.error)) {
  ------------------
  |  Branch (814:14): [True: 8.64k, False: 6.77M]
  ------------------
  815|  8.64k|            return {ix, ctx.error};
  816|  8.64k|         }
  817|  6.77M|      }
  818|       |
  819|  3.42k|      if constexpr (resizable<JSONBuffer>) {
  820|  3.42k|         out.resize(ix);
  821|  3.42k|      }
  822|       |
  823|       |      // count is the number of bytes written. A resizable buffer carries its own size, but a
  824|       |      // fixed-size one has no other way to learn how much of it now holds JSON.
  825|  3.42k|      return {ix};
  826|  12.0k|   }
_ZN3glz6detail18beve_to_json_valueITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEERNS_7contextERPKcSE_RmEEvOT1_OT2_OT3_RT0_OT4_j:
  114|  22.9M|      {
  115|  22.9M|         if (it >= end) [[unlikely]] {
  ------------------
  |  Branch (115:14): [True: 785, False: 22.9M]
  ------------------
  116|    785|            ctx.error = error_code::syntax_error;
  117|    785|            return;
  118|    785|         }
  119|  22.9M|         const auto tag = uint8_t(*it);
  120|  22.9M|         const auto type = tag & 0b00000'111;
  121|       |
  122|       |         // `recursive_depth` is the number of levels enclosing this value. Containers, and the
  123|       |         // extensions that wrap a value, open another; scalars do not, so as in the readers a scalar
  124|       |         // may sit inside the deepest container the limit allows.
  125|  22.9M|         const bool opens_level = type != tag::null && type != tag::number && type != tag::string;
  ------------------
  |  Branch (125:35): [True: 7.08M, False: 15.8M]
  |  Branch (125:56): [True: 6.98M, False: 94.9k]
  |  Branch (125:79): [True: 6.97M, False: 14.6k]
  ------------------
  126|  22.9M|         if (opens_level && recursive_depth >= max_recursive_depth_limit) [[unlikely]] {
  ------------------
  |  Branch (126:14): [True: 6.97M, False: 15.9M]
  |  Branch (126:29): [True: 12, False: 6.97M]
  ------------------
  127|     12|            ctx.error = error_code::exceeded_max_recursive_depth;
  128|     12|            return;
  129|     12|         }
  130|       |
  131|  22.9M|         switch (type) {
  132|  15.8M|         case tag::null: {
  ------------------
  |  Branch (132:10): [True: 15.8M, False: 7.08M]
  ------------------
  133|  15.8M|            if (tag & tag::boolean) {
  ------------------
  |  Branch (133:17): [True: 1.95M, False: 13.8M]
  ------------------
  134|  1.95M|               if (tag >> 4) {
  ------------------
  |  Branch (134:20): [True: 783k, False: 1.16M]
  ------------------
  135|   783k|                  if (!emit_literal<"true">(ctx, out, ix)) return;
  ------------------
  |  Branch (135:23): [True: 0, False: 783k]
  ------------------
  136|   783k|               }
  137|  1.16M|               else {
  138|  1.16M|                  if (!emit_literal<"false">(ctx, out, ix)) return;
  ------------------
  |  Branch (138:23): [True: 0, False: 1.16M]
  ------------------
  139|  1.16M|               }
  140|  1.95M|            }
  141|  13.8M|            else {
  142|  13.8M|               if (!emit_literal<"null">(ctx, out, ix)) return;
  ------------------
  |  Branch (142:20): [True: 0, False: 13.8M]
  ------------------
  143|  13.8M|            }
  144|  15.8M|            ++it;
  145|  15.8M|            break;
  146|  15.8M|         }
  147|  94.9k|         case tag::number: {
  ------------------
  |  Branch (147:10): [True: 94.9k, False: 22.8M]
  ------------------
  148|  94.9k|            ++it;
  149|  94.9k|            beve_to_json_number<Opts>(tag, ctx, it, end, out, ix);
  150|  94.9k|            if (bool(ctx.error)) return;
  ------------------
  |  Branch (150:17): [True: 246, False: 94.6k]
  ------------------
  151|  94.6k|            break;
  152|  94.9k|         }
  153|  94.6k|         case tag::string: {
  ------------------
  |  Branch (153:10): [True: 14.6k, False: 22.8M]
  ------------------
  154|  14.6k|            ++it;
  155|  14.6k|            const auto n = int_from_compressed(ctx, it, end);
  156|  14.6k|            if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (156:17): [True: 143, False: 14.5k]
  ------------------
  157|    143|               return;
  158|    143|            }
  159|  14.5k|            if (uint64_t(end - it) < n) [[unlikely]] {
  ------------------
  |  Branch (159:17): [True: 187, False: 14.3k]
  ------------------
  160|    187|               ctx.error = error_code::unexpected_end;
  161|    187|               return;
  162|    187|            }
  163|  14.3k|            const sv value{reinterpret_cast<const char*>(it), n};
  164|  14.3k|            detail::emit_untrusted_string<Opts>(ctx, value, out, ix);
  165|  14.3k|            if (bool(ctx.error)) [[unlikely]]
  ------------------
  |  Branch (165:17): [True: 136, False: 14.2k]
  ------------------
  166|    136|               return;
  167|  14.2k|            it += n;
  168|  14.2k|            break;
  169|  14.3k|         }
  170|  13.2k|         case tag::object: {
  ------------------
  |  Branch (170:10): [True: 13.2k, False: 22.8M]
  ------------------
  171|  13.2k|            ++it;
  172|       |
  173|  13.2k|            if (!emit_char(ctx, '{', out, ix)) return;
  ------------------
  |  Branch (173:17): [True: 0, False: 13.2k]
  ------------------
  174|  13.2k|            {
  175|       |               // The indentation this object adds belongs to it, so every way out -- including an
  176|       |               // error return from a nested value -- puts the depth back.
  177|  13.2k|               const indent_guard indent{ctx, Opts.prettify ? check_indentation_width(Opts) : 1};
  ------------------
  |  Branch (177:47): [Folded, False: 13.2k]
  ------------------
  178|       |
  179|       |               if constexpr (Opts.prettify) {
  180|       |                  if (!emit_newline_indent<Opts>(ctx, out, ix)) return;
  181|       |               }
  182|       |
  183|  13.2k|               const auto key_type = (tag & 0b000'11'000) >> 3;
  184|  13.2k|               switch (key_type) {
  185|  8.05k|               case 0: {
  ------------------
  |  Branch (185:16): [True: 8.05k, False: 5.23k]
  ------------------
  186|       |                  // string key
  187|  8.05k|                  const auto n_fields = int_from_compressed(ctx, it, end);
  188|  8.05k|                  if (bool(ctx.error)) {
  ------------------
  |  Branch (188:23): [True: 154, False: 7.90k]
  ------------------
  189|    154|                     return;
  190|    154|                  }
  191|  1.65M|                  for (size_t i = 0; i < n_fields; ++i) {
  ------------------
  |  Branch (191:38): [True: 1.64M, False: 5.12k]
  ------------------
  192|       |                     // convert the key
  193|  1.64M|                     const auto n = int_from_compressed(ctx, it, end);
  194|  1.64M|                     if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (194:26): [True: 647, False: 1.64M]
  ------------------
  195|    647|                        return;
  196|    647|                     }
  197|  1.64M|                     if (uint64_t(end - it) < n) [[unlikely]] {
  ------------------
  |  Branch (197:26): [True: 337, False: 1.64M]
  ------------------
  198|    337|                        ctx.error = error_code::unexpected_end;
  199|    337|                        return;
  200|    337|                     }
  201|  1.64M|                     const sv key{reinterpret_cast<const char*>(it), n};
  202|  1.64M|                     detail::emit_untrusted_string<Opts>(ctx, key, out, ix);
  203|  1.64M|                     if (bool(ctx.error)) [[unlikely]]
  ------------------
  |  Branch (203:26): [True: 185, False: 1.64M]
  ------------------
  204|    185|                        return;
  205|       |                     if constexpr (Opts.prettify) {
  206|       |                        if (!emit_literal<": ">(ctx, out, ix)) return;
  207|       |                     }
  208|  1.64M|                     else {
  209|  1.64M|                        if (!emit_char(ctx, ':', out, ix)) return;
  ------------------
  |  Branch (209:29): [True: 0, False: 1.64M]
  ------------------
  210|  1.64M|                     }
  211|  1.64M|                     it += n;
  212|  1.64M|                     beve_to_json_value<Opts>(ctx, it, end, out, ix, recursive_depth + 1);
  213|  1.64M|                     if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (213:26): [True: 1.61k, False: 1.64M]
  ------------------
  214|  1.61k|                        return;
  215|  1.61k|                     }
  216|  1.64M|                     if (i != n_fields - 1) {
  ------------------
  |  Branch (216:26): [True: 1.64M, False: 346]
  ------------------
  217|  1.64M|                        if (!emit_char(ctx, ',', out, ix)) return;
  ------------------
  |  Branch (217:29): [True: 0, False: 1.64M]
  ------------------
  218|       |                        if constexpr (Opts.prettify) {
  219|       |                           if (!emit_newline_indent<Opts>(ctx, out, ix)) return;
  220|       |                        }
  221|  1.64M|                     }
  222|  1.64M|                  }
  223|  5.12k|                  break;
  224|  7.90k|               }
  225|  5.12k|               case 1:
  ------------------
  |  Branch (225:16): [True: 3.58k, False: 9.70k]
  ------------------
  226|  3.58k|                  [[fallthrough]]; // signed integer key
  227|  5.18k|               case 2: {
  ------------------
  |  Branch (227:16): [True: 1.60k, False: 11.6k]
  ------------------
  228|       |                  // unsigned integer key
  229|  5.18k|                  const auto n_fields = int_from_compressed(ctx, it, end);
  230|  5.18k|                  if (bool(ctx.error)) {
  ------------------
  |  Branch (230:23): [True: 61, False: 5.12k]
  ------------------
  231|     61|                     return;
  232|     61|                  }
  233|   616k|                  for (size_t i = 0; i < n_fields; ++i) {
  ------------------
  |  Branch (233:38): [True: 613k, False: 3.65k]
  ------------------
  234|       |                     // convert the key
  235|   613k|                     if (!emit_char(ctx, '"', out, ix)) return;
  ------------------
  |  Branch (235:26): [True: 0, False: 613k]
  ------------------
  236|   613k|                     beve_to_json_number<Opts>(tag, ctx, it, end, out, ix);
  237|   613k|                     if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (237:26): [True: 233, False: 612k]
  ------------------
  238|    233|                        return;
  239|    233|                     }
  240|   612k|                     if (!emit_char(ctx, '"', out, ix)) return;
  ------------------
  |  Branch (240:26): [True: 0, False: 612k]
  ------------------
  241|       |                     if constexpr (Opts.prettify) {
  242|       |                        if (!emit_literal<": ">(ctx, out, ix)) return;
  243|       |                     }
  244|   612k|                     else {
  245|   612k|                        if (!emit_char(ctx, ':', out, ix)) return;
  ------------------
  |  Branch (245:29): [True: 0, False: 612k]
  ------------------
  246|   612k|                     }
  247|   612k|                     beve_to_json_value<Opts>(ctx, it, end, out, ix, recursive_depth + 1);
  248|   612k|                     if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (248:26): [True: 1.24k, False: 611k]
  ------------------
  249|  1.24k|                        return;
  250|  1.24k|                     }
  251|   611k|                     if (i != n_fields - 1) {
  ------------------
  |  Branch (251:26): [True: 611k, False: 490]
  ------------------
  252|   611k|                        if (!emit_char(ctx, ',', out, ix)) return;
  ------------------
  |  Branch (252:29): [True: 0, False: 611k]
  ------------------
  253|       |                        if constexpr (Opts.prettify) {
  254|       |                           if (!emit_newline_indent<Opts>(ctx, out, ix)) return;
  255|       |                        }
  256|   611k|                     }
  257|   611k|                  }
  258|  3.65k|                  break;
  259|  5.12k|               }
  260|  3.65k|               default: {
  ------------------
  |  Branch (260:16): [True: 46, False: 13.2k]
  ------------------
  261|     46|                  ctx.error = error_code::syntax_error;
  262|     46|                  return;
  263|  5.12k|               }
  264|  13.2k|               }
  265|  13.2k|            }
  266|       |
  267|       |            if constexpr (Opts.prettify) {
  268|       |               if (!emit_newline_indent<Opts>(ctx, out, ix)) return;
  269|       |            }
  270|  8.77k|            if (!emit_char(ctx, '}', out, ix)) return;
  ------------------
  |  Branch (270:17): [True: 0, False: 8.77k]
  ------------------
  271|  8.77k|            break;
  272|  8.77k|         }
  273|   360k|         case tag::typed_array: {
  ------------------
  |  Branch (273:10): [True: 360k, False: 22.5M]
  ------------------
  274|       |            // Check for aligned typed array (tag == 0x5C)
  275|   360k|            if (tag == tag::aligned_typed_array) {
  ------------------
  |  Branch (275:17): [True: 20.8k, False: 339k]
  ------------------
  276|  20.8k|               ++it; // skip aligned header
  277|  20.8k|               if (it >= end) [[unlikely]] {
  ------------------
  |  Branch (277:20): [True: 7, False: 20.8k]
  ------------------
  278|      7|                  ctx.error = error_code::syntax_error;
  279|      7|                  return;
  280|      7|               }
  281|       |               // Read the numeric header byte
  282|  20.8k|               const auto numeric_tag = uint8_t(*it);
  283|  20.8k|               if ((numeric_tag & 0b00000'111) != tag::typed_array) [[unlikely]] {
  ------------------
  |  Branch (283:20): [True: 19, False: 20.8k]
  ------------------
  284|     19|                  ctx.error = error_code::syntax_error;
  285|     19|                  return;
  286|     19|               }
  287|  20.8k|               ++it; // skip numeric header
  288|  20.8k|               const auto value_type_inner = (numeric_tag & 0b000'11'000) >> 3;
  289|  20.8k|               const uint8_t byte_count_inner = byte_count_lookup[numeric_tag >> 5];
  290|       |
  291|  20.8k|               const auto n = int_from_compressed(ctx, it, end);
  292|  20.8k|               if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (292:20): [True: 158, False: 20.6k]
  ------------------
  293|    158|                  return;
  294|    158|               }
  295|       |
  296|       |               // Read padding length byte and skip padding
  297|  20.6k|               if (it >= end) [[unlikely]] {
  ------------------
  |  Branch (297:20): [True: 201, False: 20.4k]
  ------------------
  298|    201|                  ctx.error = error_code::unexpected_end;
  299|    201|                  return;
  300|    201|               }
  301|  20.4k|               const uint8_t padding = uint8_t(*it);
  302|  20.4k|               ++it;
  303|  20.4k|               if (padding >= byte_count_inner) [[unlikely]] {
  ------------------
  |  Branch (303:20): [True: 26, False: 20.4k]
  ------------------
  304|     26|                  ctx.error = error_code::syntax_error;
  305|     26|                  return;
  306|     26|               }
  307|  20.4k|               if (typed_array_out_of_bounds(ctx, it, end, n, byte_count_inner, padding)) return;
  ------------------
  |  Branch (307:20): [True: 135, False: 20.3k]
  ------------------
  308|  20.3k|               it += padding;
  309|       |
  310|       |               // Now decode as a normal numeric typed array
  311|  20.3k|               if (!emit_char(ctx, '[', out, ix)) return;
  ------------------
  |  Branch (311:20): [True: 0, False: 20.3k]
  ------------------
  312|       |
  313|  20.3k|               auto write_aligned_array = [&]<class T>(T&& value) {
  314|  20.3k|                  for (size_t i = 0; i < n; ++i) {
  315|  20.3k|                     if (size_t(end - it) < sizeof(T)) [[unlikely]] {
  316|  20.3k|                        ctx.error = error_code::unexpected_end;
  317|  20.3k|                        return;
  318|  20.3k|                     }
  319|  20.3k|                     using V = std::remove_cvref_t<T>;
  320|  20.3k|                     std::memcpy(&value, it, sizeof(V));
  321|  20.3k|                     if constexpr (std::endian::native == std::endian::big) {
  322|  20.3k|                        byteswap_le(value);
  323|  20.3k|                     }
  324|  20.3k|                     to<JSON, T>::template op<Opts>(value, ctx, out, ix);
  325|  20.3k|                     it += sizeof(T);
  326|  20.3k|                     if (i != n - 1) {
  327|  20.3k|                        if (!emit_char(ctx, ',', out, ix)) return;
  328|  20.3k|                     }
  329|  20.3k|                  }
  330|  20.3k|               };
  331|       |
  332|  20.3k|               switch (value_type_inner) {
  333|  2.17k|               case 0: {
  ------------------
  |  Branch (333:16): [True: 2.17k, False: 18.1k]
  ------------------
  334|  2.17k|                  switch (byte_count_inner) {
  335|    749|                  case 4:
  ------------------
  |  Branch (335:19): [True: 749, False: 1.42k]
  ------------------
  336|    749|                     write_aligned_array(float{});
  337|    749|                     break;
  338|  1.42k|                  case 8:
  ------------------
  |  Branch (338:19): [True: 1.42k, False: 754]
  ------------------
  339|  1.42k|                     write_aligned_array(double{});
  340|  1.42k|                     break;
  341|      5|                  default:
  ------------------
  |  Branch (341:19): [True: 5, False: 2.17k]
  ------------------
  342|      5|                     ctx.error = error_code::syntax_error;
  343|      5|                     return;
  344|  2.17k|                  }
  345|  2.17k|                  break;
  346|  2.17k|               }
  347|  6.25k|               case 1: {
  ------------------
  |  Branch (347:16): [True: 6.25k, False: 14.0k]
  ------------------
  348|  6.25k|                  switch (byte_count_inner) {
  349|  2.17k|                  case 1:
  ------------------
  |  Branch (349:19): [True: 2.17k, False: 4.07k]
  ------------------
  350|  2.17k|                     write_aligned_array(int8_t{});
  351|  2.17k|                     break;
  352|    896|                  case 2:
  ------------------
  |  Branch (352:19): [True: 896, False: 5.35k]
  ------------------
  353|    896|                     write_aligned_array(int16_t{});
  354|    896|                     break;
  355|  2.19k|                  case 4:
  ------------------
  |  Branch (355:19): [True: 2.19k, False: 4.05k]
  ------------------
  356|  2.19k|                     write_aligned_array(int32_t{});
  357|  2.19k|                     break;
  358|    976|                  case 8:
  ------------------
  |  Branch (358:19): [True: 976, False: 5.27k]
  ------------------
  359|    976|                     write_aligned_array(int64_t{});
  360|    976|                     break;
  361|      4|                  default:
  ------------------
  |  Branch (361:19): [True: 4, False: 6.24k]
  ------------------
  362|      4|                     ctx.error = error_code::syntax_error;
  363|      4|                     return;
  364|  6.25k|                  }
  365|  6.24k|                  break;
  366|  6.25k|               }
  367|  11.8k|               case 2: {
  ------------------
  |  Branch (367:16): [True: 11.8k, False: 8.42k]
  ------------------
  368|  11.8k|                  switch (byte_count_inner) {
  369|    707|                  case 1:
  ------------------
  |  Branch (369:19): [True: 707, False: 11.1k]
  ------------------
  370|    707|                     write_aligned_array(uint8_t{});
  371|    707|                     break;
  372|  3.53k|                  case 2:
  ------------------
  |  Branch (372:19): [True: 3.53k, False: 8.33k]
  ------------------
  373|  3.53k|                     write_aligned_array(uint16_t{});
  374|  3.53k|                     break;
  375|    550|                  case 4:
  ------------------
  |  Branch (375:19): [True: 550, False: 11.3k]
  ------------------
  376|    550|                     write_aligned_array(uint32_t{});
  377|    550|                     break;
  378|  7.07k|                  case 8:
  ------------------
  |  Branch (378:19): [True: 7.07k, False: 4.80k]
  ------------------
  379|  7.07k|                     write_aligned_array(uint64_t{});
  380|  7.07k|                     break;
  381|      4|                  default:
  ------------------
  |  Branch (381:19): [True: 4, False: 11.8k]
  ------------------
  382|      4|                     ctx.error = error_code::syntax_error;
  383|      4|                     return;
  384|  11.8k|                  }
  385|  11.8k|                  break;
  386|  11.8k|               }
  387|  11.8k|               default:
  ------------------
  |  Branch (387:16): [True: 2, False: 20.3k]
  ------------------
  388|      2|                  ctx.error = error_code::syntax_error;
  389|      2|                  return;
  390|  20.3k|               }
  391|       |
  392|  20.2k|               if (!emit_char(ctx, ']', out, ix)) return;
  ------------------
  |  Branch (392:20): [True: 0, False: 20.2k]
  ------------------
  393|  20.2k|               break;
  394|  20.2k|            }
  395|       |
  396|   339k|            ++it;
  397|   339k|            const auto value_type = (tag & 0b000'11'000) >> 3;
  398|   339k|            const uint8_t byte_count = byte_count_lookup[tag >> 5];
  399|       |
  400|   339k|            auto write_array = [&]<class T>(T&& value) {
  401|   339k|               const auto n = int_from_compressed(ctx, it, end);
  402|   339k|               if (bool(ctx.error)) [[unlikely]] {
  403|   339k|                  return;
  404|   339k|               }
  405|   339k|               for (size_t i = 0; i < n; ++i) {
  406|   339k|                  if (size_t(end - it) < sizeof(T)) [[unlikely]] {
  407|   339k|                     ctx.error = error_code::unexpected_end;
  408|   339k|                     return;
  409|   339k|                  }
  410|   339k|                  using V = std::remove_cvref_t<T>;
  411|   339k|                  std::memcpy(&value, it, sizeof(V));
  412|   339k|                  if constexpr (std::endian::native == std::endian::big) {
  413|   339k|                     byteswap_le(value);
  414|   339k|                  }
  415|   339k|                  to<JSON, T>::template op<Opts>(value, ctx, out, ix);
  416|   339k|                  it += sizeof(T);
  417|   339k|                  if (i != n - 1) {
  418|   339k|                     if (!emit_char(ctx, ',', out, ix)) return;
  419|   339k|                  }
  420|   339k|               }
  421|   339k|            };
  422|       |
  423|   339k|            if (!emit_char(ctx, '[', out, ix)) return;
  ------------------
  |  Branch (423:17): [True: 0, False: 339k]
  ------------------
  424|       |
  425|   339k|            switch (value_type) {
  426|  5.48k|            case 0: {
  ------------------
  |  Branch (426:13): [True: 5.48k, False: 333k]
  ------------------
  427|       |               // floating point
  428|  5.48k|               switch (byte_count) {
  429|  3.58k|               case 4: {
  ------------------
  |  Branch (429:16): [True: 3.58k, False: 1.89k]
  ------------------
  430|  3.58k|                  write_array(float{});
  431|  3.58k|                  break;
  432|      0|               }
  433|  1.82k|               case 8: {
  ------------------
  |  Branch (433:16): [True: 1.82k, False: 3.65k]
  ------------------
  434|  1.82k|                  write_array(double{});
  435|  1.82k|                  break;
  436|      0|               }
  437|     66|               default: {
  ------------------
  |  Branch (437:16): [True: 66, False: 5.41k]
  ------------------
  438|     66|                  ctx.error = error_code::syntax_error;
  439|     66|                  return;
  440|      0|               }
  441|  5.48k|               }
  442|  5.41k|               break;
  443|  5.48k|            }
  444|  21.7k|            case 1: {
  ------------------
  |  Branch (444:13): [True: 21.7k, False: 317k]
  ------------------
  445|       |               // signed integer
  446|  21.7k|               switch (byte_count) {
  447|  11.1k|               case 1: {
  ------------------
  |  Branch (447:16): [True: 11.1k, False: 10.5k]
  ------------------
  448|  11.1k|                  write_array(int8_t{});
  449|  11.1k|                  break;
  450|      0|               }
  451|  4.84k|               case 2: {
  ------------------
  |  Branch (451:16): [True: 4.84k, False: 16.9k]
  ------------------
  452|  4.84k|                  write_array(int16_t{});
  453|  4.84k|                  break;
  454|      0|               }
  455|  4.21k|               case 4: {
  ------------------
  |  Branch (455:16): [True: 4.21k, False: 17.5k]
  ------------------
  456|  4.21k|                  write_array(int32_t{});
  457|  4.21k|                  break;
  458|      0|               }
  459|  1.49k|               case 8: {
  ------------------
  |  Branch (459:16): [True: 1.49k, False: 20.2k]
  ------------------
  460|  1.49k|                  write_array(int64_t{});
  461|  1.49k|                  break;
  462|      0|               }
  463|     23|               default: {
  ------------------
  |  Branch (463:16): [True: 23, False: 21.7k]
  ------------------
  464|     23|                  ctx.error = error_code::syntax_error;
  465|     23|                  return;
  466|      0|               }
  467|  21.7k|               }
  468|  21.7k|               break;
  469|  21.7k|            }
  470|  56.0k|            case 2: {
  ------------------
  |  Branch (470:13): [True: 56.0k, False: 283k]
  ------------------
  471|       |               // unsigned integer
  472|  56.0k|               switch (byte_count) {
  473|  36.6k|               case 1: {
  ------------------
  |  Branch (473:16): [True: 36.6k, False: 19.4k]
  ------------------
  474|  36.6k|                  write_array(uint8_t{});
  475|  36.6k|                  break;
  476|      0|               }
  477|  2.16k|               case 2: {
  ------------------
  |  Branch (477:16): [True: 2.16k, False: 53.9k]
  ------------------
  478|  2.16k|                  write_array(uint16_t{});
  479|  2.16k|                  break;
  480|      0|               }
  481|  1.91k|               case 4: {
  ------------------
  |  Branch (481:16): [True: 1.91k, False: 54.1k]
  ------------------
  482|  1.91k|                  write_array(uint32_t{});
  483|  1.91k|                  break;
  484|      0|               }
  485|  15.3k|               case 8: {
  ------------------
  |  Branch (485:16): [True: 15.3k, False: 40.7k]
  ------------------
  486|  15.3k|                  write_array(uint64_t{});
  487|  15.3k|                  break;
  488|      0|               }
  489|     16|               default: {
  ------------------
  |  Branch (489:16): [True: 16, False: 56.0k]
  ------------------
  490|     16|                  ctx.error = error_code::syntax_error;
  491|     16|                  return;
  492|      0|               }
  493|  56.0k|               }
  494|  56.0k|               break;
  495|  56.0k|            }
  496|   256k|            case 3: {
  ------------------
  |  Branch (496:13): [True: 256k, False: 83.3k]
  ------------------
  497|       |               // string or boolean
  498|   256k|               const auto string_or_boolean = (tag & 0b001'00'000) >> 5;
  499|   256k|               switch (string_or_boolean) {
  500|   254k|               case 0: {
  ------------------
  |  Branch (500:16): [True: 254k, False: 1.85k]
  ------------------
  501|       |                  // boolean array (bit packed, LSB first)
  502|   254k|                  const auto n = int_from_compressed(ctx, it, end);
  503|   254k|                  if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (503:23): [True: 49, False: 254k]
  ------------------
  504|     49|                     return;
  505|     49|                  }
  506|   254k|                  const auto num_bytes = (n + 7) / 8;
  507|   254k|                  if (uint64_t(end - it) < num_bytes) [[unlikely]] {
  ------------------
  |  Branch (507:23): [True: 136, False: 254k]
  ------------------
  508|    136|                     ctx.error = error_code::unexpected_end;
  509|    136|                     return;
  510|    136|                  }
  511|   254k|                  if (num_bytes && !packed_bool_padding_is_zero(uint8_t(*(it + (num_bytes - 1))), n)) [[unlikely]] {
  ------------------
  |  Branch (511:23): [True: 237k, False: 17.0k]
  |  Branch (511:36): [True: 21, False: 236k]
  ------------------
  512|     21|                     ctx.error = error_code::syntax_error;
  513|     21|                     return;
  514|     21|                  }
  515|   487M|                  for (size_t i = 0; i < n; ++i) {
  ------------------
  |  Branch (515:38): [True: 487M, False: 253k]
  ------------------
  516|   487M|                     if (i != 0) {
  ------------------
  |  Branch (516:26): [True: 487M, False: 236k]
  ------------------
  517|   487M|                        if (!emit_char(ctx, ',', out, ix)) return;
  ------------------
  |  Branch (517:29): [True: 0, False: 487M]
  ------------------
  518|   487M|                     }
  519|   487M|                     const bool x = (uint8_t(it[i / 8]) >> (i % 8)) & uint8_t(1);
  520|   487M|                     if (x) {
  ------------------
  |  Branch (520:26): [True: 89.5M, False: 397M]
  ------------------
  521|  89.5M|                        if (!emit_literal<"true">(ctx, out, ix)) return;
  ------------------
  |  Branch (521:29): [True: 0, False: 89.5M]
  ------------------
  522|  89.5M|                     }
  523|   397M|                     else {
  524|   397M|                        if (!emit_literal<"false">(ctx, out, ix)) return;
  ------------------
  |  Branch (524:29): [True: 0, False: 397M]
  ------------------
  525|   397M|                     }
  526|   487M|                  }
  527|   253k|                  it += num_bytes;
  528|   253k|                  break;
  529|   253k|               }
  530|  1.85k|               case 1: {
  ------------------
  |  Branch (530:16): [True: 1.85k, False: 254k]
  ------------------
  531|       |                  // array of strings
  532|  1.85k|                  const auto n_strings = int_from_compressed(ctx, it, end);
  533|  1.85k|                  if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (533:23): [True: 54, False: 1.80k]
  ------------------
  534|     54|                     return;
  535|     54|                  }
  536|   258k|                  for (size_t i = 0; i < n_strings; ++i) {
  ------------------
  |  Branch (536:38): [True: 257k, False: 1.34k]
  ------------------
  537|   257k|                     const auto n = int_from_compressed(ctx, it, end);
  538|   257k|                     if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (538:26): [True: 274, False: 257k]
  ------------------
  539|    274|                        return;
  540|    274|                     }
  541|   257k|                     if (uint64_t(end - it) < n) [[unlikely]] {
  ------------------
  |  Branch (541:26): [True: 119, False: 257k]
  ------------------
  542|    119|                        ctx.error = error_code::unexpected_end;
  543|    119|                        return;
  544|    119|                     }
  545|   257k|                     const sv value{reinterpret_cast<const char*>(it), n};
  546|   257k|                     detail::emit_untrusted_string<Opts>(ctx, value, out, ix);
  547|   257k|                     if (bool(ctx.error)) [[unlikely]]
  ------------------
  |  Branch (547:26): [True: 58, False: 257k]
  ------------------
  548|     58|                        return;
  549|   257k|                     it += n;
  550|   257k|                     if (i != n_strings - 1) {
  ------------------
  |  Branch (550:26): [True: 256k, False: 246]
  ------------------
  551|   256k|                        if (!emit_char(ctx, ',', out, ix)) return;
  ------------------
  |  Branch (551:29): [True: 0, False: 256k]
  ------------------
  552|   256k|                     }
  553|   257k|                  }
  554|  1.34k|                  break;
  555|  1.80k|               }
  556|  1.34k|               default: {
  ------------------
  |  Branch (556:16): [True: 0, False: 256k]
  ------------------
  557|      0|                  ctx.error = error_code::syntax_error;
  558|      0|                  return;
  559|  1.80k|               }
  560|   256k|               }
  561|   255k|               break;
  562|   256k|            }
  563|   255k|            default: {
  ------------------
  |  Branch (563:13): [True: 0, False: 339k]
  ------------------
  564|      0|               ctx.error = error_code::syntax_error;
  565|      0|               return;
  566|   256k|            }
  567|   339k|            }
  568|       |
  569|   338k|            if (!emit_char(ctx, ']', out, ix)) return;
  ------------------
  |  Branch (569:17): [True: 0, False: 338k]
  ------------------
  570|       |
  571|   338k|            break;
  572|   338k|         }
  573|   338k|         case tag::generic_array: {
  ------------------
  |  Branch (573:10): [True: 17.2k, False: 22.8M]
  ------------------
  574|  17.2k|            ++it;
  575|  17.2k|            const auto n = int_from_compressed(ctx, it, end);
  576|  17.2k|            if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (576:17): [True: 45, False: 17.2k]
  ------------------
  577|     45|               return;
  578|     45|            }
  579|  17.2k|            if (!emit_char(ctx, '[', out, ix)) return;
  ------------------
  |  Branch (579:17): [True: 0, False: 17.2k]
  ------------------
  580|  1.03M|            for (size_t i = 0; i < n; ++i) {
  ------------------
  |  Branch (580:32): [True: 1.02M, False: 13.9k]
  ------------------
  581|  1.02M|               beve_to_json_value<Opts>(ctx, it, end, out, ix, recursive_depth + 1);
  582|  1.02M|               if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (582:20): [True: 3.34k, False: 1.01M]
  ------------------
  583|  3.34k|                  return;
  584|  3.34k|               }
  585|  1.01M|               if (i != n - 1) {
  ------------------
  |  Branch (585:20): [True: 1.01M, False: 797]
  ------------------
  586|  1.01M|                  if (!emit_char(ctx, ',', out, ix)) return;
  ------------------
  |  Branch (586:23): [True: 0, False: 1.01M]
  ------------------
  587|  1.01M|               }
  588|  1.01M|            }
  589|  13.9k|            if (!emit_char(ctx, ']', out, ix)) return;
  ------------------
  |  Branch (589:17): [True: 0, False: 13.9k]
  ------------------
  590|  13.9k|            break;
  591|  13.9k|         }
  592|  6.58M|         case tag::extensions: {
  ------------------
  |  Branch (592:10): [True: 6.58M, False: 16.3M]
  ------------------
  593|  6.58M|            const uint8_t extension = tag >> 3;
  594|  6.58M|            switch (extension) {
  595|   133k|            case 0: {
  ------------------
  |  Branch (595:13): [True: 133k, False: 6.44M]
  ------------------
  596|       |               // delimiter
  597|   133k|               ++it;
  598|   133k|               if (!emit_char(ctx, '\n', out, ix)) return;
  ------------------
  |  Branch (598:20): [True: 0, False: 133k]
  ------------------
  599|   133k|               break;
  600|   133k|            }
  601|   133k|            case 1: {
  ------------------
  |  Branch (601:13): [True: 2.00k, False: 6.57M]
  ------------------
  602|       |               // legacy (Version 1) type tag: transcode by dropping the positional index and
  603|       |               // emitting the value. Version 2 variants are ordinary objects/values transcoded by
  604|       |               // their normal cases and never reach here.
  605|  2.00k|               ++it;
  606|  2.00k|               skip_compressed_int(ctx, it, end);
  607|  2.00k|               if (bool(ctx.error)) return;
  ------------------
  |  Branch (607:20): [True: 3, False: 1.99k]
  ------------------
  608|       |
  609|  1.99k|               beve_to_json_value<Opts>(ctx, it, end, out, ix, recursive_depth + 1);
  610|  1.99k|               if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (610:20): [True: 1.29k, False: 702]
  ------------------
  611|  1.29k|                  return;
  612|  1.29k|               }
  613|    702|               break;
  614|  1.99k|            }
  615|  6.44M|            case 2: {
  ------------------
  |  Branch (615:13): [True: 6.44M, False: 138k]
  ------------------
  616|       |               // matrices
  617|  6.44M|               ++it;
  618|  6.44M|               if (it >= end) [[unlikely]] {
  ------------------
  |  Branch (618:20): [True: 29, False: 6.44M]
  ------------------
  619|     29|                  ctx.error = error_code::syntax_error;
  620|     29|                  return;
  621|     29|               }
  622|  6.44M|               const auto matrix_header = uint8_t(*it);
  623|  6.44M|               ++it;
  624|       |
  625|  6.44M|               if (!emit_char(ctx, '{', out, ix)) return;
  ------------------
  |  Branch (625:20): [True: 0, False: 6.44M]
  ------------------
  626|  6.44M|               {
  627|       |                  // The indentation this matrix adds belongs to it, so every way out -- including an
  628|       |                  // error return from a nested value -- puts the depth back.
  629|  6.44M|                  const indent_guard indent{ctx, Opts.prettify ? check_indentation_width(Opts) : 1};
  ------------------
  |  Branch (629:50): [Folded, False: 6.44M]
  ------------------
  630|       |
  631|       |                  if constexpr (Opts.prettify) {
  632|       |                     if (!emit_newline_indent<Opts>(ctx, out, ix)) return;
  633|       |                  }
  634|       |
  635|       |                  if constexpr (Opts.prettify) {
  636|       |                     if (!emit_literal<R"("layout": )">(ctx, out, ix)) return;
  637|       |                  }
  638|  6.44M|                  else {
  639|  6.44M|                     if (!emit_literal<R"("layout":)">(ctx, out, ix)) return;
  ------------------
  |  Branch (639:26): [True: 0, False: 6.44M]
  ------------------
  640|  6.44M|                  }
  641|       |
  642|  6.44M|                  const auto layout = matrix_header & 0b0000000'1;
  643|  6.44M|                  if (layout) {
  ------------------
  |  Branch (643:23): [True: 144k, False: 6.29M]
  ------------------
  644|   144k|                     if (!emit_literal<R"("layout_right")">(ctx, out, ix)) return;
  ------------------
  |  Branch (644:26): [True: 0, False: 144k]
  ------------------
  645|   144k|                  }
  646|  6.29M|                  else {
  647|  6.29M|                     if (!emit_literal<R"("layout_left")">(ctx, out, ix)) return;
  ------------------
  |  Branch (647:26): [True: 0, False: 6.29M]
  ------------------
  648|  6.29M|                  }
  649|       |
  650|  6.44M|                  if (!emit_char(ctx, ',', out, ix)) return;
  ------------------
  |  Branch (650:23): [True: 0, False: 6.44M]
  ------------------
  651|       |                  if constexpr (Opts.prettify) {
  652|       |                     if (!emit_newline_indent<Opts>(ctx, out, ix)) return;
  653|       |                  }
  654|       |
  655|       |                  if constexpr (Opts.prettify) {
  656|       |                     if (!emit_literal<R"("extents": )">(ctx, out, ix)) return;
  657|       |                  }
  658|  6.44M|                  else {
  659|  6.44M|                     if (!emit_literal<R"("extents":)">(ctx, out, ix)) return;
  ------------------
  |  Branch (659:26): [True: 0, False: 6.44M]
  ------------------
  660|  6.44M|                  }
  661|       |
  662|  6.44M|                  beve_to_json_value<Opts>(ctx, it, end, out, ix, recursive_depth + 1);
  663|  6.44M|                  if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (663:23): [True: 30.1k, False: 6.41M]
  ------------------
  664|  30.1k|                     return;
  665|  30.1k|                  }
  666|       |
  667|  6.41M|                  if (!emit_char(ctx, ',', out, ix)) return;
  ------------------
  |  Branch (667:23): [True: 0, False: 6.41M]
  ------------------
  668|       |                  if constexpr (Opts.prettify) {
  669|       |                     if (!emit_newline_indent<Opts>(ctx, out, ix)) return;
  670|       |                  }
  671|       |
  672|       |                  if constexpr (Opts.prettify) {
  673|       |                     if (!emit_literal<R"("value": )">(ctx, out, ix)) return;
  674|       |                  }
  675|  6.41M|                  else {
  676|  6.41M|                     if (!emit_literal<R"("value":)">(ctx, out, ix)) return;
  ------------------
  |  Branch (676:26): [True: 0, False: 6.41M]
  ------------------
  677|  6.41M|                  }
  678|       |
  679|  6.41M|                  beve_to_json_value<Opts>(ctx, it, end, out, ix, recursive_depth + 1);
  680|  6.41M|                  if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (680:23): [True: 2.20k, False: 6.40M]
  ------------------
  681|  2.20k|                     return;
  682|  2.20k|                  }
  683|  6.41M|               }
  684|       |
  685|       |               if constexpr (Opts.prettify) {
  686|       |                  if (!emit_newline_indent<Opts>(ctx, out, ix)) return;
  687|       |               }
  688|  6.40M|               if (!emit_char(ctx, '}', out, ix)) return;
  ------------------
  |  Branch (688:20): [True: 0, False: 6.40M]
  ------------------
  689|  6.40M|               break;
  690|  6.40M|            }
  691|  6.40M|            case 3: {
  ------------------
  |  Branch (691:13): [True: 3.35k, False: 6.57M]
  ------------------
  692|       |               // complex numbers
  693|  3.35k|               ++it;
  694|  3.35k|               if (it >= end) [[unlikely]] {
  ------------------
  |  Branch (694:20): [True: 1, False: 3.35k]
  ------------------
  695|      1|                  ctx.error = error_code::syntax_error;
  696|      1|                  return;
  697|      1|               }
  698|  3.35k|               const auto complex_header = uint8_t(*it);
  699|  3.35k|               ++it;
  700|       |
  701|       |               // The COMPLEX HEADER carries the component's numerical type (bits 3-4) and BYTE COUNT
  702|       |               // (bits 5-7) in the same positions as a number tag.
  703|  3.35k|               const uint8_t number_tag = tag::number | (complex_header & 0b111'11'000);
  704|       |
  705|       |               // Writes one complex value as [re,im]
  706|  3.35k|               auto write_complex = [&]() -> bool {
  707|  3.35k|                  if (!emit_char(ctx, '[', out, ix)) return false;
  708|  3.35k|                  beve_to_json_number<Opts>(number_tag, ctx, it, end, out, ix);
  709|  3.35k|                  if (bool(ctx.error)) [[unlikely]] {
  710|  3.35k|                     return false;
  711|  3.35k|                  }
  712|  3.35k|                  if (!emit_char(ctx, ',', out, ix)) return false;
  713|  3.35k|                  beve_to_json_number<Opts>(number_tag, ctx, it, end, out, ix);
  714|  3.35k|                  if (bool(ctx.error)) [[unlikely]] {
  715|  3.35k|                     return false;
  716|  3.35k|                  }
  717|  3.35k|                  return emit_char(ctx, ']', out, ix);
  718|  3.35k|               };
  719|       |
  720|       |               // Writes n complex values as [[re,im],...]
  721|  3.35k|               auto write_complex_array = [&](const size_t n) -> bool {
  722|  3.35k|                  if (!emit_char(ctx, '[', out, ix)) return false;
  723|  3.35k|                  for (size_t i = 0; i < n; ++i) {
  724|  3.35k|                     if (!write_complex()) return false;
  725|  3.35k|                     if (i != n - 1) {
  726|  3.35k|                        if (!emit_char(ctx, ',', out, ix)) return false;
  727|  3.35k|                     }
  728|  3.35k|                  }
  729|  3.35k|                  return emit_char(ctx, ']', out, ix);
  730|  3.35k|               };
  731|       |
  732|  3.35k|               switch (complex_header & glz::extension::complex_subtype_mask) {
  733|    232|               case glz::extension::complex_number: {
  ------------------
  |  Branch (733:16): [True: 232, False: 3.12k]
  ------------------
  734|    232|                  if (!write_complex()) return;
  ------------------
  |  Branch (734:23): [True: 24, False: 208]
  ------------------
  735|    208|                  break;
  736|    232|               }
  737|  1.90k|               case glz::extension::complex_array: {
  ------------------
  |  Branch (737:16): [True: 1.90k, False: 1.45k]
  ------------------
  738|  1.90k|                  const auto n = int_from_compressed(ctx, it, end);
  739|  1.90k|                  if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (739:23): [True: 33, False: 1.86k]
  ------------------
  740|     33|                     return;
  741|     33|                  }
  742|  1.86k|                  if (!write_complex_array(n)) return;
  ------------------
  |  Branch (742:23): [True: 446, False: 1.42k]
  ------------------
  743|  1.42k|                  break;
  744|  1.86k|               }
  745|  1.42k|               case glz::extension::complex_aligned_array: {
  ------------------
  |  Branch (745:16): [True: 1.20k, False: 2.15k]
  ------------------
  746|       |                  // Alignment is a storage property: the JSON matches an unaligned complex array
  747|  1.20k|                  const auto n = read_aligned_complex_header(ctx, it, end, complex_header);
  748|  1.20k|                  if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (748:23): [True: 190, False: 1.01k]
  ------------------
  749|    190|                     return;
  750|    190|                  }
  751|  1.01k|                  if (!write_complex_array(n)) return;
  ------------------
  |  Branch (751:23): [True: 1, False: 1.01k]
  ------------------
  752|  1.01k|                  break;
  753|  1.01k|               }
  754|  1.01k|               default: {
  ------------------
  |  Branch (754:16): [True: 20, False: 3.33k]
  ------------------
  755|       |                  // Undefined complex sub-type
  756|     20|                  ctx.error = error_code::syntax_error;
  757|     20|                  return;
  758|  1.01k|               }
  759|  3.35k|               }
  760|       |
  761|  2.64k|               break;
  762|  3.35k|            }
  763|  2.64k|            default: {
  ------------------
  |  Branch (763:13): [True: 94, False: 6.58M]
  ------------------
  764|     94|               ctx.error = error_code::syntax_error;
  765|     94|               return;
  766|  3.35k|            }
  767|  6.58M|            }
  768|  6.54M|            break;
  769|  6.58M|         }
  770|  6.54M|         default: {
  ------------------
  |  Branch (770:10): [True: 201, False: 22.9M]
  ------------------
  771|    201|            ctx.error = error_code::syntax_error;
  772|    201|            return;
  773|  6.58M|         }
  774|  22.9M|         }
  775|  22.9M|      }
_ZN3glz6detail19beve_to_json_numberITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERKhRNS_7contextERPKcS9_NSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEmEEvOT0_OT1_OT2_OT3_RT4_RT5_:
   15|  2.38M|      {
   16|  2.38M|         const auto number_type = (tag & 0b000'11'000) >> 3;
   17|  2.38M|         const uint8_t byte_count = byte_count_lookup[tag >> 5];
   18|       |
   19|  2.38M|         auto write_number = [&]<class T>(T&& value) {
   20|  2.38M|            if (size_t(end - it) < sizeof(T)) [[unlikely]] {
   21|  2.38M|               ctx.error = error_code::syntax_error;
   22|  2.38M|               return;
   23|  2.38M|            }
   24|  2.38M|            using V = std::remove_cvref_t<T>;
   25|  2.38M|            std::memcpy(&value, it, sizeof(V));
   26|  2.38M|            if constexpr (std::endian::native == std::endian::big) {
   27|  2.38M|               byteswap_le(value);
   28|  2.38M|            }
   29|  2.38M|            to<JSON, T>::template op<Opts>(value, ctx, out, ix);
   30|  2.38M|            it += sizeof(T);
   31|  2.38M|         };
   32|       |
   33|  2.38M|         switch (number_type) {
   34|   635k|         case 0: {
  ------------------
  |  Branch (34:10): [True: 635k, False: 1.74M]
  ------------------
   35|       |            // floating point
   36|   635k|            switch (byte_count) {
   37|   200k|            case 4: {
  ------------------
  |  Branch (37:13): [True: 200k, False: 434k]
  ------------------
   38|   200k|               write_number(float{});
   39|   200k|               break;
   40|      0|            }
   41|   434k|            case 8: {
  ------------------
  |  Branch (41:13): [True: 434k, False: 200k]
  ------------------
   42|   434k|               write_number(double{});
   43|   434k|               break;
   44|      0|            }
   45|     80|            default: {
  ------------------
  |  Branch (45:13): [True: 80, False: 635k]
  ------------------
   46|     80|               ctx.error = error_code::syntax_error;
   47|     80|               return;
   48|      0|            }
   49|   635k|            }
   50|   635k|            break;
   51|   635k|         }
   52|   986k|         case 1: {
  ------------------
  |  Branch (52:10): [True: 986k, False: 1.39M]
  ------------------
   53|       |            // signed integer
   54|   986k|            switch (byte_count) {
   55|   176k|            case 1: {
  ------------------
  |  Branch (55:13): [True: 176k, False: 810k]
  ------------------
   56|   176k|               write_number(int8_t{});
   57|   176k|               break;
   58|      0|            }
   59|   603k|            case 2: {
  ------------------
  |  Branch (59:13): [True: 603k, False: 382k]
  ------------------
   60|   603k|               write_number(int16_t{});
   61|   603k|               break;
   62|      0|            }
   63|   112k|            case 4: {
  ------------------
  |  Branch (63:13): [True: 112k, False: 873k]
  ------------------
   64|   112k|               write_number(int32_t{});
   65|   112k|               break;
   66|      0|            }
   67|  93.4k|            case 8: {
  ------------------
  |  Branch (67:13): [True: 93.4k, False: 893k]
  ------------------
   68|  93.4k|               write_number(int64_t{});
   69|  93.4k|               break;
   70|      0|            }
   71|     54|            default: {
  ------------------
  |  Branch (71:13): [True: 54, False: 986k]
  ------------------
   72|     54|               ctx.error = error_code::syntax_error;
   73|     54|               return;
   74|      0|            }
   75|   986k|            }
   76|   986k|            break;
   77|   986k|         }
   78|   986k|         case 2: {
  ------------------
  |  Branch (78:10): [True: 761k, False: 1.62M]
  ------------------
   79|       |            // unsigned integer
   80|   761k|            switch (byte_count) {
   81|   125k|            case 1: {
  ------------------
  |  Branch (81:13): [True: 125k, False: 635k]
  ------------------
   82|   125k|               write_number(uint8_t{});
   83|   125k|               break;
   84|      0|            }
   85|   461k|            case 2: {
  ------------------
  |  Branch (85:13): [True: 461k, False: 300k]
  ------------------
   86|   461k|               write_number(uint16_t{});
   87|   461k|               break;
   88|      0|            }
   89|  84.7k|            case 4: {
  ------------------
  |  Branch (89:13): [True: 84.7k, False: 676k]
  ------------------
   90|  84.7k|               write_number(uint32_t{});
   91|  84.7k|               break;
   92|      0|            }
   93|  89.6k|            case 8: {
  ------------------
  |  Branch (93:13): [True: 89.6k, False: 671k]
  ------------------
   94|  89.6k|               write_number(uint64_t{});
   95|  89.6k|               break;
   96|      0|            }
   97|     42|            default: {
  ------------------
  |  Branch (97:13): [True: 42, False: 761k]
  ------------------
   98|     42|               ctx.error = error_code::syntax_error;
   99|     42|               return;
  100|      0|            }
  101|   761k|            }
  102|   761k|            break;
  103|   761k|         }
  104|   761k|         default: {
  ------------------
  |  Branch (104:10): [True: 24, False: 2.38M]
  ------------------
  105|     24|            ctx.error = error_code::syntax_error;
  106|     24|            return;
  107|   761k|         }
  108|  2.38M|         }
  109|  2.38M|      }
_ZZN3glz6detail19beve_to_json_numberITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERKhRNS_7contextERPKcS9_NSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEmEEvOT0_OT1_OT2_OT3_RT4_RT5_ENKUlTyOT_E_clIfEEDaSU_:
   19|   200k|         auto write_number = [&]<class T>(T&& value) {
   20|   200k|            if (size_t(end - it) < sizeof(T)) [[unlikely]] {
  ------------------
  |  Branch (20:17): [True: 75, False: 200k]
  ------------------
   21|     75|               ctx.error = error_code::syntax_error;
   22|     75|               return;
   23|     75|            }
   24|   200k|            using V = std::remove_cvref_t<T>;
   25|   200k|            std::memcpy(&value, it, sizeof(V));
   26|       |            if constexpr (std::endian::native == std::endian::big) {
   27|       |               byteswap_le(value);
   28|       |            }
   29|   200k|            to<JSON, T>::template op<Opts>(value, ctx, out, ix);
   30|   200k|            it += sizeof(T);
   31|   200k|         };
_ZZN3glz6detail19beve_to_json_numberITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERKhRNS_7contextERPKcS9_NSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEmEEvOT0_OT1_OT2_OT3_RT4_RT5_ENKUlTyOT_E_clIdEEDaSU_:
   19|   434k|         auto write_number = [&]<class T>(T&& value) {
   20|   434k|            if (size_t(end - it) < sizeof(T)) [[unlikely]] {
  ------------------
  |  Branch (20:17): [True: 42, False: 434k]
  ------------------
   21|     42|               ctx.error = error_code::syntax_error;
   22|     42|               return;
   23|     42|            }
   24|   434k|            using V = std::remove_cvref_t<T>;
   25|   434k|            std::memcpy(&value, it, sizeof(V));
   26|       |            if constexpr (std::endian::native == std::endian::big) {
   27|       |               byteswap_le(value);
   28|       |            }
   29|   434k|            to<JSON, T>::template op<Opts>(value, ctx, out, ix);
   30|   434k|            it += sizeof(T);
   31|   434k|         };
_ZZN3glz6detail19beve_to_json_numberITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERKhRNS_7contextERPKcS9_NSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEmEEvOT0_OT1_OT2_OT3_RT4_RT5_ENKUlTyOT_E_clIaEEDaSU_:
   19|   176k|         auto write_number = [&]<class T>(T&& value) {
   20|   176k|            if (size_t(end - it) < sizeof(T)) [[unlikely]] {
  ------------------
  |  Branch (20:17): [True: 161, False: 176k]
  ------------------
   21|    161|               ctx.error = error_code::syntax_error;
   22|    161|               return;
   23|    161|            }
   24|   176k|            using V = std::remove_cvref_t<T>;
   25|   176k|            std::memcpy(&value, it, sizeof(V));
   26|       |            if constexpr (std::endian::native == std::endian::big) {
   27|       |               byteswap_le(value);
   28|       |            }
   29|   176k|            to<JSON, T>::template op<Opts>(value, ctx, out, ix);
   30|   176k|            it += sizeof(T);
   31|   176k|         };
_ZZN3glz6detail19beve_to_json_numberITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERKhRNS_7contextERPKcS9_NSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEmEEvOT0_OT1_OT2_OT3_RT4_RT5_ENKUlTyOT_E_clIsEEDaSU_:
   19|   603k|         auto write_number = [&]<class T>(T&& value) {
   20|   603k|            if (size_t(end - it) < sizeof(T)) [[unlikely]] {
  ------------------
  |  Branch (20:17): [True: 76, False: 603k]
  ------------------
   21|     76|               ctx.error = error_code::syntax_error;
   22|     76|               return;
   23|     76|            }
   24|   603k|            using V = std::remove_cvref_t<T>;
   25|   603k|            std::memcpy(&value, it, sizeof(V));
   26|       |            if constexpr (std::endian::native == std::endian::big) {
   27|       |               byteswap_le(value);
   28|       |            }
   29|   603k|            to<JSON, T>::template op<Opts>(value, ctx, out, ix);
   30|   603k|            it += sizeof(T);
   31|   603k|         };
_ZZN3glz6detail19beve_to_json_numberITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERKhRNS_7contextERPKcS9_NSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEmEEvOT0_OT1_OT2_OT3_RT4_RT5_ENKUlTyOT_E_clIiEEDaSU_:
   19|   112k|         auto write_number = [&]<class T>(T&& value) {
   20|   112k|            if (size_t(end - it) < sizeof(T)) [[unlikely]] {
  ------------------
  |  Branch (20:17): [True: 36, False: 112k]
  ------------------
   21|     36|               ctx.error = error_code::syntax_error;
   22|     36|               return;
   23|     36|            }
   24|   112k|            using V = std::remove_cvref_t<T>;
   25|   112k|            std::memcpy(&value, it, sizeof(V));
   26|       |            if constexpr (std::endian::native == std::endian::big) {
   27|       |               byteswap_le(value);
   28|       |            }
   29|   112k|            to<JSON, T>::template op<Opts>(value, ctx, out, ix);
   30|   112k|            it += sizeof(T);
   31|   112k|         };
_ZZN3glz6detail19beve_to_json_numberITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERKhRNS_7contextERPKcS9_NSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEmEEvOT0_OT1_OT2_OT3_RT4_RT5_ENKUlTyOT_E_clIlEEDaSU_:
   19|  93.4k|         auto write_number = [&]<class T>(T&& value) {
   20|  93.4k|            if (size_t(end - it) < sizeof(T)) [[unlikely]] {
  ------------------
  |  Branch (20:17): [True: 48, False: 93.3k]
  ------------------
   21|     48|               ctx.error = error_code::syntax_error;
   22|     48|               return;
   23|     48|            }
   24|  93.3k|            using V = std::remove_cvref_t<T>;
   25|  93.3k|            std::memcpy(&value, it, sizeof(V));
   26|       |            if constexpr (std::endian::native == std::endian::big) {
   27|       |               byteswap_le(value);
   28|       |            }
   29|  93.3k|            to<JSON, T>::template op<Opts>(value, ctx, out, ix);
   30|  93.3k|            it += sizeof(T);
   31|  93.3k|         };
_ZZN3glz6detail19beve_to_json_numberITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERKhRNS_7contextERPKcS9_NSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEmEEvOT0_OT1_OT2_OT3_RT4_RT5_ENKUlTyOT_E_clIhEEDaSU_:
   19|   125k|         auto write_number = [&]<class T>(T&& value) {
   20|   125k|            if (size_t(end - it) < sizeof(T)) [[unlikely]] {
  ------------------
  |  Branch (20:17): [True: 150, False: 125k]
  ------------------
   21|    150|               ctx.error = error_code::syntax_error;
   22|    150|               return;
   23|    150|            }
   24|   125k|            using V = std::remove_cvref_t<T>;
   25|   125k|            std::memcpy(&value, it, sizeof(V));
   26|       |            if constexpr (std::endian::native == std::endian::big) {
   27|       |               byteswap_le(value);
   28|       |            }
   29|   125k|            to<JSON, T>::template op<Opts>(value, ctx, out, ix);
   30|   125k|            it += sizeof(T);
   31|   125k|         };
_ZZN3glz6detail19beve_to_json_numberITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERKhRNS_7contextERPKcS9_NSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEmEEvOT0_OT1_OT2_OT3_RT4_RT5_ENKUlTyOT_E_clItEEDaSU_:
   19|   461k|         auto write_number = [&]<class T>(T&& value) {
   20|   461k|            if (size_t(end - it) < sizeof(T)) [[unlikely]] {
  ------------------
  |  Branch (20:17): [True: 84, False: 461k]
  ------------------
   21|     84|               ctx.error = error_code::syntax_error;
   22|     84|               return;
   23|     84|            }
   24|   461k|            using V = std::remove_cvref_t<T>;
   25|   461k|            std::memcpy(&value, it, sizeof(V));
   26|       |            if constexpr (std::endian::native == std::endian::big) {
   27|       |               byteswap_le(value);
   28|       |            }
   29|   461k|            to<JSON, T>::template op<Opts>(value, ctx, out, ix);
   30|   461k|            it += sizeof(T);
   31|   461k|         };
_ZZN3glz6detail19beve_to_json_numberITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERKhRNS_7contextERPKcS9_NSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEmEEvOT0_OT1_OT2_OT3_RT4_RT5_ENKUlTyOT_E_clIjEEDaSU_:
   19|  84.7k|         auto write_number = [&]<class T>(T&& value) {
   20|  84.7k|            if (size_t(end - it) < sizeof(T)) [[unlikely]] {
  ------------------
  |  Branch (20:17): [True: 40, False: 84.6k]
  ------------------
   21|     40|               ctx.error = error_code::syntax_error;
   22|     40|               return;
   23|     40|            }
   24|  84.6k|            using V = std::remove_cvref_t<T>;
   25|  84.6k|            std::memcpy(&value, it, sizeof(V));
   26|       |            if constexpr (std::endian::native == std::endian::big) {
   27|       |               byteswap_le(value);
   28|       |            }
   29|  84.6k|            to<JSON, T>::template op<Opts>(value, ctx, out, ix);
   30|  84.6k|            it += sizeof(T);
   31|  84.6k|         };
_ZZN3glz6detail19beve_to_json_numberITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERKhRNS_7contextERPKcS9_NSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEmEEvOT0_OT1_OT2_OT3_RT4_RT5_ENKUlTyOT_E_clImEEDaSU_:
   19|  89.6k|         auto write_number = [&]<class T>(T&& value) {
   20|  89.6k|            if (size_t(end - it) < sizeof(T)) [[unlikely]] {
  ------------------
  |  Branch (20:17): [True: 38, False: 89.6k]
  ------------------
   21|     38|               ctx.error = error_code::syntax_error;
   22|     38|               return;
   23|     38|            }
   24|  89.6k|            using V = std::remove_cvref_t<T>;
   25|  89.6k|            std::memcpy(&value, it, sizeof(V));
   26|       |            if constexpr (std::endian::native == std::endian::big) {
   27|       |               byteswap_le(value);
   28|       |            }
   29|  89.6k|            to<JSON, T>::template op<Opts>(value, ctx, out, ix);
   30|  89.6k|            it += sizeof(T);
   31|  89.6k|         };
_ZZN3glz6detail18beve_to_json_valueITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEERNS_7contextERPKcSE_RmEEvOT1_OT2_OT3_RT0_OT4_jENKUlTyOT_E_clIfEEDaSR_:
  313|    749|               auto write_aligned_array = [&]<class T>(T&& value) {
  314|   339k|                  for (size_t i = 0; i < n; ++i) {
  ------------------
  |  Branch (314:38): [True: 338k, False: 749]
  ------------------
  315|   338k|                     if (size_t(end - it) < sizeof(T)) [[unlikely]] {
  ------------------
  |  Branch (315:26): [True: 0, False: 338k]
  ------------------
  316|      0|                        ctx.error = error_code::unexpected_end;
  317|      0|                        return;
  318|      0|                     }
  319|   338k|                     using V = std::remove_cvref_t<T>;
  320|   338k|                     std::memcpy(&value, it, sizeof(V));
  321|       |                     if constexpr (std::endian::native == std::endian::big) {
  322|       |                        byteswap_le(value);
  323|       |                     }
  324|   338k|                     to<JSON, T>::template op<Opts>(value, ctx, out, ix);
  325|   338k|                     it += sizeof(T);
  326|   338k|                     if (i != n - 1) {
  ------------------
  |  Branch (326:26): [True: 338k, False: 282]
  ------------------
  327|   338k|                        if (!emit_char(ctx, ',', out, ix)) return;
  ------------------
  |  Branch (327:29): [True: 0, False: 338k]
  ------------------
  328|   338k|                     }
  329|   338k|                  }
  330|    749|               };
_ZZN3glz6detail18beve_to_json_valueITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEERNS_7contextERPKcSE_RmEEvOT1_OT2_OT3_RT0_OT4_jENKUlTyOT_E_clIdEEDaSR_:
  313|  1.42k|               auto write_aligned_array = [&]<class T>(T&& value) {
  314|  36.3k|                  for (size_t i = 0; i < n; ++i) {
  ------------------
  |  Branch (314:38): [True: 34.9k, False: 1.42k]
  ------------------
  315|  34.9k|                     if (size_t(end - it) < sizeof(T)) [[unlikely]] {
  ------------------
  |  Branch (315:26): [True: 0, False: 34.9k]
  ------------------
  316|      0|                        ctx.error = error_code::unexpected_end;
  317|      0|                        return;
  318|      0|                     }
  319|  34.9k|                     using V = std::remove_cvref_t<T>;
  320|  34.9k|                     std::memcpy(&value, it, sizeof(V));
  321|       |                     if constexpr (std::endian::native == std::endian::big) {
  322|       |                        byteswap_le(value);
  323|       |                     }
  324|  34.9k|                     to<JSON, T>::template op<Opts>(value, ctx, out, ix);
  325|  34.9k|                     it += sizeof(T);
  326|  34.9k|                     if (i != n - 1) {
  ------------------
  |  Branch (326:26): [True: 33.9k, False: 1.04k]
  ------------------
  327|  33.9k|                        if (!emit_char(ctx, ',', out, ix)) return;
  ------------------
  |  Branch (327:29): [True: 0, False: 33.9k]
  ------------------
  328|  33.9k|                     }
  329|  34.9k|                  }
  330|  1.42k|               };
_ZZN3glz6detail18beve_to_json_valueITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEERNS_7contextERPKcSE_RmEEvOT1_OT2_OT3_RT0_OT4_jENKUlTyOT_E_clIaEEDaSR_:
  313|  2.17k|               auto write_aligned_array = [&]<class T>(T&& value) {
  314|   303k|                  for (size_t i = 0; i < n; ++i) {
  ------------------
  |  Branch (314:38): [True: 301k, False: 2.17k]
  ------------------
  315|   301k|                     if (size_t(end - it) < sizeof(T)) [[unlikely]] {
  ------------------
  |  Branch (315:26): [True: 0, False: 301k]
  ------------------
  316|      0|                        ctx.error = error_code::unexpected_end;
  317|      0|                        return;
  318|      0|                     }
  319|   301k|                     using V = std::remove_cvref_t<T>;
  320|   301k|                     std::memcpy(&value, it, sizeof(V));
  321|       |                     if constexpr (std::endian::native == std::endian::big) {
  322|       |                        byteswap_le(value);
  323|       |                     }
  324|   301k|                     to<JSON, T>::template op<Opts>(value, ctx, out, ix);
  325|   301k|                     it += sizeof(T);
  326|   301k|                     if (i != n - 1) {
  ------------------
  |  Branch (326:26): [True: 299k, False: 1.78k]
  ------------------
  327|   299k|                        if (!emit_char(ctx, ',', out, ix)) return;
  ------------------
  |  Branch (327:29): [True: 0, False: 299k]
  ------------------
  328|   299k|                     }
  329|   301k|                  }
  330|  2.17k|               };
_ZZN3glz6detail18beve_to_json_valueITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEERNS_7contextERPKcSE_RmEEvOT1_OT2_OT3_RT0_OT4_jENKUlTyOT_E_clIsEEDaSR_:
  313|    896|               auto write_aligned_array = [&]<class T>(T&& value) {
  314|  1.00M|                  for (size_t i = 0; i < n; ++i) {
  ------------------
  |  Branch (314:38): [True: 1.00M, False: 896]
  ------------------
  315|  1.00M|                     if (size_t(end - it) < sizeof(T)) [[unlikely]] {
  ------------------
  |  Branch (315:26): [True: 0, False: 1.00M]
  ------------------
  316|      0|                        ctx.error = error_code::unexpected_end;
  317|      0|                        return;
  318|      0|                     }
  319|  1.00M|                     using V = std::remove_cvref_t<T>;
  320|  1.00M|                     std::memcpy(&value, it, sizeof(V));
  321|       |                     if constexpr (std::endian::native == std::endian::big) {
  322|       |                        byteswap_le(value);
  323|       |                     }
  324|  1.00M|                     to<JSON, T>::template op<Opts>(value, ctx, out, ix);
  325|  1.00M|                     it += sizeof(T);
  326|  1.00M|                     if (i != n - 1) {
  ------------------
  |  Branch (326:26): [True: 1.00M, False: 599]
  ------------------
  327|  1.00M|                        if (!emit_char(ctx, ',', out, ix)) return;
  ------------------
  |  Branch (327:29): [True: 0, False: 1.00M]
  ------------------
  328|  1.00M|                     }
  329|  1.00M|                  }
  330|    896|               };
_ZZN3glz6detail18beve_to_json_valueITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEERNS_7contextERPKcSE_RmEEvOT1_OT2_OT3_RT0_OT4_jENKUlTyOT_E_clIiEEDaSR_:
  313|  2.19k|               auto write_aligned_array = [&]<class T>(T&& value) {
  314|   192k|                  for (size_t i = 0; i < n; ++i) {
  ------------------
  |  Branch (314:38): [True: 190k, False: 2.19k]
  ------------------
  315|   190k|                     if (size_t(end - it) < sizeof(T)) [[unlikely]] {
  ------------------
  |  Branch (315:26): [True: 0, False: 190k]
  ------------------
  316|      0|                        ctx.error = error_code::unexpected_end;
  317|      0|                        return;
  318|      0|                     }
  319|   190k|                     using V = std::remove_cvref_t<T>;
  320|   190k|                     std::memcpy(&value, it, sizeof(V));
  321|       |                     if constexpr (std::endian::native == std::endian::big) {
  322|       |                        byteswap_le(value);
  323|       |                     }
  324|   190k|                     to<JSON, T>::template op<Opts>(value, ctx, out, ix);
  325|   190k|                     it += sizeof(T);
  326|   190k|                     if (i != n - 1) {
  ------------------
  |  Branch (326:26): [True: 188k, False: 1.80k]
  ------------------
  327|   188k|                        if (!emit_char(ctx, ',', out, ix)) return;
  ------------------
  |  Branch (327:29): [True: 0, False: 188k]
  ------------------
  328|   188k|                     }
  329|   190k|                  }
  330|  2.19k|               };
_ZZN3glz6detail18beve_to_json_valueITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEERNS_7contextERPKcSE_RmEEvOT1_OT2_OT3_RT0_OT4_jENKUlTyOT_E_clIlEEDaSR_:
  313|    976|               auto write_aligned_array = [&]<class T>(T&& value) {
  314|   195k|                  for (size_t i = 0; i < n; ++i) {
  ------------------
  |  Branch (314:38): [True: 194k, False: 976]
  ------------------
  315|   194k|                     if (size_t(end - it) < sizeof(T)) [[unlikely]] {
  ------------------
  |  Branch (315:26): [True: 0, False: 194k]
  ------------------
  316|      0|                        ctx.error = error_code::unexpected_end;
  317|      0|                        return;
  318|      0|                     }
  319|   194k|                     using V = std::remove_cvref_t<T>;
  320|   194k|                     std::memcpy(&value, it, sizeof(V));
  321|       |                     if constexpr (std::endian::native == std::endian::big) {
  322|       |                        byteswap_le(value);
  323|       |                     }
  324|   194k|                     to<JSON, T>::template op<Opts>(value, ctx, out, ix);
  325|   194k|                     it += sizeof(T);
  326|   194k|                     if (i != n - 1) {
  ------------------
  |  Branch (326:26): [True: 194k, False: 707]
  ------------------
  327|   194k|                        if (!emit_char(ctx, ',', out, ix)) return;
  ------------------
  |  Branch (327:29): [True: 0, False: 194k]
  ------------------
  328|   194k|                     }
  329|   194k|                  }
  330|    976|               };
_ZZN3glz6detail18beve_to_json_valueITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEERNS_7contextERPKcSE_RmEEvOT1_OT2_OT3_RT0_OT4_jENKUlTyOT_E_clIhEEDaSR_:
  313|    707|               auto write_aligned_array = [&]<class T>(T&& value) {
  314|  1.86M|                  for (size_t i = 0; i < n; ++i) {
  ------------------
  |  Branch (314:38): [True: 1.86M, False: 707]
  ------------------
  315|  1.86M|                     if (size_t(end - it) < sizeof(T)) [[unlikely]] {
  ------------------
  |  Branch (315:26): [True: 0, False: 1.86M]
  ------------------
  316|      0|                        ctx.error = error_code::unexpected_end;
  317|      0|                        return;
  318|      0|                     }
  319|  1.86M|                     using V = std::remove_cvref_t<T>;
  320|  1.86M|                     std::memcpy(&value, it, sizeof(V));
  321|       |                     if constexpr (std::endian::native == std::endian::big) {
  322|       |                        byteswap_le(value);
  323|       |                     }
  324|  1.86M|                     to<JSON, T>::template op<Opts>(value, ctx, out, ix);
  325|  1.86M|                     it += sizeof(T);
  326|  1.86M|                     if (i != n - 1) {
  ------------------
  |  Branch (326:26): [True: 1.86M, False: 359]
  ------------------
  327|  1.86M|                        if (!emit_char(ctx, ',', out, ix)) return;
  ------------------
  |  Branch (327:29): [True: 0, False: 1.86M]
  ------------------
  328|  1.86M|                     }
  329|  1.86M|                  }
  330|    707|               };
_ZZN3glz6detail18beve_to_json_valueITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEERNS_7contextERPKcSE_RmEEvOT1_OT2_OT3_RT0_OT4_jENKUlTyOT_E_clItEEDaSR_:
  313|  3.53k|               auto write_aligned_array = [&]<class T>(T&& value) {
  314|  1.05M|                  for (size_t i = 0; i < n; ++i) {
  ------------------
  |  Branch (314:38): [True: 1.05M, False: 3.53k]
  ------------------
  315|  1.05M|                     if (size_t(end - it) < sizeof(T)) [[unlikely]] {
  ------------------
  |  Branch (315:26): [True: 0, False: 1.05M]
  ------------------
  316|      0|                        ctx.error = error_code::unexpected_end;
  317|      0|                        return;
  318|      0|                     }
  319|  1.05M|                     using V = std::remove_cvref_t<T>;
  320|  1.05M|                     std::memcpy(&value, it, sizeof(V));
  321|       |                     if constexpr (std::endian::native == std::endian::big) {
  322|       |                        byteswap_le(value);
  323|       |                     }
  324|  1.05M|                     to<JSON, T>::template op<Opts>(value, ctx, out, ix);
  325|  1.05M|                     it += sizeof(T);
  326|  1.05M|                     if (i != n - 1) {
  ------------------
  |  Branch (326:26): [True: 1.05M, False: 3.08k]
  ------------------
  327|  1.05M|                        if (!emit_char(ctx, ',', out, ix)) return;
  ------------------
  |  Branch (327:29): [True: 0, False: 1.05M]
  ------------------
  328|  1.05M|                     }
  329|  1.05M|                  }
  330|  3.53k|               };
_ZZN3glz6detail18beve_to_json_valueITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEERNS_7contextERPKcSE_RmEEvOT1_OT2_OT3_RT0_OT4_jENKUlTyOT_E_clIjEEDaSR_:
  313|    550|               auto write_aligned_array = [&]<class T>(T&& value) {
  314|   153k|                  for (size_t i = 0; i < n; ++i) {
  ------------------
  |  Branch (314:38): [True: 153k, False: 550]
  ------------------
  315|   153k|                     if (size_t(end - it) < sizeof(T)) [[unlikely]] {
  ------------------
  |  Branch (315:26): [True: 0, False: 153k]
  ------------------
  316|      0|                        ctx.error = error_code::unexpected_end;
  317|      0|                        return;
  318|      0|                     }
  319|   153k|                     using V = std::remove_cvref_t<T>;
  320|   153k|                     std::memcpy(&value, it, sizeof(V));
  321|       |                     if constexpr (std::endian::native == std::endian::big) {
  322|       |                        byteswap_le(value);
  323|       |                     }
  324|   153k|                     to<JSON, T>::template op<Opts>(value, ctx, out, ix);
  325|   153k|                     it += sizeof(T);
  326|   153k|                     if (i != n - 1) {
  ------------------
  |  Branch (326:26): [True: 152k, False: 323]
  ------------------
  327|   152k|                        if (!emit_char(ctx, ',', out, ix)) return;
  ------------------
  |  Branch (327:29): [True: 0, False: 152k]
  ------------------
  328|   152k|                     }
  329|   153k|                  }
  330|    550|               };
_ZZN3glz6detail18beve_to_json_valueITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEERNS_7contextERPKcSE_RmEEvOT1_OT2_OT3_RT0_OT4_jENKUlTyOT_E_clImEEDaSR_:
  313|  7.07k|               auto write_aligned_array = [&]<class T>(T&& value) {
  314|  96.8k|                  for (size_t i = 0; i < n; ++i) {
  ------------------
  |  Branch (314:38): [True: 89.8k, False: 7.07k]
  ------------------
  315|  89.8k|                     if (size_t(end - it) < sizeof(T)) [[unlikely]] {
  ------------------
  |  Branch (315:26): [True: 0, False: 89.8k]
  ------------------
  316|      0|                        ctx.error = error_code::unexpected_end;
  317|      0|                        return;
  318|      0|                     }
  319|  89.8k|                     using V = std::remove_cvref_t<T>;
  320|  89.8k|                     std::memcpy(&value, it, sizeof(V));
  321|       |                     if constexpr (std::endian::native == std::endian::big) {
  322|       |                        byteswap_le(value);
  323|       |                     }
  324|  89.8k|                     to<JSON, T>::template op<Opts>(value, ctx, out, ix);
  325|  89.8k|                     it += sizeof(T);
  326|  89.8k|                     if (i != n - 1) {
  ------------------
  |  Branch (326:26): [True: 88.6k, False: 1.13k]
  ------------------
  327|  88.6k|                        if (!emit_char(ctx, ',', out, ix)) return;
  ------------------
  |  Branch (327:29): [True: 0, False: 88.6k]
  ------------------
  328|  88.6k|                     }
  329|  89.8k|                  }
  330|  7.07k|               };
_ZZN3glz6detail18beve_to_json_valueITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEERNS_7contextERPKcSE_RmEEvOT1_OT2_OT3_RT0_OT4_jENKUlTyOT_E0_clIfEEDaSR_:
  400|  3.58k|            auto write_array = [&]<class T>(T&& value) {
  401|  3.58k|               const auto n = int_from_compressed(ctx, it, end);
  402|  3.58k|               if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (402:20): [True: 40, False: 3.54k]
  ------------------
  403|     40|                  return;
  404|     40|               }
  405|  1.38M|               for (size_t i = 0; i < n; ++i) {
  ------------------
  |  Branch (405:35): [True: 1.38M, False: 3.25k]
  ------------------
  406|  1.38M|                  if (size_t(end - it) < sizeof(T)) [[unlikely]] {
  ------------------
  |  Branch (406:23): [True: 296, False: 1.38M]
  ------------------
  407|    296|                     ctx.error = error_code::unexpected_end;
  408|    296|                     return;
  409|    296|                  }
  410|  1.38M|                  using V = std::remove_cvref_t<T>;
  411|  1.38M|                  std::memcpy(&value, it, sizeof(V));
  412|       |                  if constexpr (std::endian::native == std::endian::big) {
  413|       |                     byteswap_le(value);
  414|       |                  }
  415|  1.38M|                  to<JSON, T>::template op<Opts>(value, ctx, out, ix);
  416|  1.38M|                  it += sizeof(T);
  417|  1.38M|                  if (i != n - 1) {
  ------------------
  |  Branch (417:23): [True: 1.38M, False: 1.38k]
  ------------------
  418|  1.38M|                     if (!emit_char(ctx, ',', out, ix)) return;
  ------------------
  |  Branch (418:26): [True: 0, False: 1.38M]
  ------------------
  419|  1.38M|                  }
  420|  1.38M|               }
  421|  3.54k|            };
_ZZN3glz6detail18beve_to_json_valueITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEERNS_7contextERPKcSE_RmEEvOT1_OT2_OT3_RT0_OT4_jENKUlTyOT_E0_clIdEEDaSR_:
  400|  1.82k|            auto write_array = [&]<class T>(T&& value) {
  401|  1.82k|               const auto n = int_from_compressed(ctx, it, end);
  402|  1.82k|               if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (402:20): [True: 52, False: 1.77k]
  ------------------
  403|     52|                  return;
  404|     52|               }
  405|   840k|               for (size_t i = 0; i < n; ++i) {
  ------------------
  |  Branch (405:35): [True: 838k, False: 1.45k]
  ------------------
  406|   838k|                  if (size_t(end - it) < sizeof(T)) [[unlikely]] {
  ------------------
  |  Branch (406:23): [True: 322, False: 838k]
  ------------------
  407|    322|                     ctx.error = error_code::unexpected_end;
  408|    322|                     return;
  409|    322|                  }
  410|   838k|                  using V = std::remove_cvref_t<T>;
  411|   838k|                  std::memcpy(&value, it, sizeof(V));
  412|       |                  if constexpr (std::endian::native == std::endian::big) {
  413|       |                     byteswap_le(value);
  414|       |                  }
  415|   838k|                  to<JSON, T>::template op<Opts>(value, ctx, out, ix);
  416|   838k|                  it += sizeof(T);
  417|   838k|                  if (i != n - 1) {
  ------------------
  |  Branch (417:23): [True: 837k, False: 401]
  ------------------
  418|   837k|                     if (!emit_char(ctx, ',', out, ix)) return;
  ------------------
  |  Branch (418:26): [True: 0, False: 837k]
  ------------------
  419|   837k|                  }
  420|   838k|               }
  421|  1.77k|            };
_ZZN3glz6detail18beve_to_json_valueITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEERNS_7contextERPKcSE_RmEEvOT1_OT2_OT3_RT0_OT4_jENKUlTyOT_E0_clIaEEDaSR_:
  400|  11.1k|            auto write_array = [&]<class T>(T&& value) {
  401|  11.1k|               const auto n = int_from_compressed(ctx, it, end);
  402|  11.1k|               if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (402:20): [True: 45, False: 11.1k]
  ------------------
  403|     45|                  return;
  404|     45|               }
  405|   398k|               for (size_t i = 0; i < n; ++i) {
  ------------------
  |  Branch (405:35): [True: 387k, False: 10.9k]
  ------------------
  406|   387k|                  if (size_t(end - it) < sizeof(T)) [[unlikely]] {
  ------------------
  |  Branch (406:23): [True: 202, False: 386k]
  ------------------
  407|    202|                     ctx.error = error_code::unexpected_end;
  408|    202|                     return;
  409|    202|                  }
  410|   386k|                  using V = std::remove_cvref_t<T>;
  411|   386k|                  std::memcpy(&value, it, sizeof(V));
  412|       |                  if constexpr (std::endian::native == std::endian::big) {
  413|       |                     byteswap_le(value);
  414|       |                  }
  415|   386k|                  to<JSON, T>::template op<Opts>(value, ctx, out, ix);
  416|   386k|                  it += sizeof(T);
  417|   386k|                  if (i != n - 1) {
  ------------------
  |  Branch (417:23): [True: 381k, False: 5.92k]
  ------------------
  418|   381k|                     if (!emit_char(ctx, ',', out, ix)) return;
  ------------------
  |  Branch (418:26): [True: 0, False: 381k]
  ------------------
  419|   381k|                  }
  420|   386k|               }
  421|  11.1k|            };
_ZZN3glz6detail18beve_to_json_valueITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEERNS_7contextERPKcSE_RmEEvOT1_OT2_OT3_RT0_OT4_jENKUlTyOT_E0_clIsEEDaSR_:
  400|  4.84k|            auto write_array = [&]<class T>(T&& value) {
  401|  4.84k|               const auto n = int_from_compressed(ctx, it, end);
  402|  4.84k|               if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (402:20): [True: 49, False: 4.79k]
  ------------------
  403|     49|                  return;
  404|     49|               }
  405|   394k|               for (size_t i = 0; i < n; ++i) {
  ------------------
  |  Branch (405:35): [True: 390k, False: 4.64k]
  ------------------
  406|   390k|                  if (size_t(end - it) < sizeof(T)) [[unlikely]] {
  ------------------
  |  Branch (406:23): [True: 155, False: 389k]
  ------------------
  407|    155|                     ctx.error = error_code::unexpected_end;
  408|    155|                     return;
  409|    155|                  }
  410|   389k|                  using V = std::remove_cvref_t<T>;
  411|   389k|                  std::memcpy(&value, it, sizeof(V));
  412|       |                  if constexpr (std::endian::native == std::endian::big) {
  413|       |                     byteswap_le(value);
  414|       |                  }
  415|   389k|                  to<JSON, T>::template op<Opts>(value, ctx, out, ix);
  416|   389k|                  it += sizeof(T);
  417|   389k|                  if (i != n - 1) {
  ------------------
  |  Branch (417:23): [True: 388k, False: 1.59k]
  ------------------
  418|   388k|                     if (!emit_char(ctx, ',', out, ix)) return;
  ------------------
  |  Branch (418:26): [True: 0, False: 388k]
  ------------------
  419|   388k|                  }
  420|   389k|               }
  421|  4.79k|            };
_ZZN3glz6detail18beve_to_json_valueITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEERNS_7contextERPKcSE_RmEEvOT1_OT2_OT3_RT0_OT4_jENKUlTyOT_E0_clIiEEDaSR_:
  400|  4.21k|            auto write_array = [&]<class T>(T&& value) {
  401|  4.21k|               const auto n = int_from_compressed(ctx, it, end);
  402|  4.21k|               if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (402:20): [True: 53, False: 4.15k]
  ------------------
  403|     53|                  return;
  404|     53|               }
  405|   784k|               for (size_t i = 0; i < n; ++i) {
  ------------------
  |  Branch (405:35): [True: 780k, False: 3.92k]
  ------------------
  406|   780k|                  if (size_t(end - it) < sizeof(T)) [[unlikely]] {
  ------------------
  |  Branch (406:23): [True: 230, False: 780k]
  ------------------
  407|    230|                     ctx.error = error_code::unexpected_end;
  408|    230|                     return;
  409|    230|                  }
  410|   780k|                  using V = std::remove_cvref_t<T>;
  411|   780k|                  std::memcpy(&value, it, sizeof(V));
  412|       |                  if constexpr (std::endian::native == std::endian::big) {
  413|       |                     byteswap_le(value);
  414|       |                  }
  415|   780k|                  to<JSON, T>::template op<Opts>(value, ctx, out, ix);
  416|   780k|                  it += sizeof(T);
  417|   780k|                  if (i != n - 1) {
  ------------------
  |  Branch (417:23): [True: 778k, False: 2.27k]
  ------------------
  418|   778k|                     if (!emit_char(ctx, ',', out, ix)) return;
  ------------------
  |  Branch (418:26): [True: 0, False: 778k]
  ------------------
  419|   778k|                  }
  420|   780k|               }
  421|  4.15k|            };
_ZZN3glz6detail18beve_to_json_valueITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEERNS_7contextERPKcSE_RmEEvOT1_OT2_OT3_RT0_OT4_jENKUlTyOT_E0_clIlEEDaSR_:
  400|  1.49k|            auto write_array = [&]<class T>(T&& value) {
  401|  1.49k|               const auto n = int_from_compressed(ctx, it, end);
  402|  1.49k|               if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (402:20): [True: 43, False: 1.45k]
  ------------------
  403|     43|                  return;
  404|     43|               }
  405|   445k|               for (size_t i = 0; i < n; ++i) {
  ------------------
  |  Branch (405:35): [True: 444k, False: 1.16k]
  ------------------
  406|   444k|                  if (size_t(end - it) < sizeof(T)) [[unlikely]] {
  ------------------
  |  Branch (406:23): [True: 290, False: 444k]
  ------------------
  407|    290|                     ctx.error = error_code::unexpected_end;
  408|    290|                     return;
  409|    290|                  }
  410|   444k|                  using V = std::remove_cvref_t<T>;
  411|   444k|                  std::memcpy(&value, it, sizeof(V));
  412|       |                  if constexpr (std::endian::native == std::endian::big) {
  413|       |                     byteswap_le(value);
  414|       |                  }
  415|   444k|                  to<JSON, T>::template op<Opts>(value, ctx, out, ix);
  416|   444k|                  it += sizeof(T);
  417|   444k|                  if (i != n - 1) {
  ------------------
  |  Branch (417:23): [True: 443k, False: 318]
  ------------------
  418|   443k|                     if (!emit_char(ctx, ',', out, ix)) return;
  ------------------
  |  Branch (418:26): [True: 0, False: 443k]
  ------------------
  419|   443k|                  }
  420|   444k|               }
  421|  1.45k|            };
_ZZN3glz6detail18beve_to_json_valueITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEERNS_7contextERPKcSE_RmEEvOT1_OT2_OT3_RT0_OT4_jENKUlTyOT_E0_clIhEEDaSR_:
  400|  36.6k|            auto write_array = [&]<class T>(T&& value) {
  401|  36.6k|               const auto n = int_from_compressed(ctx, it, end);
  402|  36.6k|               if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (402:20): [True: 40, False: 36.6k]
  ------------------
  403|     40|                  return;
  404|     40|               }
  405|   274k|               for (size_t i = 0; i < n; ++i) {
  ------------------
  |  Branch (405:35): [True: 238k, False: 36.4k]
  ------------------
  406|   238k|                  if (size_t(end - it) < sizeof(T)) [[unlikely]] {
  ------------------
  |  Branch (406:23): [True: 209, False: 237k]
  ------------------
  407|    209|                     ctx.error = error_code::unexpected_end;
  408|    209|                     return;
  409|    209|                  }
  410|   237k|                  using V = std::remove_cvref_t<T>;
  411|   237k|                  std::memcpy(&value, it, sizeof(V));
  412|       |                  if constexpr (std::endian::native == std::endian::big) {
  413|       |                     byteswap_le(value);
  414|       |                  }
  415|   237k|                  to<JSON, T>::template op<Opts>(value, ctx, out, ix);
  416|   237k|                  it += sizeof(T);
  417|   237k|                  if (i != n - 1) {
  ------------------
  |  Branch (417:23): [True: 223k, False: 14.0k]
  ------------------
  418|   223k|                     if (!emit_char(ctx, ',', out, ix)) return;
  ------------------
  |  Branch (418:26): [True: 0, False: 223k]
  ------------------
  419|   223k|                  }
  420|   237k|               }
  421|  36.6k|            };
_ZZN3glz6detail18beve_to_json_valueITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEERNS_7contextERPKcSE_RmEEvOT1_OT2_OT3_RT0_OT4_jENKUlTyOT_E0_clItEEDaSR_:
  400|  2.16k|            auto write_array = [&]<class T>(T&& value) {
  401|  2.16k|               const auto n = int_from_compressed(ctx, it, end);
  402|  2.16k|               if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (402:20): [True: 55, False: 2.11k]
  ------------------
  403|     55|                  return;
  404|     55|               }
  405|   258k|               for (size_t i = 0; i < n; ++i) {
  ------------------
  |  Branch (405:35): [True: 257k, False: 1.83k]
  ------------------
  406|   257k|                  if (size_t(end - it) < sizeof(T)) [[unlikely]] {
  ------------------
  |  Branch (406:23): [True: 280, False: 256k]
  ------------------
  407|    280|                     ctx.error = error_code::unexpected_end;
  408|    280|                     return;
  409|    280|                  }
  410|   256k|                  using V = std::remove_cvref_t<T>;
  411|   256k|                  std::memcpy(&value, it, sizeof(V));
  412|       |                  if constexpr (std::endian::native == std::endian::big) {
  413|       |                     byteswap_le(value);
  414|       |                  }
  415|   256k|                  to<JSON, T>::template op<Opts>(value, ctx, out, ix);
  416|   256k|                  it += sizeof(T);
  417|   256k|                  if (i != n - 1) {
  ------------------
  |  Branch (417:23): [True: 256k, False: 720]
  ------------------
  418|   256k|                     if (!emit_char(ctx, ',', out, ix)) return;
  ------------------
  |  Branch (418:26): [True: 0, False: 256k]
  ------------------
  419|   256k|                  }
  420|   256k|               }
  421|  2.11k|            };
_ZZN3glz6detail18beve_to_json_valueITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEERNS_7contextERPKcSE_RmEEvOT1_OT2_OT3_RT0_OT4_jENKUlTyOT_E0_clIjEEDaSR_:
  400|  1.91k|            auto write_array = [&]<class T>(T&& value) {
  401|  1.91k|               const auto n = int_from_compressed(ctx, it, end);
  402|  1.91k|               if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (402:20): [True: 48, False: 1.86k]
  ------------------
  403|     48|                  return;
  404|     48|               }
  405|   715k|               for (size_t i = 0; i < n; ++i) {
  ------------------
  |  Branch (405:35): [True: 714k, False: 1.64k]
  ------------------
  406|   714k|                  if (size_t(end - it) < sizeof(T)) [[unlikely]] {
  ------------------
  |  Branch (406:23): [True: 215, False: 713k]
  ------------------
  407|    215|                     ctx.error = error_code::unexpected_end;
  408|    215|                     return;
  409|    215|                  }
  410|   713k|                  using V = std::remove_cvref_t<T>;
  411|   713k|                  std::memcpy(&value, it, sizeof(V));
  412|       |                  if constexpr (std::endian::native == std::endian::big) {
  413|       |                     byteswap_le(value);
  414|       |                  }
  415|   713k|                  to<JSON, T>::template op<Opts>(value, ctx, out, ix);
  416|   713k|                  it += sizeof(T);
  417|   713k|                  if (i != n - 1) {
  ------------------
  |  Branch (417:23): [True: 713k, False: 454]
  ------------------
  418|   713k|                     if (!emit_char(ctx, ',', out, ix)) return;
  ------------------
  |  Branch (418:26): [True: 0, False: 713k]
  ------------------
  419|   713k|                  }
  420|   713k|               }
  421|  1.86k|            };
_ZZN3glz6detail18beve_to_json_valueITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEERNS_7contextERPKcSE_RmEEvOT1_OT2_OT3_RT0_OT4_jENKUlTyOT_E0_clImEEDaSR_:
  400|  15.3k|            auto write_array = [&]<class T>(T&& value) {
  401|  15.3k|               const auto n = int_from_compressed(ctx, it, end);
  402|  15.3k|               if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (402:20): [True: 144, False: 15.1k]
  ------------------
  403|    144|                  return;
  404|    144|               }
  405|   301k|               for (size_t i = 0; i < n; ++i) {
  ------------------
  |  Branch (405:35): [True: 286k, False: 14.9k]
  ------------------
  406|   286k|                  if (size_t(end - it) < sizeof(T)) [[unlikely]] {
  ------------------
  |  Branch (406:23): [True: 239, False: 286k]
  ------------------
  407|    239|                     ctx.error = error_code::unexpected_end;
  408|    239|                     return;
  409|    239|                  }
  410|   286k|                  using V = std::remove_cvref_t<T>;
  411|   286k|                  std::memcpy(&value, it, sizeof(V));
  412|       |                  if constexpr (std::endian::native == std::endian::big) {
  413|       |                     byteswap_le(value);
  414|       |                  }
  415|   286k|                  to<JSON, T>::template op<Opts>(value, ctx, out, ix);
  416|   286k|                  it += sizeof(T);
  417|   286k|                  if (i != n - 1) {
  ------------------
  |  Branch (417:23): [True: 285k, False: 377]
  ------------------
  418|   285k|                     if (!emit_char(ctx, ',', out, ix)) return;
  ------------------
  |  Branch (418:26): [True: 0, False: 285k]
  ------------------
  419|   285k|                  }
  420|   286k|               }
  421|  15.1k|            };
_ZZN3glz6detail18beve_to_json_valueITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEERNS_7contextERPKcSE_RmEEvOT1_OT2_OT3_RT0_OT4_jENKUlvE_clEv:
  706|   838k|               auto write_complex = [&]() -> bool {
  707|   838k|                  if (!emit_char(ctx, '[', out, ix)) return false;
  ------------------
  |  Branch (707:23): [True: 0, False: 838k]
  ------------------
  708|   838k|                  beve_to_json_number<Opts>(number_tag, ctx, it, end, out, ix);
  709|   838k|                  if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (709:23): [True: 336, False: 837k]
  ------------------
  710|    336|                     return false;
  711|    336|                  }
  712|   837k|                  if (!emit_char(ctx, ',', out, ix)) return false;
  ------------------
  |  Branch (712:23): [True: 0, False: 837k]
  ------------------
  713|   837k|                  beve_to_json_number<Opts>(number_tag, ctx, it, end, out, ix);
  714|   837k|                  if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (714:23): [True: 135, False: 837k]
  ------------------
  715|    135|                     return false;
  716|    135|                  }
  717|   837k|                  return emit_char(ctx, ']', out, ix);
  718|   837k|               };
_ZZN3glz6detail18beve_to_json_valueITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEERNS_7contextERPKcSE_RmEEvOT1_OT2_OT3_RT0_OT4_jENKUlmE_clEm:
  721|  2.88k|               auto write_complex_array = [&](const size_t n) -> bool {
  722|  2.88k|                  if (!emit_char(ctx, '[', out, ix)) return false;
  ------------------
  |  Branch (722:23): [True: 0, False: 2.88k]
  ------------------
  723|   840k|                  for (size_t i = 0; i < n; ++i) {
  ------------------
  |  Branch (723:38): [True: 837k, False: 2.43k]
  ------------------
  724|   837k|                     if (!write_complex()) return false;
  ------------------
  |  Branch (724:26): [True: 447, False: 837k]
  ------------------
  725|   837k|                     if (i != n - 1) {
  ------------------
  |  Branch (725:26): [True: 836k, False: 483]
  ------------------
  726|   836k|                        if (!emit_char(ctx, ',', out, ix)) return false;
  ------------------
  |  Branch (726:29): [True: 0, False: 836k]
  ------------------
  727|   836k|                     }
  728|   837k|                  }
  729|  2.43k|                  return emit_char(ctx, ']', out, ix);
  730|  2.88k|               };

_ZN3glz11invalid_endITkNS_10is_contextENS_7contextERPKcS3_EEbRT_OT0_T1_:
   23|  60.1k|   {
   24|  60.1k|      if (it >= end) [[unlikely]] {
  ------------------
  |  Branch (24:11): [True: 318, False: 59.8k]
  ------------------
   25|    318|         ctx.error = error_code::unexpected_end;
   26|    318|         return true;
   27|    318|      }
   28|  59.8k|      else [[likely]] {
   29|  59.8k|         return false;
   30|  59.8k|      }
   31|  60.1k|   }
_ZN3glz19int_from_compressedIRNS_7contextERPKcS4_EEmOT_OT0_T1_:
  256|  2.33M|   {
  257|  2.33M|      if (it >= end) [[unlikely]] {
  ------------------
  |  Branch (257:11): [True: 1.43k, False: 2.33M]
  ------------------
  258|  1.43k|         ctx.error = error_code::unexpected_end;
  259|  1.43k|         return 0;
  260|  1.43k|      }
  261|       |
  262|  2.33M|      uint8_t header;
  263|  2.33M|      std::memcpy(&header, it, 1);
  264|  2.33M|      const uint8_t config = header & 0b000000'11;
  265|       |
  266|  2.33M|      if (size_t(end - it) < byte_count_lookup[config]) [[unlikely]] {
  ------------------
  |  Branch (266:11): [True: 1.14k, False: 2.33M]
  ------------------
  267|  1.14k|         ctx.error = error_code::unexpected_end;
  268|  1.14k|         return 0;
  269|  1.14k|      }
  270|       |
  271|  2.33M|      switch (config) {
  272|  2.26M|      case 0:
  ------------------
  |  Branch (272:7): [True: 2.26M, False: 71.7k]
  ------------------
  273|  2.26M|         ++it;
  274|  2.26M|         return header >> 2;
  275|  51.8k|      case 1: {
  ------------------
  |  Branch (275:7): [True: 51.8k, False: 2.28M]
  ------------------
  276|  51.8k|         uint16_t h;
  277|  51.8k|         std::memcpy(&h, it, 2);
  278|       |         if constexpr (std::endian::native == std::endian::big) {
  279|       |            h = std::byteswap(h);
  280|       |         }
  281|  51.8k|         it += 2;
  282|  51.8k|         return h >> 2;
  283|      0|      }
  284|  10.0k|      case 2: {
  ------------------
  |  Branch (284:7): [True: 10.0k, False: 2.32M]
  ------------------
  285|  10.0k|         uint32_t h;
  286|  10.0k|         std::memcpy(&h, it, 4);
  287|       |         if constexpr (std::endian::native == std::endian::big) {
  288|       |            h = std::byteswap(h);
  289|       |         }
  290|  10.0k|         it += 4;
  291|  10.0k|         return h >> 2;
  292|      0|      }
  293|  9.76k|      case 3: {
  ------------------
  |  Branch (293:7): [True: 9.76k, False: 2.32M]
  ------------------
  294|       |         // On 32-bit systems it's impossible to address more than 4 GBiB of memory, so we should verify first if we are
  295|       |         // running in 64-bit mode here
  296|  9.76k|         if constexpr (sizeof(size_t) > sizeof(uint32_t)) {
  297|  9.76k|            uint64_t h;
  298|  9.76k|            std::memcpy(&h, it, 8);
  299|       |            if constexpr (std::endian::native == std::endian::big) {
  300|       |               h = std::byteswap(h);
  301|       |            }
  302|  9.76k|            it += 8;
  303|  9.76k|            h = h >> 2;
  304|  9.76k|            static constexpr uint64_t safety_limit = 1ull << 48; // 2^48
  305|  9.76k|            if (h > safety_limit) [[unlikely]] {
  ------------------
  |  Branch (305:17): [True: 1.21k, False: 8.55k]
  ------------------
  306|  1.21k|               ctx.error = error_code::unexpected_end;
  307|  1.21k|               return 0;
  308|  1.21k|            }
  309|  8.55k|            return h;
  310|       |         }
  311|       |         else {
  312|       |            // 8-byte length encoding not supported on 32-bit systems
  313|       |            ctx.error = error_code::invalid_length;
  314|       |            return 0;
  315|       |         }
  316|  9.76k|      }
  317|  9.76k|      default:
  ------------------
  |  Branch (317:7): [True: 0, False: 2.33M]
  ------------------
  318|  9.76k|         ctx.error = error_code::syntax_error;
  319|  9.76k|         return 0;
  320|  2.33M|      }
  321|  2.33M|   }
_ZN3glz25typed_array_out_of_boundsITkNS_10is_contextENS_7contextERPKcS4_EEbRT_OT0_OT1_mmm:
   48|  26.3k|   {
   49|  26.3k|      const uint64_t available = uint64_t(end - it);
   50|  26.3k|      if constexpr (sizeof(size_t) > sizeof(uint32_t)) {
   51|  26.3k|         if (available < padding + count * element_size) [[unlikely]] {
  ------------------
  |  Branch (51:14): [True: 701, False: 25.6k]
  ------------------
   52|    701|            ctx.error = error_code::unexpected_end;
   53|    701|            return true;
   54|    701|         }
   55|       |      }
   56|       |      else {
   57|       |         if (available < padding || count > (available - padding) / element_size) [[unlikely]] {
   58|       |            ctx.error = error_code::unexpected_end;
   59|       |            return true;
   60|       |         }
   61|       |      }
   62|  25.6k|      return false;
   63|  26.3k|   }
_ZN3glz27packed_bool_padding_is_zeroEhm:
  363|   237k|   {
  364|   237k|      const size_t used_bits = count % 8;
  365|   237k|      return used_bits == 0 || (last_byte >> used_bits) == 0;
  ------------------
  |  Branch (365:14): [True: 16.4k, False: 220k]
  |  Branch (365:32): [True: 220k, False: 21]
  ------------------
  366|   237k|   }
_ZN3glz19skip_compressed_intITkNS_10is_contextERNS_7contextERPKcS4_EEvOT_OT0_T1_:
  324|  2.00k|   {
  325|  2.00k|      if (invalid_end(ctx, it, end)) {
  ------------------
  |  Branch (325:11): [True: 2, False: 1.99k]
  ------------------
  326|      2|         return;
  327|      2|      }
  328|       |
  329|  1.99k|      uint8_t header;
  330|  1.99k|      std::memcpy(&header, it, 1);
  331|  1.99k|      const uint8_t config = header & 0b000000'11;
  332|       |
  333|  1.99k|      if (size_t(end - it) < byte_count_lookup[config]) [[unlikely]] {
  ------------------
  |  Branch (333:11): [True: 1, False: 1.99k]
  ------------------
  334|      1|         ctx.error = error_code::unexpected_end;
  335|      1|         return;
  336|      1|      }
  337|       |
  338|  1.99k|      switch (config) {
  339|    930|      case 0:
  ------------------
  |  Branch (339:7): [True: 930, False: 1.06k]
  ------------------
  340|    930|         ++it;
  341|    930|         return;
  342|    315|      case 1: {
  ------------------
  |  Branch (342:7): [True: 315, False: 1.68k]
  ------------------
  343|    315|         it += 2;
  344|    315|         return;
  345|      0|      }
  346|    532|      case 2: {
  ------------------
  |  Branch (346:7): [True: 532, False: 1.46k]
  ------------------
  347|    532|         it += 4;
  348|    532|         return;
  349|      0|      }
  350|    221|      case 3: {
  ------------------
  |  Branch (350:7): [True: 221, False: 1.77k]
  ------------------
  351|    221|         it += 8;
  352|    221|         return;
  353|      0|      }
  354|      0|      default:
  ------------------
  |  Branch (354:7): [True: 0, False: 1.99k]
  ------------------
  355|      0|         return;
  356|  1.99k|      }
  357|  1.99k|   }
_ZN3glz27read_aligned_complex_headerITkNS_10is_contextERNS_7contextERPKcS4_EEmOT_OT0_T1_h:
  382|  1.20k|   {
  383|  1.20k|      if (invalid_end(ctx, it, end)) {
  ------------------
  |  Branch (383:11): [True: 2, False: 1.19k]
  ------------------
  384|      2|         return 0;
  385|      2|      }
  386|  1.19k|      if (uint8_t(*it) != tag::aligned_typed_array) [[unlikely]] {
  ------------------
  |  Branch (386:11): [True: 8, False: 1.19k]
  ------------------
  387|      8|         ctx.error = error_code::syntax_error;
  388|      8|         return 0;
  389|      8|      }
  390|  1.19k|      ++it;
  391|       |
  392|  1.19k|      if (invalid_end(ctx, it, end)) {
  ------------------
  |  Branch (392:11): [True: 2, False: 1.18k]
  ------------------
  393|      2|         return 0;
  394|      2|      }
  395|       |      // The COMPLEX HEADER holds the numerical type (bits 3-4) and BYTE COUNT (bits 5-7) where a numeric
  396|       |      // typed array header does, so the two agree exactly when those bits match. Category 3 is not numeric.
  397|  1.18k|      constexpr uint8_t numeric_bits = 0b111'11'000;
  398|  1.18k|      const uint8_t expected_numeric_header = tag::typed_array | (complex_header & numeric_bits);
  399|  1.18k|      if (uint8_t(*it) != expected_numeric_header || ((complex_header >> 3) & 0b11) == 3) [[unlikely]] {
  ------------------
  |  Branch (399:11): [True: 13, False: 1.17k]
  |  Branch (399:54): [True: 1, False: 1.17k]
  ------------------
  400|     14|         ctx.error = error_code::syntax_error;
  401|     14|         return 0;
  402|     14|      }
  403|  1.17k|      ++it;
  404|       |
  405|  1.17k|      const size_t components = int_from_compressed(ctx, it, end);
  406|  1.17k|      if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (406:11): [True: 31, False: 1.14k]
  ------------------
  407|     31|         return 0;
  408|     31|      }
  409|  1.14k|      if (components % 2 != 0) [[unlikely]] {
  ------------------
  |  Branch (409:11): [True: 26, False: 1.11k]
  ------------------
  410|     26|         ctx.error = error_code::syntax_error;
  411|     26|         return 0;
  412|     26|      }
  413|       |
  414|  1.11k|      if (invalid_end(ctx, it, end)) {
  ------------------
  |  Branch (414:11): [True: 32, False: 1.08k]
  ------------------
  415|     32|         return 0;
  416|     32|      }
  417|  1.08k|      const uint8_t padding = uint8_t(*it);
  418|  1.08k|      ++it;
  419|  1.08k|      const size_t component_size = byte_count_lookup[complex_header >> 5];
  420|  1.08k|      if (padding >= component_size) [[unlikely]] {
  ------------------
  |  Branch (420:11): [True: 17, False: 1.06k]
  ------------------
  421|     17|         ctx.error = error_code::syntax_error;
  422|     17|         return 0;
  423|     17|      }
  424|  1.06k|      if (typed_array_out_of_bounds(ctx, it, end, components, component_size, padding)) {
  ------------------
  |  Branch (424:11): [True: 58, False: 1.01k]
  ------------------
  425|     58|         return 0;
  426|     58|      }
  427|  1.01k|      it += padding;
  428|  1.01k|      return components / 2;
  429|  1.06k|   }

_ZN3glz9read_beveITkNS_14read_supportedIL_ZNS_4BEVEEEEE9my_structRKNSt3__16vectorIcNS3_9allocatorIcEEEEEENS3_8expectedIT_NS_9error_ctxEEEOT0_:
 3350|  24.1k|   {
 3351|  24.1k|      T value{};
 3352|  24.1k|      const auto pe = read<opts{.format = BEVE}>(value, std::forward<Buffer>(buffer));
 3353|  24.1k|      if (pe) [[unlikely]] {
  ------------------
  |  Branch (3353:11): [True: 24.0k, False: 67]
  ------------------
 3354|  24.0k|         return unexpected(pe);
 3355|  24.0k|      }
 3356|     67|      return value;
 3357|  24.1k|   }
_ZN3glz5parseILj1EE2opITnDaXtlNS_4optsELj1ELb0ELb0ELb1ELb1EEER9my_structTkNS_10is_contextERNS_7contextERPKcS9_Qntcl15check_no_headerT_EEEvOT0_OT1_OT2_T3_:
   57|  24.1k|      {
   58|       |         if constexpr (const_value_v<T>) {
   59|       |            if constexpr (check_error_on_const_read(Opts)) {
   60|       |               ctx.error = error_code::attempt_const_read;
   61|       |            }
   62|       |            else {
   63|       |               // do not read anything into the const value
   64|       |               skip_value<BEVE>::op<Opts>(std::forward<Ctx>(ctx), std::forward<It0>(it), end);
   65|       |            }
   66|       |         }
   67|  24.1k|         else {
   68|  24.1k|            using V = std::remove_cvref_t<T>;
   69|  24.1k|            from<BEVE, V>::template op<Opts>(std::forward<T>(value), std::forward<Ctx>(ctx), std::forward<It0>(it),
   70|  24.1k|                                             end);
   71|  24.1k|         }
   72|  24.1k|      }
_ZN3glz4fromILj1E9my_structE2opITnDaXtlNS_4optsELj1ELb0ELb0ELb1ELb1EEETnNS_14string_literalEXtlNS5_ILm1EEEEERS1_TkNS_10is_contextERNS_7contextERPKcSB_Qeqcl23check_structs_as_arraysTL0__ELb0EEEvOT1_OT2_OT3_T4_:
 3039|  24.1k|      {
 3040|  24.1k|         constexpr uint8_t type = 0; // string key
 3041|  24.1k|         constexpr uint8_t header = tag::object | type;
 3042|       |
 3043|  24.1k|         if (invalid_end(ctx, it, end)) {
  ------------------
  |  Branch (3043:14): [True: 0, False: 24.1k]
  ------------------
 3044|      0|            return;
 3045|      0|         }
 3046|  24.1k|         const auto tag = uint8_t(*it);
 3047|  24.1k|         if (tag != header) [[unlikely]] {
  ------------------
  |  Branch (3047:14): [True: 19.4k, False: 4.68k]
  ------------------
 3048|  19.4k|            ctx.error = error_code::syntax_error;
 3049|  19.4k|            return;
 3050|  19.4k|         }
 3051|       |
 3052|  4.68k|         depth_guard guard{ctx};
 3053|  4.68k|         if (!guard) [[unlikely]] {
  ------------------
  |  Branch (3053:14): [True: 0, False: 4.68k]
  ------------------
 3054|      0|            return;
 3055|      0|         }
 3056|       |
 3057|  4.68k|         ++it;
 3058|       |
 3059|  4.68k|         static constexpr auto N = reflect<T>::size;
 3060|       |         if constexpr (N == 0) {
 3061|       |            (void)value;
 3062|       |         }
 3063|       |
 3064|  4.68k|         static constexpr bit_array<N> all_fields = [] {
 3065|  4.68k|            bit_array<N> arr{};
 3066|  4.68k|            for (size_t i = 0; i < N; ++i) {
 3067|  4.68k|               arr[i] = true;
 3068|  4.68k|            }
 3069|  4.68k|            return arr;
 3070|  4.68k|         }();
 3071|       |
 3072|  4.68k|         decltype(auto) fields = [&]() -> decltype(auto) {
 3073|  4.68k|            if constexpr (Opts.error_on_missing_keys || Opts.partial_read) {
 3074|  4.68k|               return bit_array<N>{};
 3075|  4.68k|            }
 3076|  4.68k|            else {
 3077|  4.68k|               return nullptr;
 3078|  4.68k|            }
 3079|  4.68k|         }();
 3080|       |
 3081|  4.68k|         const auto n_keys = int_from_compressed(ctx, it, end);
 3082|  4.68k|         if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (3082:14): [True: 173, False: 4.50k]
  ------------------
 3083|    173|            return;
 3084|    173|         }
 3085|       |
 3086|  20.2k|         for (size_t i = 0; i < n_keys; ++i) {
  ------------------
  |  Branch (3086:29): [True: 15.6k, False: 4.50k]
  ------------------
 3087|       |            if constexpr (Opts.partial_read) {
 3088|       |               if ((all_fields & fields) == all_fields) {
 3089|       |                  return;
 3090|       |               }
 3091|       |            }
 3092|       |
 3093|  15.6k|            if constexpr (N > 0) {
 3094|  15.6k|               static constexpr auto HashInfo = hash_info<T>;
 3095|       |
 3096|  15.6k|               const auto n = int_from_compressed(ctx, it, end);
 3097|  15.6k|               if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (3097:20): [True: 816, False: 14.8k]
  ------------------
 3098|    816|                  return;
 3099|    816|               }
 3100|  14.8k|               if (uint64_t(end - it) < n || it == end) [[unlikely]] {
  ------------------
  |  Branch (3100:20): [True: 464, False: 14.4k]
  |  Branch (3100:46): [True: 321, False: 14.0k]
  ------------------
 3101|    785|                  ctx.error = error_code::unexpected_end;
 3102|    785|                  return;
 3103|    785|               }
 3104|       |
 3105|       |               if constexpr (not Tag.sv().empty() && not has_member_with_name<T>(Tag.sv())) {
 3106|       |                  // Discriminator key injected by the variant reader: skip it (and its value) without
 3107|       |                  // consulting error_on_unknown_keys, while the alternative's real keys stay checked.
 3108|       |                  if (sv{it, n} == Tag.sv()) {
 3109|       |                     it += n;
 3110|       |                     skip_value<BEVE>::op<Opts>(ctx, it, end);
 3111|       |                     if (bool(ctx.error)) [[unlikely]] {
 3112|       |                        return;
 3113|       |                     }
 3114|       |                     continue;
 3115|       |                  }
 3116|       |               }
 3117|       |
 3118|  14.0k|               const auto index = decode_hash_with_size<BEVE, T, HashInfo, HashInfo.type>::op(it, end, n);
 3119|       |
 3120|  14.0k|               if (index < N) [[likely]] {
  ------------------
  |  Branch (3120:20): [True: 13.2k, False: 808]
  ------------------
 3121|       |                  if constexpr (Opts.error_on_missing_keys || Opts.partial_read) {
 3122|       |                     fields[index] = true;
 3123|       |                  }
 3124|       |
 3125|  13.2k|                  const sv key{it, n};
 3126|  13.2k|                  it += n;
 3127|       |
 3128|  13.2k|                  visit<N>(
 3129|  13.2k|                     [&]<size_t I>() {
 3130|  13.2k|                        static constexpr auto TargetKey = get<I>(reflect<T>::keys);
 3131|  13.2k|                        static constexpr auto Length = TargetKey.size();
 3132|  13.2k|                        if ((Length == n) && compare<Length>(TargetKey.data(), key.data())) [[likely]] {
 3133|       |                           // An `else` branch rather than an early return, so a skipped field's reader is
 3134|       |                           // never instantiated -- see `skipped_by_meta`.
 3135|  13.2k|                           if constexpr (skipped_by_meta<T, I, operation::parse>) {
 3136|  13.2k|                              skip_value<BEVE>::op<Opts>(ctx, it, end);
 3137|  13.2k|                           }
 3138|  13.2k|                           else {
 3139|       |                              // Check for null value skipping on read
 3140|  13.2k|                              if constexpr (check_skip_null_members_on_read(Opts)) {
 3141|  13.2k|                                 if (invalid_end(ctx, it, end)) {
 3142|  13.2k|                                    return;
 3143|  13.2k|                                 }
 3144|  13.2k|                                 if (uint8_t(*it) == tag::null) {
 3145|  13.2k|                                    ++it; // Skip the null tag
 3146|  13.2k|                                    return;
 3147|  13.2k|                                 }
 3148|  13.2k|                              }
 3149|       |
 3150|  13.2k|                              if constexpr (reflectable<T>) {
 3151|  13.2k|                                 parse<BEVE>::op<Opts>(get_member(value, get<I>(to_tie(value))), ctx, it, end);
 3152|  13.2k|                              }
 3153|  13.2k|                              else {
 3154|  13.2k|                                 parse<BEVE>::op<Opts>(get_member(value, get<I>(reflect<T>::values)), ctx, it, end);
 3155|  13.2k|                              }
 3156|  13.2k|                           }
 3157|  13.2k|                        }
 3158|  13.2k|                        else {
 3159|  13.2k|                           if constexpr (Opts.error_on_unknown_keys) {
 3160|  13.2k|                              ctx.error = error_code::unknown_key;
 3161|  13.2k|                              return;
 3162|  13.2k|                           }
 3163|  13.2k|                           else {
 3164|  13.2k|                              skip_value<BEVE>::op<Opts>(ctx, it, end);
 3165|  13.2k|                              if (bool(ctx.error)) [[unlikely]]
 3166|  13.2k|                                 return;
 3167|  13.2k|                           }
 3168|  13.2k|                        }
 3169|  13.2k|                     },
 3170|  13.2k|                     index);
 3171|       |
 3172|  13.2k|                  if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (3172:23): [True: 2.03k, False: 11.2k]
  ------------------
 3173|  2.03k|                     return;
 3174|  2.03k|                  }
 3175|  13.2k|               }
 3176|    808|               else [[unlikely]] {
 3177|    808|                  if constexpr (Opts.error_on_unknown_keys) {
 3178|    808|                     ctx.error = error_code::unknown_key;
 3179|    808|                     return;
 3180|       |                  }
 3181|       |                  else {
 3182|       |                     it += n;
 3183|       |                     skip_value<BEVE>::op<Opts>(ctx, it, end);
 3184|       |                     if (bool(ctx.error)) [[unlikely]]
 3185|       |                        return;
 3186|       |                  }
 3187|    808|               }
 3188|       |            }
 3189|       |            else if constexpr (Opts.error_on_unknown_keys) {
 3190|       |               ctx.error = error_code::unknown_key;
 3191|       |               return;
 3192|       |            }
 3193|       |            else {
 3194|       |               skip_value<BEVE>::op<Opts>(ctx, it, end);
 3195|       |               if (bool(ctx.error)) [[unlikely]]
 3196|       |                  return;
 3197|       |            }
 3198|  15.6k|         }
 3199|       |
 3200|       |         if constexpr (Opts.error_on_missing_keys) {
 3201|       |            constexpr auto req_fields = required_fields<T, Opts>();
 3202|       |            if ((req_fields & fields) != req_fields) {
 3203|       |               for (size_t i = 0; i < N; ++i) {
 3204|       |                  if (not fields[i] && req_fields[i]) {
 3205|       |                     ctx.custom_error_message = reflect<T>::keys[i];
 3206|       |                     break;
 3207|       |                  }
 3208|       |               }
 3209|       |               ctx.error = error_code::missing_key;
 3210|       |               return;
 3211|       |            }
 3212|       |         }
 3213|  4.50k|      }
_ZZN3glz4fromILj1E9my_structE2opITnDaXtlNS_4optsELj1ELb0ELb0ELb1ELb1EEETnNS_14string_literalEXtlNS5_ILm1EEEEERS1_TkNS_10is_contextERNS_7contextERPKcSB_Qeqcl23check_structs_as_arraysTL0__ELb0EEEvOT1_OT2_OT3_T4_ENKUlvE0_clEv:
 3072|  4.68k|         decltype(auto) fields = [&]() -> decltype(auto) {
 3073|       |            if constexpr (Opts.error_on_missing_keys || Opts.partial_read) {
 3074|       |               return bit_array<N>{};
 3075|       |            }
 3076|  4.68k|            else {
 3077|  4.68k|               return nullptr;
 3078|  4.68k|            }
 3079|  4.68k|         }();
_ZZN3glz4fromILj1E9my_structE2opITnDaXtlNS_4optsELj1ELb0ELb0ELb1ELb1EEETnNS_14string_literalEXtlNS5_ILm1EEEEERS1_TkNS_10is_contextERNS_7contextERPKcSB_Qeqcl23check_structs_as_arraysTL0__ELb0EEEvOT1_OT2_OT3_T4_ENKUlTnmvE_clILm0EEEDav:
 3129|  3.45k|                     [&]<size_t I>() {
 3130|  3.45k|                        static constexpr auto TargetKey = get<I>(reflect<T>::keys);
 3131|  3.45k|                        static constexpr auto Length = TargetKey.size();
 3132|  3.45k|                        if ((Length == n) && compare<Length>(TargetKey.data(), key.data())) [[likely]] {
  ------------------
  |  Branch (3132:29): [True: 3.44k, False: 5]
  |  Branch (3132:46): [True: 3.44k, False: 0]
  ------------------
 3133|       |                           // An `else` branch rather than an early return, so a skipped field's reader is
 3134|       |                           // never instantiated -- see `skipped_by_meta`.
 3135|       |                           if constexpr (skipped_by_meta<T, I, operation::parse>) {
 3136|       |                              skip_value<BEVE>::op<Opts>(ctx, it, end);
 3137|       |                           }
 3138|  3.44k|                           else {
 3139|       |                              // Check for null value skipping on read
 3140|       |                              if constexpr (check_skip_null_members_on_read(Opts)) {
 3141|       |                                 if (invalid_end(ctx, it, end)) {
 3142|       |                                    return;
 3143|       |                                 }
 3144|       |                                 if (uint8_t(*it) == tag::null) {
 3145|       |                                    ++it; // Skip the null tag
 3146|       |                                    return;
 3147|       |                                 }
 3148|       |                              }
 3149|       |
 3150|  3.44k|                              if constexpr (reflectable<T>) {
 3151|  3.44k|                                 parse<BEVE>::op<Opts>(get_member(value, get<I>(to_tie(value))), ctx, it, end);
 3152|       |                              }
 3153|       |                              else {
 3154|       |                                 parse<BEVE>::op<Opts>(get_member(value, get<I>(reflect<T>::values)), ctx, it, end);
 3155|       |                              }
 3156|  3.44k|                           }
 3157|  3.44k|                        }
 3158|      5|                        else {
 3159|      5|                           if constexpr (Opts.error_on_unknown_keys) {
 3160|      5|                              ctx.error = error_code::unknown_key;
 3161|      5|                              return;
 3162|       |                           }
 3163|       |                           else {
 3164|       |                              skip_value<BEVE>::op<Opts>(ctx, it, end);
 3165|       |                              if (bool(ctx.error)) [[unlikely]]
 3166|       |                                 return;
 3167|       |                           }
 3168|      5|                        }
 3169|  3.45k|                     },
_ZN3glz5parseILj1EE2opITnDaXtlNS_4optsELj1ELb0ELb0ELb1ELb1EEERiTkNS_10is_contextERNS_7contextERPKcS8_Qntcl15check_no_headerT_EEEvOT0_OT1_OT2_T3_:
   57|  3.44k|      {
   58|       |         if constexpr (const_value_v<T>) {
   59|       |            if constexpr (check_error_on_const_read(Opts)) {
   60|       |               ctx.error = error_code::attempt_const_read;
   61|       |            }
   62|       |            else {
   63|       |               // do not read anything into the const value
   64|       |               skip_value<BEVE>::op<Opts>(std::forward<Ctx>(ctx), std::forward<It0>(it), end);
   65|       |            }
   66|       |         }
   67|  3.44k|         else {
   68|  3.44k|            using V = std::remove_cvref_t<T>;
   69|  3.44k|            from<BEVE, V>::template op<Opts>(std::forward<T>(value), std::forward<Ctx>(ctx), std::forward<It0>(it),
   70|  3.44k|                                             end);
   71|  3.44k|         }
   72|  3.44k|      }
_ZN3glz4fromILj1EiE2opITnDaXtlNS_4optsELj1ELb0ELb0ELb1ELb1EEERiTkNS_10is_contextERNS_7contextERPKcS8_Qntcl15check_no_headerTL0__EEEvOT0_OT1_OT2_T3_:
  347|  3.44k|      {
  348|  3.44k|         if (invalid_end(ctx, it, end)) {
  ------------------
  |  Branch (348:14): [True: 5, False: 3.44k]
  ------------------
  349|      5|            return;
  350|      5|         }
  351|  3.44k|         const auto tag = uint8_t(*it);
  352|  3.44k|         ++it;
  353|  3.44k|         op<no_header_on<Opts>()>(value, tag, ctx, it, end);
  354|  3.44k|      }
_ZN3glz4fromILj1EiE2opITnDaXtlNS_4optsELj1ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj8EEERiTkNS_10is_contextERNS_7contextERPKcS8_Qcl15check_no_headerTL0__EEEvOT0_hOT1_OT2_T3_:
  221|  3.44k|      {
  222|  3.44k|         if (invalid_end(ctx, it, end)) {
  ------------------
  |  Branch (222:14): [True: 28, False: 3.41k]
  ------------------
  223|     28|            return;
  224|     28|         }
  225|       |
  226|  3.41k|         using V = std::decay_t<decltype(value)>;
  227|       |
  228|  3.41k|         constexpr auto is_volatile = std::is_volatile_v<std::remove_reference_t<decltype(value)>>;
  229|       |
  230|  3.41k|         if (tag != header) {
  ------------------
  |  Branch (230:14): [True: 3.10k, False: 315]
  ------------------
  231|  3.10k|            if constexpr (check_allow_conversions(Opts)) {
  232|  3.10k|               if constexpr (num_t<T>) {
  233|  3.10k|                  if ((tag & 0b00000111) != tag::number) {
  ------------------
  |  Branch (233:23): [True: 18, False: 3.08k]
  ------------------
  234|     18|                     ctx.error = error_code::syntax_error;
  235|     18|                     return;
  236|     18|                  }
  237|       |
  238|  3.08k|                  auto decode = [&](auto&& i) {
  239|  3.08k|                     if (size_t(end - it) < sizeof(i)) [[unlikely]] {
  240|  3.08k|                        ctx.error = error_code::unexpected_end;
  241|  3.08k|                        return;
  242|  3.08k|                     }
  243|  3.08k|                     using I = std::decay_t<decltype(i)>;
  244|  3.08k|                     std::memcpy(&i, it, sizeof(I));
  245|  3.08k|                     if constexpr (std::endian::native == std::endian::big && sizeof(I) > 1) {
  246|  3.08k|                        byteswap_le(i);
  247|  3.08k|                     }
  248|  3.08k|                     value = static_cast<V>(i);
  249|  3.08k|                     it += sizeof(i);
  250|  3.08k|                  };
  251|       |
  252|  3.08k|                  switch (tag) {
  253|      5|                  case tag::f32: {
  ------------------
  |  Branch (253:19): [True: 5, False: 3.07k]
  ------------------
  254|      5|                     if constexpr (std::integral<V>) {
  255|       |                        // We do not allow cross conversions from floats to integral types
  256|      5|                        ctx.error = error_code::syntax_error;
  257|       |                     }
  258|       |                     else {
  259|       |                        static_assert(sizeof(float) == 4);
  260|       |                        // TODO: use float32_t in C++23
  261|       |                        decode(float{});
  262|       |                     }
  263|      5|                     return;
  264|      0|                  }
  265|      3|                  case tag::f64: {
  ------------------
  |  Branch (265:19): [True: 3, False: 3.07k]
  ------------------
  266|      3|                     if constexpr (std::integral<V>) {
  267|       |                        // We do not allow cross conversions from floats to integral types
  268|      3|                        ctx.error = error_code::syntax_error;
  269|       |                     }
  270|       |                     else {
  271|       |                        static_assert(sizeof(double) == 8);
  272|       |                        // TODO: use float64_t in C++23
  273|       |                        decode(double{});
  274|       |                     }
  275|      3|                     return;
  276|      0|                  }
  277|    514|                  case tag::i8: {
  ------------------
  |  Branch (277:19): [True: 514, False: 2.56k]
  ------------------
  278|    514|                     decode(int8_t{});
  279|    514|                     return;
  280|      0|                  }
  281|    201|                  case tag::i16: {
  ------------------
  |  Branch (281:19): [True: 201, False: 2.88k]
  ------------------
  282|    201|                     decode(int16_t{});
  283|    201|                     return;
  284|      0|                  }
  285|      0|                  case tag::i32: {
  ------------------
  |  Branch (285:19): [True: 0, False: 3.08k]
  ------------------
  286|      0|                     decode(int32_t{});
  287|      0|                     return;
  288|      0|                  }
  289|    229|                  case tag::i64: {
  ------------------
  |  Branch (289:19): [True: 229, False: 2.85k]
  ------------------
  290|    229|                     decode(int64_t{});
  291|    229|                     return;
  292|      0|                  }
  293|    328|                  case tag::u8: {
  ------------------
  |  Branch (293:19): [True: 328, False: 2.75k]
  ------------------
  294|    328|                     decode(uint8_t{});
  295|    328|                     return;
  296|      0|                  }
  297|    211|                  case tag::u16: {
  ------------------
  |  Branch (297:19): [True: 211, False: 2.87k]
  ------------------
  298|    211|                     decode(uint16_t{});
  299|    211|                     return;
  300|      0|                  }
  301|    841|                  case tag::u32: {
  ------------------
  |  Branch (301:19): [True: 841, False: 2.24k]
  ------------------
  302|    841|                     decode(uint32_t{});
  303|    841|                     return;
  304|      0|                  }
  305|    747|                  case tag::u64: {
  ------------------
  |  Branch (305:19): [True: 747, False: 2.33k]
  ------------------
  306|    747|                     decode(uint64_t{});
  307|    747|                     return;
  308|      0|                  }
  309|      3|                  default: {
  ------------------
  |  Branch (309:19): [True: 3, False: 3.07k]
  ------------------
  310|      3|                     ctx.error = error_code::syntax_error;
  311|      3|                     return;
  312|      0|                  }
  313|  3.08k|                  }
  314|  3.08k|               }
  315|       |            }
  316|       |            else {
  317|       |               ctx.error = error_code::syntax_error;
  318|       |               return;
  319|       |            }
  320|  3.10k|         }
  321|       |
  322|  3.41k|         if (size_t(end - it) < sizeof(V)) [[unlikely]] {
  ------------------
  |  Branch (322:14): [True: 5, False: 3.41k]
  ------------------
  323|      5|            ctx.error = error_code::unexpected_end;
  324|      5|            return;
  325|      5|         }
  326|       |
  327|       |         if constexpr (is_volatile) {
  328|       |            V temp;
  329|       |            std::memcpy(&temp, it, sizeof(V));
  330|       |            if constexpr (std::endian::native == std::endian::big && sizeof(V) > 1) {
  331|       |               byteswap_le(temp);
  332|       |            }
  333|       |            value = temp;
  334|       |         }
  335|  3.41k|         else {
  336|  3.41k|            std::memcpy(&value, it, sizeof(V));
  337|       |            if constexpr (std::endian::native == std::endian::big && sizeof(V) > 1) {
  338|       |               byteswap_le(value);
  339|       |            }
  340|  3.41k|         }
  341|  3.41k|         it += sizeof(V);
  342|  3.41k|      }
_ZZN3glz4fromILj1EiE2opITnDaXtlNS_4optsELj1ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj8EEERiTkNS_10is_contextERNS_7contextERPKcS8_Qcl15check_no_headerTL0__EEEvOT0_hOT1_OT2_T3_ENKUlOT_E_clIaEEDaSI_:
  238|    514|                  auto decode = [&](auto&& i) {
  239|    514|                     if (size_t(end - it) < sizeof(i)) [[unlikely]] {
  ------------------
  |  Branch (239:26): [True: 0, False: 514]
  ------------------
  240|      0|                        ctx.error = error_code::unexpected_end;
  241|      0|                        return;
  242|      0|                     }
  243|    514|                     using I = std::decay_t<decltype(i)>;
  244|    514|                     std::memcpy(&i, it, sizeof(I));
  245|       |                     if constexpr (std::endian::native == std::endian::big && sizeof(I) > 1) {
  246|       |                        byteswap_le(i);
  247|       |                     }
  248|    514|                     value = static_cast<V>(i);
  249|    514|                     it += sizeof(i);
  250|    514|                  };
_ZZN3glz4fromILj1EiE2opITnDaXtlNS_4optsELj1ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj8EEERiTkNS_10is_contextERNS_7contextERPKcS8_Qcl15check_no_headerTL0__EEEvOT0_hOT1_OT2_T3_ENKUlOT_E_clIsEEDaSI_:
  238|    201|                  auto decode = [&](auto&& i) {
  239|    201|                     if (size_t(end - it) < sizeof(i)) [[unlikely]] {
  ------------------
  |  Branch (239:26): [True: 3, False: 198]
  ------------------
  240|      3|                        ctx.error = error_code::unexpected_end;
  241|      3|                        return;
  242|      3|                     }
  243|    198|                     using I = std::decay_t<decltype(i)>;
  244|    198|                     std::memcpy(&i, it, sizeof(I));
  245|       |                     if constexpr (std::endian::native == std::endian::big && sizeof(I) > 1) {
  246|       |                        byteswap_le(i);
  247|       |                     }
  248|    198|                     value = static_cast<V>(i);
  249|    198|                     it += sizeof(i);
  250|    198|                  };
_ZZN3glz4fromILj1EiE2opITnDaXtlNS_4optsELj1ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj8EEERiTkNS_10is_contextERNS_7contextERPKcS8_Qcl15check_no_headerTL0__EEEvOT0_hOT1_OT2_T3_ENKUlOT_E_clIlEEDaSI_:
  238|    229|                  auto decode = [&](auto&& i) {
  239|    229|                     if (size_t(end - it) < sizeof(i)) [[unlikely]] {
  ------------------
  |  Branch (239:26): [True: 9, False: 220]
  ------------------
  240|      9|                        ctx.error = error_code::unexpected_end;
  241|      9|                        return;
  242|      9|                     }
  243|    220|                     using I = std::decay_t<decltype(i)>;
  244|    220|                     std::memcpy(&i, it, sizeof(I));
  245|       |                     if constexpr (std::endian::native == std::endian::big && sizeof(I) > 1) {
  246|       |                        byteswap_le(i);
  247|       |                     }
  248|    220|                     value = static_cast<V>(i);
  249|    220|                     it += sizeof(i);
  250|    220|                  };
_ZZN3glz4fromILj1EiE2opITnDaXtlNS_4optsELj1ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj8EEERiTkNS_10is_contextERNS_7contextERPKcS8_Qcl15check_no_headerTL0__EEEvOT0_hOT1_OT2_T3_ENKUlOT_E_clIhEEDaSI_:
  238|    328|                  auto decode = [&](auto&& i) {
  239|    328|                     if (size_t(end - it) < sizeof(i)) [[unlikely]] {
  ------------------
  |  Branch (239:26): [True: 0, False: 328]
  ------------------
  240|      0|                        ctx.error = error_code::unexpected_end;
  241|      0|                        return;
  242|      0|                     }
  243|    328|                     using I = std::decay_t<decltype(i)>;
  244|    328|                     std::memcpy(&i, it, sizeof(I));
  245|       |                     if constexpr (std::endian::native == std::endian::big && sizeof(I) > 1) {
  246|       |                        byteswap_le(i);
  247|       |                     }
  248|    328|                     value = static_cast<V>(i);
  249|    328|                     it += sizeof(i);
  250|    328|                  };
_ZZN3glz4fromILj1EiE2opITnDaXtlNS_4optsELj1ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj8EEERiTkNS_10is_contextERNS_7contextERPKcS8_Qcl15check_no_headerTL0__EEEvOT0_hOT1_OT2_T3_ENKUlOT_E_clItEEDaSI_:
  238|    211|                  auto decode = [&](auto&& i) {
  239|    211|                     if (size_t(end - it) < sizeof(i)) [[unlikely]] {
  ------------------
  |  Branch (239:26): [True: 3, False: 208]
  ------------------
  240|      3|                        ctx.error = error_code::unexpected_end;
  241|      3|                        return;
  242|      3|                     }
  243|    208|                     using I = std::decay_t<decltype(i)>;
  244|    208|                     std::memcpy(&i, it, sizeof(I));
  245|       |                     if constexpr (std::endian::native == std::endian::big && sizeof(I) > 1) {
  246|       |                        byteswap_le(i);
  247|       |                     }
  248|    208|                     value = static_cast<V>(i);
  249|    208|                     it += sizeof(i);
  250|    208|                  };
_ZZN3glz4fromILj1EiE2opITnDaXtlNS_4optsELj1ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj8EEERiTkNS_10is_contextERNS_7contextERPKcS8_Qcl15check_no_headerTL0__EEEvOT0_hOT1_OT2_T3_ENKUlOT_E_clIjEEDaSI_:
  238|    841|                  auto decode = [&](auto&& i) {
  239|    841|                     if (size_t(end - it) < sizeof(i)) [[unlikely]] {
  ------------------
  |  Branch (239:26): [True: 7, False: 834]
  ------------------
  240|      7|                        ctx.error = error_code::unexpected_end;
  241|      7|                        return;
  242|      7|                     }
  243|    834|                     using I = std::decay_t<decltype(i)>;
  244|    834|                     std::memcpy(&i, it, sizeof(I));
  245|       |                     if constexpr (std::endian::native == std::endian::big && sizeof(I) > 1) {
  246|       |                        byteswap_le(i);
  247|       |                     }
  248|    834|                     value = static_cast<V>(i);
  249|    834|                     it += sizeof(i);
  250|    834|                  };
_ZZN3glz4fromILj1EiE2opITnDaXtlNS_4optsELj1ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj8EEERiTkNS_10is_contextERNS_7contextERPKcS8_Qcl15check_no_headerTL0__EEEvOT0_hOT1_OT2_T3_ENKUlOT_E_clImEEDaSI_:
  238|    747|                  auto decode = [&](auto&& i) {
  239|    747|                     if (size_t(end - it) < sizeof(i)) [[unlikely]] {
  ------------------
  |  Branch (239:26): [True: 9, False: 738]
  ------------------
  240|      9|                        ctx.error = error_code::unexpected_end;
  241|      9|                        return;
  242|      9|                     }
  243|    738|                     using I = std::decay_t<decltype(i)>;
  244|    738|                     std::memcpy(&i, it, sizeof(I));
  245|       |                     if constexpr (std::endian::native == std::endian::big && sizeof(I) > 1) {
  246|       |                        byteswap_le(i);
  247|       |                     }
  248|    738|                     value = static_cast<V>(i);
  249|    738|                     it += sizeof(i);
  250|    738|                  };
_ZZN3glz4fromILj1E9my_structE2opITnDaXtlNS_4optsELj1ELb0ELb0ELb1ELb1EEETnNS_14string_literalEXtlNS5_ILm1EEEEERS1_TkNS_10is_contextERNS_7contextERPKcSB_Qeqcl23check_structs_as_arraysTL0__ELb0EEEvOT1_OT2_OT3_T4_ENKUlTnmvE_clILm1EEEDav:
 3129|  3.10k|                     [&]<size_t I>() {
 3130|  3.10k|                        static constexpr auto TargetKey = get<I>(reflect<T>::keys);
 3131|  3.10k|                        static constexpr auto Length = TargetKey.size();
 3132|  3.10k|                        if ((Length == n) && compare<Length>(TargetKey.data(), key.data())) [[likely]] {
  ------------------
  |  Branch (3132:29): [True: 3.09k, False: 7]
  |  Branch (3132:46): [True: 3.09k, False: 0]
  ------------------
 3133|       |                           // An `else` branch rather than an early return, so a skipped field's reader is
 3134|       |                           // never instantiated -- see `skipped_by_meta`.
 3135|       |                           if constexpr (skipped_by_meta<T, I, operation::parse>) {
 3136|       |                              skip_value<BEVE>::op<Opts>(ctx, it, end);
 3137|       |                           }
 3138|  3.09k|                           else {
 3139|       |                              // Check for null value skipping on read
 3140|       |                              if constexpr (check_skip_null_members_on_read(Opts)) {
 3141|       |                                 if (invalid_end(ctx, it, end)) {
 3142|       |                                    return;
 3143|       |                                 }
 3144|       |                                 if (uint8_t(*it) == tag::null) {
 3145|       |                                    ++it; // Skip the null tag
 3146|       |                                    return;
 3147|       |                                 }
 3148|       |                              }
 3149|       |
 3150|  3.09k|                              if constexpr (reflectable<T>) {
 3151|  3.09k|                                 parse<BEVE>::op<Opts>(get_member(value, get<I>(to_tie(value))), ctx, it, end);
 3152|       |                              }
 3153|       |                              else {
 3154|       |                                 parse<BEVE>::op<Opts>(get_member(value, get<I>(reflect<T>::values)), ctx, it, end);
 3155|       |                              }
 3156|  3.09k|                           }
 3157|  3.09k|                        }
 3158|      7|                        else {
 3159|      7|                           if constexpr (Opts.error_on_unknown_keys) {
 3160|      7|                              ctx.error = error_code::unknown_key;
 3161|      7|                              return;
 3162|       |                           }
 3163|       |                           else {
 3164|       |                              skip_value<BEVE>::op<Opts>(ctx, it, end);
 3165|       |                              if (bool(ctx.error)) [[unlikely]]
 3166|       |                                 return;
 3167|       |                           }
 3168|      7|                        }
 3169|  3.10k|                     },
_ZN3glz5parseILj1EE2opITnDaXtlNS_4optsELj1ELb0ELb0ELb1ELb1EEERdTkNS_10is_contextERNS_7contextERPKcS8_Qntcl15check_no_headerT_EEEvOT0_OT1_OT2_T3_:
   57|  3.09k|      {
   58|       |         if constexpr (const_value_v<T>) {
   59|       |            if constexpr (check_error_on_const_read(Opts)) {
   60|       |               ctx.error = error_code::attempt_const_read;
   61|       |            }
   62|       |            else {
   63|       |               // do not read anything into the const value
   64|       |               skip_value<BEVE>::op<Opts>(std::forward<Ctx>(ctx), std::forward<It0>(it), end);
   65|       |            }
   66|       |         }
   67|  3.09k|         else {
   68|  3.09k|            using V = std::remove_cvref_t<T>;
   69|  3.09k|            from<BEVE, V>::template op<Opts>(std::forward<T>(value), std::forward<Ctx>(ctx), std::forward<It0>(it),
   70|  3.09k|                                             end);
   71|  3.09k|         }
   72|  3.09k|      }
_ZN3glz4fromILj1EdE2opITnDaXtlNS_4optsELj1ELb0ELb0ELb1ELb1EEERdTkNS_10is_contextERNS_7contextERPKcS8_Qntcl15check_no_headerTL0__EEEvOT0_OT1_OT2_T3_:
  347|  3.09k|      {
  348|  3.09k|         if (invalid_end(ctx, it, end)) {
  ------------------
  |  Branch (348:14): [True: 5, False: 3.08k]
  ------------------
  349|      5|            return;
  350|      5|         }
  351|  3.08k|         const auto tag = uint8_t(*it);
  352|  3.08k|         ++it;
  353|  3.08k|         op<no_header_on<Opts>()>(value, tag, ctx, it, end);
  354|  3.08k|      }
_ZN3glz4fromILj1EdE2opITnDaXtlNS_4optsELj1ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj8EEERdTkNS_10is_contextERNS_7contextERPKcS8_Qcl15check_no_headerTL0__EEEvOT0_hOT1_OT2_T3_:
  221|  3.08k|      {
  222|  3.08k|         if (invalid_end(ctx, it, end)) {
  ------------------
  |  Branch (222:14): [True: 31, False: 3.05k]
  ------------------
  223|     31|            return;
  224|     31|         }
  225|       |
  226|  3.05k|         using V = std::decay_t<decltype(value)>;
  227|       |
  228|  3.05k|         constexpr auto is_volatile = std::is_volatile_v<std::remove_reference_t<decltype(value)>>;
  229|       |
  230|  3.05k|         if (tag != header) {
  ------------------
  |  Branch (230:14): [True: 2.85k, False: 199]
  ------------------
  231|  2.85k|            if constexpr (check_allow_conversions(Opts)) {
  232|  2.85k|               if constexpr (num_t<T>) {
  233|  2.85k|                  if ((tag & 0b00000111) != tag::number) {
  ------------------
  |  Branch (233:23): [True: 43, False: 2.81k]
  ------------------
  234|     43|                     ctx.error = error_code::syntax_error;
  235|     43|                     return;
  236|     43|                  }
  237|       |
  238|  2.81k|                  auto decode = [&](auto&& i) {
  239|  2.81k|                     if (size_t(end - it) < sizeof(i)) [[unlikely]] {
  240|  2.81k|                        ctx.error = error_code::unexpected_end;
  241|  2.81k|                        return;
  242|  2.81k|                     }
  243|  2.81k|                     using I = std::decay_t<decltype(i)>;
  244|  2.81k|                     std::memcpy(&i, it, sizeof(I));
  245|  2.81k|                     if constexpr (std::endian::native == std::endian::big && sizeof(I) > 1) {
  246|  2.81k|                        byteswap_le(i);
  247|  2.81k|                     }
  248|  2.81k|                     value = static_cast<V>(i);
  249|  2.81k|                     it += sizeof(i);
  250|  2.81k|                  };
  251|       |
  252|  2.81k|                  switch (tag) {
  253|    301|                  case tag::f32: {
  ------------------
  |  Branch (253:19): [True: 301, False: 2.51k]
  ------------------
  254|       |                     if constexpr (std::integral<V>) {
  255|       |                        // We do not allow cross conversions from floats to integral types
  256|       |                        ctx.error = error_code::syntax_error;
  257|       |                     }
  258|    301|                     else {
  259|    301|                        static_assert(sizeof(float) == 4);
  260|       |                        // TODO: use float32_t in C++23
  261|    301|                        decode(float{});
  262|    301|                     }
  263|    301|                     return;
  264|      0|                  }
  265|      0|                  case tag::f64: {
  ------------------
  |  Branch (265:19): [True: 0, False: 2.81k]
  ------------------
  266|       |                     if constexpr (std::integral<V>) {
  267|       |                        // We do not allow cross conversions from floats to integral types
  268|       |                        ctx.error = error_code::syntax_error;
  269|       |                     }
  270|      0|                     else {
  271|      0|                        static_assert(sizeof(double) == 8);
  272|       |                        // TODO: use float64_t in C++23
  273|      0|                        decode(double{});
  274|      0|                     }
  275|      0|                     return;
  276|      0|                  }
  277|    417|                  case tag::i8: {
  ------------------
  |  Branch (277:19): [True: 417, False: 2.39k]
  ------------------
  278|    417|                     decode(int8_t{});
  279|    417|                     return;
  280|      0|                  }
  281|    239|                  case tag::i16: {
  ------------------
  |  Branch (281:19): [True: 239, False: 2.57k]
  ------------------
  282|    239|                     decode(int16_t{});
  283|    239|                     return;
  284|      0|                  }
  285|    213|                  case tag::i32: {
  ------------------
  |  Branch (285:19): [True: 213, False: 2.60k]
  ------------------
  286|    213|                     decode(int32_t{});
  287|    213|                     return;
  288|      0|                  }
  289|    263|                  case tag::i64: {
  ------------------
  |  Branch (289:19): [True: 263, False: 2.55k]
  ------------------
  290|    263|                     decode(int64_t{});
  291|    263|                     return;
  292|      0|                  }
  293|    355|                  case tag::u8: {
  ------------------
  |  Branch (293:19): [True: 355, False: 2.46k]
  ------------------
  294|    355|                     decode(uint8_t{});
  295|    355|                     return;
  296|      0|                  }
  297|    293|                  case tag::u16: {
  ------------------
  |  Branch (297:19): [True: 293, False: 2.52k]
  ------------------
  298|    293|                     decode(uint16_t{});
  299|    293|                     return;
  300|      0|                  }
  301|    291|                  case tag::u32: {
  ------------------
  |  Branch (301:19): [True: 291, False: 2.52k]
  ------------------
  302|    291|                     decode(uint32_t{});
  303|    291|                     return;
  304|      0|                  }
  305|    439|                  case tag::u64: {
  ------------------
  |  Branch (305:19): [True: 439, False: 2.37k]
  ------------------
  306|    439|                     decode(uint64_t{});
  307|    439|                     return;
  308|      0|                  }
  309|      5|                  default: {
  ------------------
  |  Branch (309:19): [True: 5, False: 2.81k]
  ------------------
  310|      5|                     ctx.error = error_code::syntax_error;
  311|      5|                     return;
  312|      0|                  }
  313|  2.81k|                  }
  314|  2.81k|               }
  315|       |            }
  316|       |            else {
  317|       |               ctx.error = error_code::syntax_error;
  318|       |               return;
  319|       |            }
  320|  2.85k|         }
  321|       |
  322|  3.05k|         if (size_t(end - it) < sizeof(V)) [[unlikely]] {
  ------------------
  |  Branch (322:14): [True: 5, False: 3.05k]
  ------------------
  323|      5|            ctx.error = error_code::unexpected_end;
  324|      5|            return;
  325|      5|         }
  326|       |
  327|       |         if constexpr (is_volatile) {
  328|       |            V temp;
  329|       |            std::memcpy(&temp, it, sizeof(V));
  330|       |            if constexpr (std::endian::native == std::endian::big && sizeof(V) > 1) {
  331|       |               byteswap_le(temp);
  332|       |            }
  333|       |            value = temp;
  334|       |         }
  335|  3.05k|         else {
  336|  3.05k|            std::memcpy(&value, it, sizeof(V));
  337|       |            if constexpr (std::endian::native == std::endian::big && sizeof(V) > 1) {
  338|       |               byteswap_le(value);
  339|       |            }
  340|  3.05k|         }
  341|  3.05k|         it += sizeof(V);
  342|  3.05k|      }
_ZZN3glz4fromILj1EdE2opITnDaXtlNS_4optsELj1ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj8EEERdTkNS_10is_contextERNS_7contextERPKcS8_Qcl15check_no_headerTL0__EEEvOT0_hOT1_OT2_T3_ENKUlOT_E_clIfEEDaSI_:
  238|    301|                  auto decode = [&](auto&& i) {
  239|    301|                     if (size_t(end - it) < sizeof(i)) [[unlikely]] {
  ------------------
  |  Branch (239:26): [True: 7, False: 294]
  ------------------
  240|      7|                        ctx.error = error_code::unexpected_end;
  241|      7|                        return;
  242|      7|                     }
  243|    294|                     using I = std::decay_t<decltype(i)>;
  244|    294|                     std::memcpy(&i, it, sizeof(I));
  245|       |                     if constexpr (std::endian::native == std::endian::big && sizeof(I) > 1) {
  246|       |                        byteswap_le(i);
  247|       |                     }
  248|    294|                     value = static_cast<V>(i);
  249|    294|                     it += sizeof(i);
  250|    294|                  };
_ZZN3glz4fromILj1EdE2opITnDaXtlNS_4optsELj1ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj8EEERdTkNS_10is_contextERNS_7contextERPKcS8_Qcl15check_no_headerTL0__EEEvOT0_hOT1_OT2_T3_ENKUlOT_E_clIaEEDaSI_:
  238|    417|                  auto decode = [&](auto&& i) {
  239|    417|                     if (size_t(end - it) < sizeof(i)) [[unlikely]] {
  ------------------
  |  Branch (239:26): [True: 0, False: 417]
  ------------------
  240|      0|                        ctx.error = error_code::unexpected_end;
  241|      0|                        return;
  242|      0|                     }
  243|    417|                     using I = std::decay_t<decltype(i)>;
  244|    417|                     std::memcpy(&i, it, sizeof(I));
  245|       |                     if constexpr (std::endian::native == std::endian::big && sizeof(I) > 1) {
  246|       |                        byteswap_le(i);
  247|       |                     }
  248|    417|                     value = static_cast<V>(i);
  249|    417|                     it += sizeof(i);
  250|    417|                  };
_ZZN3glz4fromILj1EdE2opITnDaXtlNS_4optsELj1ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj8EEERdTkNS_10is_contextERNS_7contextERPKcS8_Qcl15check_no_headerTL0__EEEvOT0_hOT1_OT2_T3_ENKUlOT_E_clIsEEDaSI_:
  238|    239|                  auto decode = [&](auto&& i) {
  239|    239|                     if (size_t(end - it) < sizeof(i)) [[unlikely]] {
  ------------------
  |  Branch (239:26): [True: 3, False: 236]
  ------------------
  240|      3|                        ctx.error = error_code::unexpected_end;
  241|      3|                        return;
  242|      3|                     }
  243|    236|                     using I = std::decay_t<decltype(i)>;
  244|    236|                     std::memcpy(&i, it, sizeof(I));
  245|       |                     if constexpr (std::endian::native == std::endian::big && sizeof(I) > 1) {
  246|       |                        byteswap_le(i);
  247|       |                     }
  248|    236|                     value = static_cast<V>(i);
  249|    236|                     it += sizeof(i);
  250|    236|                  };
_ZZN3glz4fromILj1EdE2opITnDaXtlNS_4optsELj1ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj8EEERdTkNS_10is_contextERNS_7contextERPKcS8_Qcl15check_no_headerTL0__EEEvOT0_hOT1_OT2_T3_ENKUlOT_E_clIiEEDaSI_:
  238|    213|                  auto decode = [&](auto&& i) {
  239|    213|                     if (size_t(end - it) < sizeof(i)) [[unlikely]] {
  ------------------
  |  Branch (239:26): [True: 7, False: 206]
  ------------------
  240|      7|                        ctx.error = error_code::unexpected_end;
  241|      7|                        return;
  242|      7|                     }
  243|    206|                     using I = std::decay_t<decltype(i)>;
  244|    206|                     std::memcpy(&i, it, sizeof(I));
  245|       |                     if constexpr (std::endian::native == std::endian::big && sizeof(I) > 1) {
  246|       |                        byteswap_le(i);
  247|       |                     }
  248|    206|                     value = static_cast<V>(i);
  249|    206|                     it += sizeof(i);
  250|    206|                  };
_ZZN3glz4fromILj1EdE2opITnDaXtlNS_4optsELj1ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj8EEERdTkNS_10is_contextERNS_7contextERPKcS8_Qcl15check_no_headerTL0__EEEvOT0_hOT1_OT2_T3_ENKUlOT_E_clIlEEDaSI_:
  238|    263|                  auto decode = [&](auto&& i) {
  239|    263|                     if (size_t(end - it) < sizeof(i)) [[unlikely]] {
  ------------------
  |  Branch (239:26): [True: 5, False: 258]
  ------------------
  240|      5|                        ctx.error = error_code::unexpected_end;
  241|      5|                        return;
  242|      5|                     }
  243|    258|                     using I = std::decay_t<decltype(i)>;
  244|    258|                     std::memcpy(&i, it, sizeof(I));
  245|       |                     if constexpr (std::endian::native == std::endian::big && sizeof(I) > 1) {
  246|       |                        byteswap_le(i);
  247|       |                     }
  248|    258|                     value = static_cast<V>(i);
  249|    258|                     it += sizeof(i);
  250|    258|                  };
_ZZN3glz4fromILj1EdE2opITnDaXtlNS_4optsELj1ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj8EEERdTkNS_10is_contextERNS_7contextERPKcS8_Qcl15check_no_headerTL0__EEEvOT0_hOT1_OT2_T3_ENKUlOT_E_clIhEEDaSI_:
  238|    355|                  auto decode = [&](auto&& i) {
  239|    355|                     if (size_t(end - it) < sizeof(i)) [[unlikely]] {
  ------------------
  |  Branch (239:26): [True: 0, False: 355]
  ------------------
  240|      0|                        ctx.error = error_code::unexpected_end;
  241|      0|                        return;
  242|      0|                     }
  243|    355|                     using I = std::decay_t<decltype(i)>;
  244|    355|                     std::memcpy(&i, it, sizeof(I));
  245|       |                     if constexpr (std::endian::native == std::endian::big && sizeof(I) > 1) {
  246|       |                        byteswap_le(i);
  247|       |                     }
  248|    355|                     value = static_cast<V>(i);
  249|    355|                     it += sizeof(i);
  250|    355|                  };
_ZZN3glz4fromILj1EdE2opITnDaXtlNS_4optsELj1ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj8EEERdTkNS_10is_contextERNS_7contextERPKcS8_Qcl15check_no_headerTL0__EEEvOT0_hOT1_OT2_T3_ENKUlOT_E_clItEEDaSI_:
  238|    293|                  auto decode = [&](auto&& i) {
  239|    293|                     if (size_t(end - it) < sizeof(i)) [[unlikely]] {
  ------------------
  |  Branch (239:26): [True: 3, False: 290]
  ------------------
  240|      3|                        ctx.error = error_code::unexpected_end;
  241|      3|                        return;
  242|      3|                     }
  243|    290|                     using I = std::decay_t<decltype(i)>;
  244|    290|                     std::memcpy(&i, it, sizeof(I));
  245|       |                     if constexpr (std::endian::native == std::endian::big && sizeof(I) > 1) {
  246|       |                        byteswap_le(i);
  247|       |                     }
  248|    290|                     value = static_cast<V>(i);
  249|    290|                     it += sizeof(i);
  250|    290|                  };
_ZZN3glz4fromILj1EdE2opITnDaXtlNS_4optsELj1ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj8EEERdTkNS_10is_contextERNS_7contextERPKcS8_Qcl15check_no_headerTL0__EEEvOT0_hOT1_OT2_T3_ENKUlOT_E_clIjEEDaSI_:
  238|    291|                  auto decode = [&](auto&& i) {
  239|    291|                     if (size_t(end - it) < sizeof(i)) [[unlikely]] {
  ------------------
  |  Branch (239:26): [True: 8, False: 283]
  ------------------
  240|      8|                        ctx.error = error_code::unexpected_end;
  241|      8|                        return;
  242|      8|                     }
  243|    283|                     using I = std::decay_t<decltype(i)>;
  244|    283|                     std::memcpy(&i, it, sizeof(I));
  245|       |                     if constexpr (std::endian::native == std::endian::big && sizeof(I) > 1) {
  246|       |                        byteswap_le(i);
  247|       |                     }
  248|    283|                     value = static_cast<V>(i);
  249|    283|                     it += sizeof(i);
  250|    283|                  };
_ZZN3glz4fromILj1EdE2opITnDaXtlNS_4optsELj1ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj8EEERdTkNS_10is_contextERNS_7contextERPKcS8_Qcl15check_no_headerTL0__EEEvOT0_hOT1_OT2_T3_ENKUlOT_E_clImEEDaSI_:
  238|    439|                  auto decode = [&](auto&& i) {
  239|    439|                     if (size_t(end - it) < sizeof(i)) [[unlikely]] {
  ------------------
  |  Branch (239:26): [True: 11, False: 428]
  ------------------
  240|     11|                        ctx.error = error_code::unexpected_end;
  241|     11|                        return;
  242|     11|                     }
  243|    428|                     using I = std::decay_t<decltype(i)>;
  244|    428|                     std::memcpy(&i, it, sizeof(I));
  245|       |                     if constexpr (std::endian::native == std::endian::big && sizeof(I) > 1) {
  246|       |                        byteswap_le(i);
  247|       |                     }
  248|    428|                     value = static_cast<V>(i);
  249|    428|                     it += sizeof(i);
  250|    428|                  };
_ZZN3glz4fromILj1E9my_structE2opITnDaXtlNS_4optsELj1ELb0ELb0ELb1ELb1EEETnNS_14string_literalEXtlNS5_ILm1EEEEERS1_TkNS_10is_contextERNS_7contextERPKcSB_Qeqcl23check_structs_as_arraysTL0__ELb0EEEvOT1_OT2_OT3_T4_ENKUlTnmvE_clILm2EEEDav:
 3129|  2.16k|                     [&]<size_t I>() {
 3130|  2.16k|                        static constexpr auto TargetKey = get<I>(reflect<T>::keys);
 3131|  2.16k|                        static constexpr auto Length = TargetKey.size();
 3132|  2.16k|                        if ((Length == n) && compare<Length>(TargetKey.data(), key.data())) [[likely]] {
  ------------------
  |  Branch (3132:29): [True: 2.15k, False: 12]
  |  Branch (3132:46): [True: 2.09k, False: 60]
  ------------------
 3133|       |                           // An `else` branch rather than an early return, so a skipped field's reader is
 3134|       |                           // never instantiated -- see `skipped_by_meta`.
 3135|       |                           if constexpr (skipped_by_meta<T, I, operation::parse>) {
 3136|       |                              skip_value<BEVE>::op<Opts>(ctx, it, end);
 3137|       |                           }
 3138|  2.09k|                           else {
 3139|       |                              // Check for null value skipping on read
 3140|       |                              if constexpr (check_skip_null_members_on_read(Opts)) {
 3141|       |                                 if (invalid_end(ctx, it, end)) {
 3142|       |                                    return;
 3143|       |                                 }
 3144|       |                                 if (uint8_t(*it) == tag::null) {
 3145|       |                                    ++it; // Skip the null tag
 3146|       |                                    return;
 3147|       |                                 }
 3148|       |                              }
 3149|       |
 3150|  2.09k|                              if constexpr (reflectable<T>) {
 3151|  2.09k|                                 parse<BEVE>::op<Opts>(get_member(value, get<I>(to_tie(value))), ctx, it, end);
 3152|       |                              }
 3153|       |                              else {
 3154|       |                                 parse<BEVE>::op<Opts>(get_member(value, get<I>(reflect<T>::values)), ctx, it, end);
 3155|       |                              }
 3156|  2.09k|                           }
 3157|  2.09k|                        }
 3158|     72|                        else {
 3159|     72|                           if constexpr (Opts.error_on_unknown_keys) {
 3160|     72|                              ctx.error = error_code::unknown_key;
 3161|     72|                              return;
 3162|       |                           }
 3163|       |                           else {
 3164|       |                              skip_value<BEVE>::op<Opts>(ctx, it, end);
 3165|       |                              if (bool(ctx.error)) [[unlikely]]
 3166|       |                                 return;
 3167|       |                           }
 3168|     72|                        }
 3169|  2.16k|                     },
_ZN3glz5parseILj1EE2opITnDaXtlNS_4optsELj1ELb0ELb0ELb1ELb1EEERNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEETkNS_10is_contextERNS_7contextERPKcSF_Qntcl15check_no_headerT_EEEvOT0_OT1_OT2_T3_:
   57|  2.09k|      {
   58|       |         if constexpr (const_value_v<T>) {
   59|       |            if constexpr (check_error_on_const_read(Opts)) {
   60|       |               ctx.error = error_code::attempt_const_read;
   61|       |            }
   62|       |            else {
   63|       |               // do not read anything into the const value
   64|       |               skip_value<BEVE>::op<Opts>(std::forward<Ctx>(ctx), std::forward<It0>(it), end);
   65|       |            }
   66|       |         }
   67|  2.09k|         else {
   68|  2.09k|            using V = std::remove_cvref_t<T>;
   69|  2.09k|            from<BEVE, V>::template op<Opts>(std::forward<T>(value), std::forward<Ctx>(ctx), std::forward<It0>(it),
   70|  2.09k|                                             end);
   71|  2.09k|         }
   72|  2.09k|      }
_ZN3glz4fromILj1ENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE2opITnDaXtlNS_4optsELj1ELb0ELb0ELb1ELb1EEERS7_TkNS_10is_contextERNS_7contextERPKcSF_Qntcl15check_no_headerTL0__EEEvOT0_OT1_OT2_T3_:
 1518|  2.09k|      {
 1519|  2.09k|         constexpr uint8_t header = tag::string;
 1520|       |
 1521|  2.09k|         if (invalid_end(ctx, it, end)) {
  ------------------
  |  Branch (1521:14): [True: 3, False: 2.08k]
  ------------------
 1522|      3|            return;
 1523|      3|         }
 1524|  2.08k|         const auto tag = uint8_t(*it);
 1525|  2.08k|         if (tag != header) [[unlikely]] {
  ------------------
  |  Branch (1525:14): [True: 11, False: 2.07k]
  ------------------
 1526|     11|            ctx.error = error_code::syntax_error;
 1527|     11|            return;
 1528|     11|         }
 1529|       |
 1530|  2.07k|         ++it;
 1531|  2.07k|         const auto n = int_from_compressed(ctx, it, end);
 1532|  2.07k|         if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (1532:14): [True: 139, False: 1.93k]
  ------------------
 1533|    139|            return;
 1534|    139|         }
 1535|  1.93k|         if (uint64_t(end - it) < n) [[unlikely]] {
  ------------------
  |  Branch (1535:14): [True: 138, False: 1.79k]
  ------------------
 1536|    138|            ctx.error = error_code::unexpected_end;
 1537|    138|            return;
 1538|    138|         }
 1539|       |         if constexpr (check_max_string_length(Opts) > 0) {
 1540|       |            if (n > check_max_string_length(Opts)) [[unlikely]] {
 1541|       |               ctx.error = error_code::invalid_length;
 1542|       |               return;
 1543|       |            }
 1544|       |         }
 1545|       |         if constexpr (has_runtime_max_string_length<std::decay_t<decltype(ctx)>>) {
 1546|       |            if (ctx.max_string_length > 0 && n > ctx.max_string_length) [[unlikely]] {
 1547|       |               ctx.error = error_code::invalid_length;
 1548|       |               return;
 1549|       |            }
 1550|       |         }
 1551|       |
 1552|  1.79k|         store(value, ctx, it, n);
 1553|  1.79k|         if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (1553:14): [True: 0, False: 1.79k]
  ------------------
 1554|      0|            return;
 1555|      0|         }
 1556|  1.79k|         it += n;
 1557|  1.79k|      }
_ZN3glz4fromILj1ENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE5storeIRS7_TkNS_10is_contextERNS_7contextERPKcEEvOT_OT0_OT1_m:
 1458|  1.79k|      {
 1459|       |         if constexpr (string_view_t<T>) {
 1460|       |            value = {it, n};
 1461|       |         }
 1462|       |         else if constexpr (array_char_t<T>) {
 1463|       |            // Fixed-size std::array<char, N> cannot be resized, so the decoded payload must
 1464|       |            // fit within it. Any trailing bytes are zero-filled to keep the buffer
 1465|       |            // deterministic when a shorter payload is read into a larger array.
 1466|       |            if (n > value.size()) [[unlikely]] {
 1467|       |               ctx.error = error_code::syntax_error;
 1468|       |               return;
 1469|       |            }
 1470|       |            std::memcpy(value.data(), it, n);
 1471|       |            if (n < value.size()) {
 1472|       |               std::memset(value.data() + n, 0, value.size() - n);
 1473|       |            }
 1474|       |         }
 1475|  1.79k|         else {
 1476|  1.79k|            if (exceeds_capacity(value, n, ctx)) [[unlikely]] {
  ------------------
  |  Branch (1476:17): [True: 0, False: 1.79k]
  ------------------
 1477|      0|               return;
 1478|      0|            }
 1479|  1.79k|            value.resize(n);
 1480|  1.79k|            std::memcpy(value.data(), it, n);
 1481|  1.79k|         }
 1482|  1.79k|      }
_ZZN3glz4fromILj1E9my_structE2opITnDaXtlNS_4optsELj1ELb0ELb0ELb1ELb1EEETnNS_14string_literalEXtlNS5_ILm1EEEEERS1_TkNS_10is_contextERNS_7contextERPKcSB_Qeqcl23check_structs_as_arraysTL0__ELb0EEEvOT1_OT2_OT3_T4_ENKUlTnmvE_clILm3EEEDav:
 3129|  4.57k|                     [&]<size_t I>() {
 3130|  4.57k|                        static constexpr auto TargetKey = get<I>(reflect<T>::keys);
 3131|  4.57k|                        static constexpr auto Length = TargetKey.size();
 3132|  4.57k|                        if ((Length == n) && compare<Length>(TargetKey.data(), key.data())) [[likely]] {
  ------------------
  |  Branch (3132:29): [True: 4.57k, False: 3]
  |  Branch (3132:46): [True: 4.52k, False: 51]
  ------------------
 3133|       |                           // An `else` branch rather than an early return, so a skipped field's reader is
 3134|       |                           // never instantiated -- see `skipped_by_meta`.
 3135|       |                           if constexpr (skipped_by_meta<T, I, operation::parse>) {
 3136|       |                              skip_value<BEVE>::op<Opts>(ctx, it, end);
 3137|       |                           }
 3138|  4.52k|                           else {
 3139|       |                              // Check for null value skipping on read
 3140|       |                              if constexpr (check_skip_null_members_on_read(Opts)) {
 3141|       |                                 if (invalid_end(ctx, it, end)) {
 3142|       |                                    return;
 3143|       |                                 }
 3144|       |                                 if (uint8_t(*it) == tag::null) {
 3145|       |                                    ++it; // Skip the null tag
 3146|       |                                    return;
 3147|       |                                 }
 3148|       |                              }
 3149|       |
 3150|  4.52k|                              if constexpr (reflectable<T>) {
 3151|  4.52k|                                 parse<BEVE>::op<Opts>(get_member(value, get<I>(to_tie(value))), ctx, it, end);
 3152|       |                              }
 3153|       |                              else {
 3154|       |                                 parse<BEVE>::op<Opts>(get_member(value, get<I>(reflect<T>::values)), ctx, it, end);
 3155|       |                              }
 3156|  4.52k|                           }
 3157|  4.52k|                        }
 3158|     54|                        else {
 3159|     54|                           if constexpr (Opts.error_on_unknown_keys) {
 3160|     54|                              ctx.error = error_code::unknown_key;
 3161|     54|                              return;
 3162|       |                           }
 3163|       |                           else {
 3164|       |                              skip_value<BEVE>::op<Opts>(ctx, it, end);
 3165|       |                              if (bool(ctx.error)) [[unlikely]]
 3166|       |                                 return;
 3167|       |                           }
 3168|     54|                        }
 3169|  4.57k|                     },
_ZN3glz5parseILj1EE2opITnDaXtlNS_4optsELj1ELb0ELb0ELb1ELb1EEERNSt3__15arrayImLm3EEETkNS_10is_contextERNS_7contextERPKcSB_Qntcl15check_no_headerT_EEEvOT0_OT1_OT2_T3_:
   57|  4.52k|      {
   58|       |         if constexpr (const_value_v<T>) {
   59|       |            if constexpr (check_error_on_const_read(Opts)) {
   60|       |               ctx.error = error_code::attempt_const_read;
   61|       |            }
   62|       |            else {
   63|       |               // do not read anything into the const value
   64|       |               skip_value<BEVE>::op<Opts>(std::forward<Ctx>(ctx), std::forward<It0>(it), end);
   65|       |            }
   66|       |         }
   67|  4.52k|         else {
   68|  4.52k|            using V = std::remove_cvref_t<T>;
   69|  4.52k|            from<BEVE, V>::template op<Opts>(std::forward<T>(value), std::forward<Ctx>(ctx), std::forward<It0>(it),
   70|  4.52k|                                             end);
   71|  4.52k|         }
   72|  4.52k|      }
_ZN3glz4fromILj1ENSt3__15arrayImLm3EEEE2opITnDaXtlNS_4optsELj1ELb0ELb0ELb1ELb1EEERS3_TkNS_10is_contextERNS_7contextERPKcSB_EEvOT0_OT1_OT2_T3_:
 1906|  4.52k|      {
 1907|  4.52k|         using V = range_value_t<std::decay_t<T>>;
 1908|       |
 1909|  4.52k|         if (invalid_end(ctx, it, end)) {
  ------------------
  |  Branch (1909:14): [True: 2, False: 4.51k]
  ------------------
 1910|      2|            return;
 1911|      2|         }
 1912|  4.51k|         const auto tag = uint8_t(*it);
 1913|       |
 1914|       |         if constexpr (boolean_like<V>) {
 1915|       |            constexpr uint8_t type = uint8_t(3) << 3;
 1916|       |            constexpr uint8_t header = tag::typed_array | type;
 1917|       |
 1918|       |            if (tag != header) [[unlikely]] {
 1919|       |               ctx.error = error_code::syntax_error;
 1920|       |               return;
 1921|       |            }
 1922|       |
 1923|       |            ++it;
 1924|       |            std::conditional_t<Opts.partial_read, size_t, const size_t> n = int_from_compressed(ctx, it, end);
 1925|       |            if (bool(ctx.error)) [[unlikely]] {
 1926|       |               return;
 1927|       |            }
 1928|       |
 1929|       |            if constexpr (Opts.partial_read) {
 1930|       |               n = value.size();
 1931|       |            }
 1932|       |
 1933|       |            const auto num_bytes = (n + 7) / 8;
 1934|       |            if (uint64_t(end - it) < num_bytes) [[unlikely]] {
 1935|       |               ctx.error = error_code::invalid_length;
 1936|       |               return;
 1937|       |            }
 1938|       |            // A partial read takes a prefix of the array, so the bits after it are data, not padding
 1939|       |            if constexpr (not Opts.partial_read) {
 1940|       |               if (num_bytes && !packed_bool_padding_is_zero(uint8_t(*(it + (num_bytes - 1))), n)) [[unlikely]] {
 1941|       |                  ctx.error = error_code::syntax_error;
 1942|       |                  return;
 1943|       |               }
 1944|       |            }
 1945|       |            if constexpr (check_max_array_size(Opts) > 0) {
 1946|       |               if (n > check_max_array_size(Opts)) [[unlikely]] {
 1947|       |                  ctx.error = error_code::invalid_length;
 1948|       |                  return;
 1949|       |               }
 1950|       |            }
 1951|       |            if constexpr (has_runtime_max_array_size<std::decay_t<decltype(ctx)>>) {
 1952|       |               if (ctx.max_array_size > 0 && n > ctx.max_array_size) [[unlikely]] {
 1953|       |                  ctx.error = error_code::invalid_length;
 1954|       |                  return;
 1955|       |               }
 1956|       |            }
 1957|       |
 1958|       |            if constexpr (resizable<T>) {
 1959|       |               if (exceeds_capacity(value, n, ctx)) [[unlikely]] {
 1960|       |                  return;
 1961|       |               }
 1962|       |               value.resize(n);
 1963|       |
 1964|       |               if constexpr (check_shrink_to_fit(Opts) && has_shrink_to_fit<T>) {
 1965|       |                  value.shrink_to_fit();
 1966|       |               }
 1967|       |            }
 1968|       |            else {
 1969|       |               if (n > value.size()) {
 1970|       |                  ctx.error = error_code::syntax_error;
 1971|       |                  return;
 1972|       |               }
 1973|       |            }
 1974|       |
 1975|       |            for (size_t byte_i{}, i{}; byte_i < num_bytes; ++byte_i, ++it) {
 1976|       |               if (invalid_end(ctx, it, end)) {
 1977|       |                  return;
 1978|       |               }
 1979|       |               uint8_t byte;
 1980|       |               std::memcpy(&byte, it, 1);
 1981|       |               for (size_t bit_i = 0; bit_i < 8 && i < n; ++bit_i, ++i) {
 1982|       |                  value[i] = byte >> bit_i & uint8_t(1);
 1983|       |               }
 1984|       |            }
 1985|       |         }
 1986|  4.51k|         else if constexpr (beve_num_array_t<V>) {
 1987|       |            // NV is the arithmetic wire type: V for plain numbers, the rep for chrono
 1988|       |            // durations / count-based time points (which are bit-compatible with it).
 1989|  4.51k|            using NV = beve_num_array_value_t<V>;
 1990|  4.51k|            constexpr uint8_t type = std::floating_point<NV> ? 0 : (std::is_signed_v<NV> ? 0b000'01'000 : 0b000'10'000);
  ------------------
  |  Branch (1990:38): [Folded, False: 4.51k]
  |  Branch (1990:69): [Folded, False: 4.51k]
  ------------------
 1991|  4.51k|            constexpr uint8_t header = tag::typed_array | type | (byte_count<NV> << 5);
 1992|       |
 1993|  4.51k|            auto validate_and_resize = [&](size_t n) -> bool {
 1994|  4.51k|               if constexpr (check_max_array_size(Opts) > 0) {
 1995|  4.51k|                  if (n > check_max_array_size(Opts)) [[unlikely]] {
 1996|  4.51k|                     ctx.error = error_code::invalid_length;
 1997|  4.51k|                     return false;
 1998|  4.51k|                  }
 1999|  4.51k|               }
 2000|  4.51k|               if constexpr (has_runtime_max_array_size<std::decay_t<decltype(ctx)>>) {
 2001|  4.51k|                  if (ctx.max_array_size > 0 && n > ctx.max_array_size) [[unlikely]] {
 2002|  4.51k|                     ctx.error = error_code::invalid_length;
 2003|  4.51k|                     return false;
 2004|  4.51k|                  }
 2005|  4.51k|               }
 2006|       |
 2007|  4.51k|               if constexpr (resizable<T>) {
 2008|  4.51k|                  if (exceeds_capacity(value, n, ctx)) [[unlikely]] {
 2009|  4.51k|                     return false;
 2010|  4.51k|                  }
 2011|  4.51k|                  value.resize(n);
 2012|       |
 2013|  4.51k|                  if constexpr (check_shrink_to_fit(Opts) && has_shrink_to_fit<T>) {
 2014|  4.51k|                     value.shrink_to_fit();
 2015|  4.51k|                  }
 2016|  4.51k|               }
 2017|  4.51k|               else {
 2018|  4.51k|                  if (n > value.size()) {
 2019|  4.51k|                     ctx.error = error_code::syntax_error;
 2020|  4.51k|                     return false;
 2021|  4.51k|                  }
 2022|  4.51k|               }
 2023|  4.51k|               return true;
 2024|  4.51k|            };
 2025|       |
 2026|  4.51k|            auto prepare = [&](const size_t element_size) -> size_t {
 2027|  4.51k|               ++it;
 2028|  4.51k|               if (invalid_end(ctx, it, end)) {
 2029|  4.51k|                  return 0;
 2030|  4.51k|               }
 2031|       |
 2032|  4.51k|               std::conditional_t<Opts.partial_read, size_t, const size_t> n = int_from_compressed(ctx, it, end);
 2033|  4.51k|               if (bool(ctx.error)) [[unlikely]] {
 2034|  4.51k|                  return 0;
 2035|  4.51k|               }
 2036|       |
 2037|  4.51k|               if constexpr (Opts.partial_read) {
 2038|  4.51k|                  n = value.size();
 2039|  4.51k|               }
 2040|       |
 2041|  4.51k|               if (typed_array_out_of_bounds(ctx, it, end, n, element_size)) return 0;
 2042|  4.51k|               if (!validate_and_resize(n)) {
 2043|  4.51k|                  return 0;
 2044|  4.51k|               }
 2045|       |
 2046|  4.51k|               return n;
 2047|  4.51k|            };
 2048|       |
 2049|  4.51k|            size_t n = 0;
 2050|       |
 2051|  4.51k|            if (tag == tag::aligned_typed_array) {
  ------------------
  |  Branch (2051:17): [True: 1.94k, False: 2.57k]
  ------------------
 2052|       |               // Aligned typed array: ALIGNED_HEADER | NUMERIC_HEADER | SIZE | PADDING_LENGTH | PADDING | DATA
 2053|  1.94k|               ++it; // skip aligned header byte
 2054|  1.94k|               if (invalid_end(ctx, it, end)) {
  ------------------
  |  Branch (2054:20): [True: 2, False: 1.94k]
  ------------------
 2055|      2|                  return;
 2056|      2|               }
 2057|  1.94k|               const auto numeric_tag = uint8_t(*it);
 2058|       |               // Verify bits 0-2 are typed_array tag
 2059|  1.94k|               if ((numeric_tag & 0b00000'111) != tag::typed_array) [[unlikely]] {
  ------------------
  |  Branch (2059:20): [True: 6, False: 1.93k]
  ------------------
 2060|      6|                  ctx.error = error_code::syntax_error;
 2061|      6|                  return;
 2062|      6|               }
 2063|       |               // Verify it's a numeric type (category 0, 1, or 2, not 3)
 2064|  1.93k|               if (((numeric_tag >> 3) & 0b11) == 3) [[unlikely]] {
  ------------------
  |  Branch (2064:20): [True: 2, False: 1.93k]
  ------------------
 2065|      2|                  ctx.error = error_code::syntax_error;
 2066|      2|                  return;
 2067|      2|               }
 2068|       |
 2069|  1.93k|               if (numeric_tag != header) {
  ------------------
  |  Branch (2069:20): [True: 1.15k, False: 782]
  ------------------
 2070|  1.15k|                  if constexpr (check_allow_conversions(Opts)) {
 2071|  1.15k|                     const uint8_t elem_byte_count = byte_count_lookup[numeric_tag >> 5];
 2072|  1.15k|                     ++it; // skip numeric header
 2073|  1.15k|                     std::conditional_t<Opts.partial_read, size_t, const size_t> count =
 2074|  1.15k|                        int_from_compressed(ctx, it, end);
 2075|  1.15k|                     if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (2075:26): [True: 22, False: 1.12k]
  ------------------
 2076|     22|                        return;
 2077|     22|                     }
 2078|       |                     if constexpr (Opts.partial_read) {
 2079|       |                        count = value.size();
 2080|       |                     }
 2081|       |
 2082|       |                     // Read padding length byte and skip padding
 2083|  1.12k|                     if (invalid_end(ctx, it, end)) {
  ------------------
  |  Branch (2083:26): [True: 62, False: 1.06k]
  ------------------
 2084|     62|                        return;
 2085|     62|                     }
 2086|  1.06k|                     const uint8_t padding = uint8_t(*it);
 2087|  1.06k|                     ++it;
 2088|  1.06k|                     if (padding >= elem_byte_count) [[unlikely]] {
  ------------------
  |  Branch (2088:26): [True: 2, False: 1.06k]
  ------------------
 2089|      2|                        ctx.error = error_code::syntax_error;
 2090|      2|                        return;
 2091|      2|                     }
 2092|  1.06k|                     if (typed_array_out_of_bounds(ctx, it, end, count, elem_byte_count, padding)) return;
  ------------------
  |  Branch (2092:26): [True: 109, False: 955]
  ------------------
 2093|    955|                     it += padding;
 2094|       |
 2095|    955|                     if (!validate_and_resize(count)) {
  ------------------
  |  Branch (2095:26): [True: 65, False: 890]
  ------------------
 2096|     65|                        return;
 2097|     65|                     }
 2098|       |
 2099|    890|                     auto x_it = value.begin();
 2100|  2.62k|                     for (size_t i = 0; i < count; ++i, ++x_it) {
  ------------------
  |  Branch (2100:41): [True: 1.73k, False: 890]
  ------------------
 2101|  1.73k|                        const uint8_t number_tag = tag::number | (numeric_tag & 0b11111000);
 2102|  1.73k|                        parse<BEVE>::op<no_header_on<Opts>()>(*x_it, number_tag, ctx, it, end);
 2103|  1.73k|                     }
 2104|    890|                     return;
 2105|       |                  }
 2106|       |                  else {
 2107|       |                     ctx.error = error_code::syntax_error;
 2108|       |                     return;
 2109|       |                  }
 2110|  1.15k|               }
 2111|       |
 2112|      0|               ++it; // skip numeric header
 2113|  1.93k|               std::conditional_t<Opts.partial_read, size_t, const size_t> count = int_from_compressed(ctx, it, end);
 2114|  1.93k|               if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (2114:20): [True: 151, False: 1.78k]
  ------------------
 2115|    151|                  return;
 2116|    151|               }
 2117|       |               if constexpr (Opts.partial_read) {
 2118|       |                  count = value.size();
 2119|       |               }
 2120|       |
 2121|       |               // Read padding length byte and skip padding
 2122|  1.78k|               if (invalid_end(ctx, it, end)) {
  ------------------
  |  Branch (2122:20): [True: 133, False: 1.64k]
  ------------------
 2123|    133|                  return;
 2124|    133|               }
 2125|  1.64k|               const uint8_t padding = uint8_t(*it);
 2126|  1.64k|               ++it;
 2127|  1.64k|               if (padding >= sizeof(V)) [[unlikely]] {
  ------------------
  |  Branch (2127:20): [True: 12, False: 1.63k]
  ------------------
 2128|     12|                  ctx.error = error_code::syntax_error;
 2129|     12|                  return;
 2130|     12|               }
 2131|       |
 2132|  1.63k|               if (typed_array_out_of_bounds(ctx, it, end, count, sizeof(V), padding)) return;
  ------------------
  |  Branch (2132:20): [True: 94, False: 1.54k]
  ------------------
 2133|  1.54k|               it += padding;
 2134|       |
 2135|  1.54k|               if (!validate_and_resize(count)) {
  ------------------
  |  Branch (2135:20): [True: 42, False: 1.50k]
  ------------------
 2136|     42|                  return;
 2137|     42|               }
 2138|  1.50k|               n = count;
 2139|  1.50k|            }
 2140|  2.57k|            else if (tag != header) {
  ------------------
  |  Branch (2140:22): [True: 1.63k, False: 942]
  ------------------
 2141|  1.63k|               if constexpr (check_allow_conversions(Opts)) {
 2142|  1.63k|                  if (tag != header) [[unlikely]] {
  ------------------
  |  Branch (2142:23): [True: 1.63k, False: 0]
  ------------------
 2143|  1.63k|                     if constexpr (check_allow_conversions(Opts)) {
 2144|  1.63k|                        if ((tag & 0b00000111) != tag::typed_array) {
  ------------------
  |  Branch (2144:29): [True: 18, False: 1.61k]
  ------------------
 2145|     18|                           ctx.error = error_code::syntax_error;
 2146|     18|                           return;
 2147|     18|                        }
 2148|       |
 2149|  1.61k|                        const uint8_t byte_count = byte_count_lookup[tag >> 5];
 2150|  1.61k|                        const size_t count = prepare(byte_count);
 2151|  1.61k|                        if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (2151:29): [True: 362, False: 1.25k]
  ------------------
 2152|    362|                           return;
 2153|    362|                        }
 2154|       |
 2155|  1.25k|                        auto x_it = value.begin();
 2156|  4.10k|                        for (size_t i = 0; i < count; ++i, ++x_it) {
  ------------------
  |  Branch (2156:44): [True: 2.84k, False: 1.25k]
  ------------------
 2157|  2.84k|                           const uint8_t number_tag = tag::number | (tag & 0b11111000);
 2158|  2.84k|                           parse<BEVE>::op<no_header_on<Opts>()>(*x_it, number_tag, ctx, it, end);
 2159|  2.84k|                        }
 2160|  1.25k|                        return;
 2161|       |                     }
 2162|       |                     else {
 2163|       |                        ctx.error = error_code::syntax_error;
 2164|       |                        return;
 2165|       |                     }
 2166|  1.63k|                  }
 2167|       |               }
 2168|       |               else {
 2169|       |                  ctx.error = error_code::syntax_error;
 2170|       |                  return;
 2171|       |               }
 2172|  1.63k|            }
 2173|    942|            else {
 2174|    942|               n = prepare(sizeof(V));
 2175|    942|               if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (2175:20): [True: 248, False: 694]
  ------------------
 2176|    248|                  return;
 2177|    248|               }
 2178|    942|            }
 2179|       |
 2180|  3.82k|            if constexpr (contiguous<T>) {
 2181|  3.82k|               constexpr auto is_volatile =
 2182|  3.82k|                  std::is_volatile_v<std::remove_reference_t<std::remove_pointer_t<decltype(value.data())>>>;
 2183|       |
 2184|       |               if constexpr (is_volatile) {
 2185|       |                  for (size_t i = 0; i < n; ++i) {
 2186|       |                     if (size_t(end - it) < sizeof(V)) [[unlikely]] {
 2187|       |                        ctx.error = error_code::unexpected_end;
 2188|       |                        return;
 2189|       |                     }
 2190|       |
 2191|       |                     NV temp;
 2192|       |                     std::memcpy(&temp, it, sizeof(NV));
 2193|       |                     if constexpr (std::endian::native == std::endian::big) {
 2194|       |                        byteswap_le(temp);
 2195|       |                     }
 2196|       |                     value[i] = beve_num_array_construct<V>(temp);
 2197|       |                     it += sizeof(NV);
 2198|       |                  }
 2199|       |               }
 2200|       |               else if constexpr (std::endian::native == std::endian::big && sizeof(V) > 1) {
 2201|       |                  // On big endian, read and swap each element (through the rep so a chrono
 2202|       |                  // element is byteswapped as its underlying number).
 2203|       |                  if (typed_array_out_of_bounds(ctx, it, end, n, sizeof(V))) return;
 2204|       |                  for (size_t i = 0; i < n; ++i) {
 2205|       |                     NV temp;
 2206|       |                     std::memcpy(&temp, it, sizeof(NV));
 2207|       |                     byteswap_le(temp);
 2208|       |                     value[i] = beve_num_array_construct<V>(temp);
 2209|       |                     it += sizeof(NV);
 2210|       |                  }
 2211|       |               }
 2212|  3.82k|               else {
 2213|       |                  // Little endian or single-byte: bulk memcpy. A chrono element is
 2214|       |                  // bit-identical to its rep, so the raw wire bytes populate it directly.
 2215|  3.82k|                  if (typed_array_out_of_bounds(ctx, it, end, n, sizeof(V))) return;
  ------------------
  |  Branch (2215:23): [True: 0, False: 3.82k]
  ------------------
 2216|  3.82k|                  if (n) {
  ------------------
  |  Branch (2216:23): [True: 138, False: 3.69k]
  ------------------
 2217|    138|                     std::memcpy(value.data(), it, n * sizeof(V));
 2218|    138|                     it += n * sizeof(V);
 2219|    138|                  }
 2220|  3.82k|               }
 2221|       |            }
 2222|       |            else {
 2223|       |               auto x_it = value.begin();
 2224|       |               for (size_t i = 0; i < n; ++i, ++x_it) {
 2225|       |                  auto&& x = *x_it;
 2226|       |                  if (size_t(end - it) < sizeof(V)) [[unlikely]] {
 2227|       |                     ctx.error = error_code::unexpected_end;
 2228|       |                     return;
 2229|       |                  }
 2230|       |
 2231|       |                  NV temp;
 2232|       |                  std::memcpy(&temp, it, sizeof(NV));
 2233|       |                  if constexpr (std::endian::native == std::endian::big) {
 2234|       |                     byteswap_le(temp);
 2235|       |                  }
 2236|       |                  x = beve_num_array_construct<V>(temp);
 2237|       |                  it += sizeof(NV);
 2238|       |               }
 2239|       |            }
 2240|       |         }
 2241|       |         else if constexpr (str_t<V>) {
 2242|       |            constexpr uint8_t type = uint8_t(3) << 3;
 2243|       |            constexpr uint8_t string_indicator = uint8_t(1) << 5;
 2244|       |            constexpr uint8_t header = tag::typed_array | type | string_indicator;
 2245|       |
 2246|       |            if (tag != header) [[unlikely]] {
 2247|       |               ctx.error = error_code::syntax_error;
 2248|       |               return;
 2249|       |            }
 2250|       |
 2251|       |            ++it;
 2252|       |            std::conditional_t<Opts.partial_read, size_t, const size_t> n = int_from_compressed(ctx, it, end);
 2253|       |            if (bool(ctx.error)) [[unlikely]] {
 2254|       |               return;
 2255|       |            }
 2256|       |
 2257|       |            if constexpr (Opts.partial_read) {
 2258|       |               n = value.size();
 2259|       |            }
 2260|       |
 2261|       |            // Each string needs at least 1 byte for length header
 2262|       |            if (uint64_t(end - it) < n) [[unlikely]] {
 2263|       |               ctx.error = error_code::invalid_length;
 2264|       |               return;
 2265|       |            }
 2266|       |            if constexpr (check_max_array_size(Opts) > 0) {
 2267|       |               if (n > check_max_array_size(Opts)) [[unlikely]] {
 2268|       |                  ctx.error = error_code::invalid_length;
 2269|       |                  return;
 2270|       |               }
 2271|       |            }
 2272|       |            if constexpr (has_runtime_max_array_size<std::decay_t<decltype(ctx)>>) {
 2273|       |               if (ctx.max_array_size > 0 && n > ctx.max_array_size) [[unlikely]] {
 2274|       |                  ctx.error = error_code::invalid_length;
 2275|       |                  return;
 2276|       |               }
 2277|       |            }
 2278|       |
 2279|       |            if constexpr (resizable<T>) {
 2280|       |               if (exceeds_capacity(value, n, ctx)) [[unlikely]] {
 2281|       |                  return;
 2282|       |               }
 2283|       |               value.resize(n);
 2284|       |
 2285|       |               if constexpr (check_shrink_to_fit(Opts) && has_shrink_to_fit<T>) {
 2286|       |                  value.shrink_to_fit();
 2287|       |               }
 2288|       |            }
 2289|       |            else {
 2290|       |               if (n > value.size()) {
 2291|       |                  ctx.error = error_code::syntax_error;
 2292|       |                  return;
 2293|       |               }
 2294|       |            }
 2295|       |
 2296|       |            auto x_it = value.begin();
 2297|       |            for (size_t i = 0; i < n; ++i, ++x_it) {
 2298|       |               auto&& x = *x_it;
 2299|       |               const auto length = int_from_compressed(ctx, it, end);
 2300|       |               if (bool(ctx.error)) [[unlikely]] {
 2301|       |                  return;
 2302|       |               }
 2303|       |               if (uint64_t(end - it) < length) [[unlikely]] {
 2304|       |                  ctx.error = error_code::unexpected_end;
 2305|       |                  return;
 2306|       |               }
 2307|       |               if constexpr (check_max_string_length(Opts) > 0) {
 2308|       |                  if (length > check_max_string_length(Opts)) [[unlikely]] {
 2309|       |                     ctx.error = error_code::invalid_length;
 2310|       |                     return;
 2311|       |                  }
 2312|       |               }
 2313|       |               if constexpr (has_runtime_max_string_length<std::decay_t<decltype(ctx)>>) {
 2314|       |                  if (ctx.max_string_length > 0 && length > ctx.max_string_length) [[unlikely]] {
 2315|       |                     ctx.error = error_code::invalid_length;
 2316|       |                     return;
 2317|       |                  }
 2318|       |               }
 2319|       |
 2320|       |               x.resize(length);
 2321|       |
 2322|       |               if constexpr (check_shrink_to_fit(Opts) && has_shrink_to_fit<decltype(x)>) {
 2323|       |                  x.shrink_to_fit();
 2324|       |               }
 2325|       |
 2326|       |               std::memcpy(x.data(), it, length);
 2327|       |               it += length;
 2328|       |            }
 2329|       |         }
 2330|       |         else if constexpr (complex_t<V>) {
 2331|       |            constexpr uint8_t header = tag::extensions | 0b00011'000;
 2332|       |            if (tag != header) [[unlikely]] {
 2333|       |               ctx.error = error_code::syntax_error;
 2334|       |               return;
 2335|       |            }
 2336|       |            ++it;
 2337|       |
 2338|       |            using X = typename V::value_type;
 2339|       |            // Accepts complex arrays (sub-type 1) and aligned complex arrays (sub-type 2), whose DATA is laid out
 2340|       |            // identically once the header has been read
 2341|       |            std::conditional_t<Opts.partial_read, size_t, const size_t> n =
 2342|       |               detail::read_beve_complex_array_header<X>(ctx, it, end);
 2343|       |            if (bool(ctx.error)) [[unlikely]] {
 2344|       |               return;
 2345|       |            }
 2346|       |
 2347|       |            if constexpr (Opts.partial_read) {
 2348|       |               n = value.size();
 2349|       |            }
 2350|       |
 2351|       |            if (typed_array_out_of_bounds(ctx, it, end, n, sizeof(V))) return;
 2352|       |            if constexpr (check_max_array_size(Opts) > 0) {
 2353|       |               if (n > check_max_array_size(Opts)) [[unlikely]] {
 2354|       |                  ctx.error = error_code::invalid_length;
 2355|       |                  return;
 2356|       |               }
 2357|       |            }
 2358|       |            if constexpr (has_runtime_max_array_size<std::decay_t<decltype(ctx)>>) {
 2359|       |               if (ctx.max_array_size > 0 && n > ctx.max_array_size) [[unlikely]] {
 2360|       |                  ctx.error = error_code::invalid_length;
 2361|       |                  return;
 2362|       |               }
 2363|       |            }
 2364|       |
 2365|       |            if constexpr (resizable<T>) {
 2366|       |               if (exceeds_capacity(value, n, ctx)) [[unlikely]] {
 2367|       |                  return;
 2368|       |               }
 2369|       |               value.resize(n);
 2370|       |
 2371|       |               if constexpr (check_shrink_to_fit(Opts) && has_shrink_to_fit<T>) {
 2372|       |                  value.shrink_to_fit();
 2373|       |               }
 2374|       |            }
 2375|       |            else {
 2376|       |               if (n > value.size()) {
 2377|       |                  ctx.error = error_code::syntax_error;
 2378|       |                  return;
 2379|       |               }
 2380|       |            }
 2381|       |
 2382|       |            if constexpr (contiguous<T>) {
 2383|       |               if constexpr (std::endian::native == std::endian::big && sizeof(X) > 1) {
 2384|       |                  // On big endian, read and swap each complex element's components
 2385|       |                  for (size_t i = 0; i < n; ++i) {
 2386|       |                     std::memcpy(&value[i], it, sizeof(V));
 2387|       |                     X real_part = value[i].real();
 2388|       |                     X imag_part = value[i].imag();
 2389|       |                     byteswap_le(real_part);
 2390|       |                     byteswap_le(imag_part);
 2391|       |                     value[i] = V(real_part, imag_part);
 2392|       |                     it += sizeof(V);
 2393|       |                  }
 2394|       |               }
 2395|       |               else {
 2396|       |                  // Little endian or single-byte: bulk memcpy
 2397|       |                  if (n) {
 2398|       |                     std::memcpy(value.data(), it, n * sizeof(V));
 2399|       |                     it += n * sizeof(V);
 2400|       |                  }
 2401|       |               }
 2402|       |            }
 2403|       |            else {
 2404|       |               auto x_it = value.begin();
 2405|       |               for (size_t i = 0; i < n; ++i, ++x_it) {
 2406|       |                  auto&& x = *x_it;
 2407|       |                  std::memcpy(&x, it, sizeof(V));
 2408|       |                  if constexpr (std::endian::native == std::endian::big && sizeof(X) > 1) {
 2409|       |                     X real_part = x.real();
 2410|       |                     X imag_part = x.imag();
 2411|       |                     byteswap_le(real_part);
 2412|       |                     byteswap_le(imag_part);
 2413|       |                     x = V(real_part, imag_part);
 2414|       |                  }
 2415|       |                  it += sizeof(V);
 2416|       |               }
 2417|       |            }
 2418|       |         }
 2419|       |         else {
 2420|       |            if ((tag & 0b00000'111) != tag::generic_array) [[unlikely]] {
 2421|       |               ctx.error = error_code::syntax_error;
 2422|       |               return;
 2423|       |            }
 2424|       |
 2425|       |            depth_guard guard{ctx};
 2426|       |            if (!guard) [[unlikely]] {
 2427|       |               return;
 2428|       |            }
 2429|       |
 2430|       |            ++it;
 2431|       |            std::conditional_t<check_partial_read(Opts), size_t, const size_t> n = int_from_compressed(ctx, it, end);
 2432|       |            if (bool(ctx.error)) [[unlikely]] {
 2433|       |               return;
 2434|       |            }
 2435|       |
 2436|       |            if constexpr (Opts.partial_read) {
 2437|       |               n = value.size();
 2438|       |            }
 2439|       |
 2440|       |            // Each element needs at least 1 byte for its tag
 2441|       |            if (uint64_t(end - it) < n) [[unlikely]] {
 2442|       |               ctx.error = error_code::invalid_length;
 2443|       |               return;
 2444|       |            }
 2445|       |            if constexpr (check_max_array_size(Opts) > 0) {
 2446|       |               if (n > check_max_array_size(Opts)) [[unlikely]] {
 2447|       |                  ctx.error = error_code::invalid_length;
 2448|       |                  return;
 2449|       |               }
 2450|       |            }
 2451|       |            if constexpr (has_runtime_max_array_size<std::decay_t<decltype(ctx)>>) {
 2452|       |               if (ctx.max_array_size > 0 && n > ctx.max_array_size) [[unlikely]] {
 2453|       |                  ctx.error = error_code::invalid_length;
 2454|       |                  return;
 2455|       |               }
 2456|       |            }
 2457|       |
 2458|       |            if constexpr (resizable<T>) {
 2459|       |               if (exceeds_capacity(value, n, ctx)) [[unlikely]] {
 2460|       |                  return;
 2461|       |               }
 2462|       |               value.resize(n);
 2463|       |
 2464|       |               if constexpr (check_shrink_to_fit(Opts) && has_shrink_to_fit<T>) {
 2465|       |                  value.shrink_to_fit();
 2466|       |               }
 2467|       |            }
 2468|       |            else {
 2469|       |               if (n > value.size()) {
 2470|       |                  ctx.error = error_code::syntax_error;
 2471|       |                  return;
 2472|       |               }
 2473|       |            }
 2474|       |
 2475|       |            auto item_it = value.begin();
 2476|       |            for (size_t i = 0; i < n; ++i, ++item_it) {
 2477|       |               parse<BEVE>::op<Opts>(*item_it, ctx, it, end);
 2478|       |            }
 2479|       |         }
 2480|  4.51k|      }
_ZZN3glz4fromILj1ENSt3__15arrayImLm3EEEE2opITnDaXtlNS_4optsELj1ELb0ELb0ELb1ELb1EEERS3_TkNS_10is_contextERNS_7contextERPKcSB_EEvOT0_OT1_OT2_T3_ENKUlmE_clEm:
 1993|  3.31k|            auto validate_and_resize = [&](size_t n) -> bool {
 1994|       |               if constexpr (check_max_array_size(Opts) > 0) {
 1995|       |                  if (n > check_max_array_size(Opts)) [[unlikely]] {
 1996|       |                     ctx.error = error_code::invalid_length;
 1997|       |                     return false;
 1998|       |                  }
 1999|       |               }
 2000|       |               if constexpr (has_runtime_max_array_size<std::decay_t<decltype(ctx)>>) {
 2001|       |                  if (ctx.max_array_size > 0 && n > ctx.max_array_size) [[unlikely]] {
 2002|       |                     ctx.error = error_code::invalid_length;
 2003|       |                     return false;
 2004|       |                  }
 2005|       |               }
 2006|       |
 2007|       |               if constexpr (resizable<T>) {
 2008|       |                  if (exceeds_capacity(value, n, ctx)) [[unlikely]] {
 2009|       |                     return false;
 2010|       |                  }
 2011|       |                  value.resize(n);
 2012|       |
 2013|       |                  if constexpr (check_shrink_to_fit(Opts) && has_shrink_to_fit<T>) {
 2014|       |                     value.shrink_to_fit();
 2015|       |                  }
 2016|       |               }
 2017|  3.31k|               else {
 2018|  3.31k|                  if (n > value.size()) {
  ------------------
  |  Branch (2018:23): [True: 128, False: 3.18k]
  ------------------
 2019|    128|                     ctx.error = error_code::syntax_error;
 2020|    128|                     return false;
 2021|    128|                  }
 2022|  3.31k|               }
 2023|  3.18k|               return true;
 2024|  3.31k|            };
_ZN3glz5parseILj1EE2opITnDaXtlNS_4optsELj1ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj8EEERmRKhTkNS_10is_contextERNS_7contextERPKcSA_Qcl15check_no_headerT_EEEvOT0_OT1_OT2_OT3_T4_:
   37|  4.58k|      {
   38|       |         if constexpr (const_value_v<T>) {
   39|       |            if constexpr (check_error_on_const_read(Opts)) {
   40|       |               ctx.error = error_code::attempt_const_read;
   41|       |            }
   42|       |            else {
   43|       |               // do not read anything into the const value
   44|       |               skip_value<BEVE>::op<Opts>(std::forward<Ctx>(ctx), std::forward<It0>(it), end);
   45|       |            }
   46|       |         }
   47|  4.58k|         else {
   48|  4.58k|            using V = std::remove_cvref_t<T>;
   49|  4.58k|            from<BEVE, V>::template op<Opts>(std::forward<T>(value), std::forward<Tag>(tag), std::forward<Ctx>(ctx),
   50|  4.58k|                                             std::forward<It0>(it), end);
   51|  4.58k|         }
   52|  4.58k|      }
_ZN3glz4fromILj1EmE2opITnDaXtlNS_4optsELj1ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj8EEERmTkNS_10is_contextERNS_7contextERPKcS8_Qcl15check_no_headerTL0__EEEvOT0_hOT1_OT2_T3_:
  221|  4.58k|      {
  222|  4.58k|         if (invalid_end(ctx, it, end)) {
  ------------------
  |  Branch (222:14): [True: 0, False: 4.58k]
  ------------------
  223|      0|            return;
  224|      0|         }
  225|       |
  226|  4.58k|         using V = std::decay_t<decltype(value)>;
  227|       |
  228|  4.58k|         constexpr auto is_volatile = std::is_volatile_v<std::remove_reference_t<decltype(value)>>;
  229|       |
  230|  4.58k|         if (tag != header) {
  ------------------
  |  Branch (230:14): [True: 4.58k, False: 0]
  ------------------
  231|  4.58k|            if constexpr (check_allow_conversions(Opts)) {
  232|  4.58k|               if constexpr (num_t<T>) {
  233|  4.58k|                  if ((tag & 0b00000111) != tag::number) {
  ------------------
  |  Branch (233:23): [True: 0, False: 4.58k]
  ------------------
  234|      0|                     ctx.error = error_code::syntax_error;
  235|      0|                     return;
  236|      0|                  }
  237|       |
  238|  4.58k|                  auto decode = [&](auto&& i) {
  239|  4.58k|                     if (size_t(end - it) < sizeof(i)) [[unlikely]] {
  240|  4.58k|                        ctx.error = error_code::unexpected_end;
  241|  4.58k|                        return;
  242|  4.58k|                     }
  243|  4.58k|                     using I = std::decay_t<decltype(i)>;
  244|  4.58k|                     std::memcpy(&i, it, sizeof(I));
  245|  4.58k|                     if constexpr (std::endian::native == std::endian::big && sizeof(I) > 1) {
  246|  4.58k|                        byteswap_le(i);
  247|  4.58k|                     }
  248|  4.58k|                     value = static_cast<V>(i);
  249|  4.58k|                     it += sizeof(i);
  250|  4.58k|                  };
  251|       |
  252|  4.58k|                  switch (tag) {
  253|     32|                  case tag::f32: {
  ------------------
  |  Branch (253:19): [True: 32, False: 4.55k]
  ------------------
  254|     32|                     if constexpr (std::integral<V>) {
  255|       |                        // We do not allow cross conversions from floats to integral types
  256|     32|                        ctx.error = error_code::syntax_error;
  257|       |                     }
  258|       |                     else {
  259|       |                        static_assert(sizeof(float) == 4);
  260|       |                        // TODO: use float32_t in C++23
  261|       |                        decode(float{});
  262|       |                     }
  263|     32|                     return;
  264|      0|                  }
  265|     20|                  case tag::f64: {
  ------------------
  |  Branch (265:19): [True: 20, False: 4.56k]
  ------------------
  266|     20|                     if constexpr (std::integral<V>) {
  267|       |                        // We do not allow cross conversions from floats to integral types
  268|     20|                        ctx.error = error_code::syntax_error;
  269|       |                     }
  270|       |                     else {
  271|       |                        static_assert(sizeof(double) == 8);
  272|       |                        // TODO: use float64_t in C++23
  273|       |                        decode(double{});
  274|       |                     }
  275|     20|                     return;
  276|      0|                  }
  277|  1.22k|                  case tag::i8: {
  ------------------
  |  Branch (277:19): [True: 1.22k, False: 3.36k]
  ------------------
  278|  1.22k|                     decode(int8_t{});
  279|  1.22k|                     return;
  280|      0|                  }
  281|    473|                  case tag::i16: {
  ------------------
  |  Branch (281:19): [True: 473, False: 4.11k]
  ------------------
  282|    473|                     decode(int16_t{});
  283|    473|                     return;
  284|      0|                  }
  285|    382|                  case tag::i32: {
  ------------------
  |  Branch (285:19): [True: 382, False: 4.20k]
  ------------------
  286|    382|                     decode(int32_t{});
  287|    382|                     return;
  288|      0|                  }
  289|    494|                  case tag::i64: {
  ------------------
  |  Branch (289:19): [True: 494, False: 4.08k]
  ------------------
  290|    494|                     decode(int64_t{});
  291|    494|                     return;
  292|      0|                  }
  293|    737|                  case tag::u8: {
  ------------------
  |  Branch (293:19): [True: 737, False: 3.84k]
  ------------------
  294|    737|                     decode(uint8_t{});
  295|    737|                     return;
  296|      0|                  }
  297|    988|                  case tag::u16: {
  ------------------
  |  Branch (297:19): [True: 988, False: 3.59k]
  ------------------
  298|    988|                     decode(uint16_t{});
  299|    988|                     return;
  300|      0|                  }
  301|    213|                  case tag::u32: {
  ------------------
  |  Branch (301:19): [True: 213, False: 4.37k]
  ------------------
  302|    213|                     decode(uint32_t{});
  303|    213|                     return;
  304|      0|                  }
  305|      0|                  case tag::u64: {
  ------------------
  |  Branch (305:19): [True: 0, False: 4.58k]
  ------------------
  306|      0|                     decode(uint64_t{});
  307|      0|                     return;
  308|      0|                  }
  309|     22|                  default: {
  ------------------
  |  Branch (309:19): [True: 22, False: 4.56k]
  ------------------
  310|     22|                     ctx.error = error_code::syntax_error;
  311|     22|                     return;
  312|      0|                  }
  313|  4.58k|                  }
  314|  4.58k|               }
  315|       |            }
  316|       |            else {
  317|       |               ctx.error = error_code::syntax_error;
  318|       |               return;
  319|       |            }
  320|  4.58k|         }
  321|       |
  322|  4.58k|         if (size_t(end - it) < sizeof(V)) [[unlikely]] {
  ------------------
  |  Branch (322:14): [True: 0, False: 4.58k]
  ------------------
  323|      0|            ctx.error = error_code::unexpected_end;
  324|      0|            return;
  325|      0|         }
  326|       |
  327|       |         if constexpr (is_volatile) {
  328|       |            V temp;
  329|       |            std::memcpy(&temp, it, sizeof(V));
  330|       |            if constexpr (std::endian::native == std::endian::big && sizeof(V) > 1) {
  331|       |               byteswap_le(temp);
  332|       |            }
  333|       |            value = temp;
  334|       |         }
  335|  4.58k|         else {
  336|  4.58k|            std::memcpy(&value, it, sizeof(V));
  337|       |            if constexpr (std::endian::native == std::endian::big && sizeof(V) > 1) {
  338|       |               byteswap_le(value);
  339|       |            }
  340|  4.58k|         }
  341|  4.58k|         it += sizeof(V);
  342|  4.58k|      }
_ZZN3glz4fromILj1EmE2opITnDaXtlNS_4optsELj1ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj8EEERmTkNS_10is_contextERNS_7contextERPKcS8_Qcl15check_no_headerTL0__EEEvOT0_hOT1_OT2_T3_ENKUlOT_E_clIaEEDaSI_:
  238|  1.22k|                  auto decode = [&](auto&& i) {
  239|  1.22k|                     if (size_t(end - it) < sizeof(i)) [[unlikely]] {
  ------------------
  |  Branch (239:26): [True: 0, False: 1.22k]
  ------------------
  240|      0|                        ctx.error = error_code::unexpected_end;
  241|      0|                        return;
  242|      0|                     }
  243|  1.22k|                     using I = std::decay_t<decltype(i)>;
  244|  1.22k|                     std::memcpy(&i, it, sizeof(I));
  245|       |                     if constexpr (std::endian::native == std::endian::big && sizeof(I) > 1) {
  246|       |                        byteswap_le(i);
  247|       |                     }
  248|  1.22k|                     value = static_cast<V>(i);
  249|  1.22k|                     it += sizeof(i);
  250|  1.22k|                  };
_ZZN3glz4fromILj1EmE2opITnDaXtlNS_4optsELj1ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj8EEERmTkNS_10is_contextERNS_7contextERPKcS8_Qcl15check_no_headerTL0__EEEvOT0_hOT1_OT2_T3_ENKUlOT_E_clIsEEDaSI_:
  238|    473|                  auto decode = [&](auto&& i) {
  239|    473|                     if (size_t(end - it) < sizeof(i)) [[unlikely]] {
  ------------------
  |  Branch (239:26): [True: 0, False: 473]
  ------------------
  240|      0|                        ctx.error = error_code::unexpected_end;
  241|      0|                        return;
  242|      0|                     }
  243|    473|                     using I = std::decay_t<decltype(i)>;
  244|    473|                     std::memcpy(&i, it, sizeof(I));
  245|       |                     if constexpr (std::endian::native == std::endian::big && sizeof(I) > 1) {
  246|       |                        byteswap_le(i);
  247|       |                     }
  248|    473|                     value = static_cast<V>(i);
  249|    473|                     it += sizeof(i);
  250|    473|                  };
_ZZN3glz4fromILj1EmE2opITnDaXtlNS_4optsELj1ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj8EEERmTkNS_10is_contextERNS_7contextERPKcS8_Qcl15check_no_headerTL0__EEEvOT0_hOT1_OT2_T3_ENKUlOT_E_clIiEEDaSI_:
  238|    382|                  auto decode = [&](auto&& i) {
  239|    382|                     if (size_t(end - it) < sizeof(i)) [[unlikely]] {
  ------------------
  |  Branch (239:26): [True: 0, False: 382]
  ------------------
  240|      0|                        ctx.error = error_code::unexpected_end;
  241|      0|                        return;
  242|      0|                     }
  243|    382|                     using I = std::decay_t<decltype(i)>;
  244|    382|                     std::memcpy(&i, it, sizeof(I));
  245|       |                     if constexpr (std::endian::native == std::endian::big && sizeof(I) > 1) {
  246|       |                        byteswap_le(i);
  247|       |                     }
  248|    382|                     value = static_cast<V>(i);
  249|    382|                     it += sizeof(i);
  250|    382|                  };
_ZZN3glz4fromILj1EmE2opITnDaXtlNS_4optsELj1ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj8EEERmTkNS_10is_contextERNS_7contextERPKcS8_Qcl15check_no_headerTL0__EEEvOT0_hOT1_OT2_T3_ENKUlOT_E_clIlEEDaSI_:
  238|    494|                  auto decode = [&](auto&& i) {
  239|    494|                     if (size_t(end - it) < sizeof(i)) [[unlikely]] {
  ------------------
  |  Branch (239:26): [True: 0, False: 494]
  ------------------
  240|      0|                        ctx.error = error_code::unexpected_end;
  241|      0|                        return;
  242|      0|                     }
  243|    494|                     using I = std::decay_t<decltype(i)>;
  244|    494|                     std::memcpy(&i, it, sizeof(I));
  245|       |                     if constexpr (std::endian::native == std::endian::big && sizeof(I) > 1) {
  246|       |                        byteswap_le(i);
  247|       |                     }
  248|    494|                     value = static_cast<V>(i);
  249|    494|                     it += sizeof(i);
  250|    494|                  };
_ZZN3glz4fromILj1EmE2opITnDaXtlNS_4optsELj1ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj8EEERmTkNS_10is_contextERNS_7contextERPKcS8_Qcl15check_no_headerTL0__EEEvOT0_hOT1_OT2_T3_ENKUlOT_E_clIhEEDaSI_:
  238|    737|                  auto decode = [&](auto&& i) {
  239|    737|                     if (size_t(end - it) < sizeof(i)) [[unlikely]] {
  ------------------
  |  Branch (239:26): [True: 0, False: 737]
  ------------------
  240|      0|                        ctx.error = error_code::unexpected_end;
  241|      0|                        return;
  242|      0|                     }
  243|    737|                     using I = std::decay_t<decltype(i)>;
  244|    737|                     std::memcpy(&i, it, sizeof(I));
  245|       |                     if constexpr (std::endian::native == std::endian::big && sizeof(I) > 1) {
  246|       |                        byteswap_le(i);
  247|       |                     }
  248|    737|                     value = static_cast<V>(i);
  249|    737|                     it += sizeof(i);
  250|    737|                  };
_ZZN3glz4fromILj1EmE2opITnDaXtlNS_4optsELj1ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj8EEERmTkNS_10is_contextERNS_7contextERPKcS8_Qcl15check_no_headerTL0__EEEvOT0_hOT1_OT2_T3_ENKUlOT_E_clItEEDaSI_:
  238|    988|                  auto decode = [&](auto&& i) {
  239|    988|                     if (size_t(end - it) < sizeof(i)) [[unlikely]] {
  ------------------
  |  Branch (239:26): [True: 0, False: 988]
  ------------------
  240|      0|                        ctx.error = error_code::unexpected_end;
  241|      0|                        return;
  242|      0|                     }
  243|    988|                     using I = std::decay_t<decltype(i)>;
  244|    988|                     std::memcpy(&i, it, sizeof(I));
  245|       |                     if constexpr (std::endian::native == std::endian::big && sizeof(I) > 1) {
  246|       |                        byteswap_le(i);
  247|       |                     }
  248|    988|                     value = static_cast<V>(i);
  249|    988|                     it += sizeof(i);
  250|    988|                  };
_ZZN3glz4fromILj1EmE2opITnDaXtlNS_4optsELj1ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj8EEERmTkNS_10is_contextERNS_7contextERPKcS8_Qcl15check_no_headerTL0__EEEvOT0_hOT1_OT2_T3_ENKUlOT_E_clIjEEDaSI_:
  238|    213|                  auto decode = [&](auto&& i) {
  239|    213|                     if (size_t(end - it) < sizeof(i)) [[unlikely]] {
  ------------------
  |  Branch (239:26): [True: 0, False: 213]
  ------------------
  240|      0|                        ctx.error = error_code::unexpected_end;
  241|      0|                        return;
  242|      0|                     }
  243|    213|                     using I = std::decay_t<decltype(i)>;
  244|    213|                     std::memcpy(&i, it, sizeof(I));
  245|       |                     if constexpr (std::endian::native == std::endian::big && sizeof(I) > 1) {
  246|       |                        byteswap_le(i);
  247|       |                     }
  248|    213|                     value = static_cast<V>(i);
  249|    213|                     it += sizeof(i);
  250|    213|                  };
_ZZN3glz4fromILj1ENSt3__15arrayImLm3EEEE2opITnDaXtlNS_4optsELj1ELb0ELb0ELb1ELb1EEERS3_TkNS_10is_contextERNS_7contextERPKcSB_EEvOT0_OT1_OT2_T3_ENKUlmE0_clEm:
 2026|  2.55k|            auto prepare = [&](const size_t element_size) -> size_t {
 2027|  2.55k|               ++it;
 2028|  2.55k|               if (invalid_end(ctx, it, end)) {
  ------------------
  |  Branch (2028:20): [True: 9, False: 2.54k]
  ------------------
 2029|      9|                  return 0;
 2030|      9|               }
 2031|       |
 2032|  2.54k|               std::conditional_t<Opts.partial_read, size_t, const size_t> n = int_from_compressed(ctx, it, end);
 2033|  2.54k|               if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (2033:20): [True: 275, False: 2.27k]
  ------------------
 2034|    275|                  return 0;
 2035|    275|               }
 2036|       |
 2037|       |               if constexpr (Opts.partial_read) {
 2038|       |                  n = value.size();
 2039|       |               }
 2040|       |
 2041|  2.27k|               if (typed_array_out_of_bounds(ctx, it, end, n, element_size)) return 0;
  ------------------
  |  Branch (2041:20): [True: 305, False: 1.96k]
  ------------------
 2042|  1.96k|               if (!validate_and_resize(n)) {
  ------------------
  |  Branch (2042:20): [True: 21, False: 1.94k]
  ------------------
 2043|     21|                  return 0;
 2044|     21|               }
 2045|       |
 2046|  1.94k|               return n;
 2047|  1.96k|            };

_ZN3glz12ensure_spaceINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEETkNS_10is_contextENS_7contextEEEbRT0_RT_m:
  265|  1.08G|   {
  266|  1.08G|      using Buffer = std::remove_cvref_t<B>;
  267|       |
  268|  1.08G|      if constexpr (vector_like<Buffer>) {
  269|  1.08G|         if (required > b.size()) [[unlikely]] {
  ------------------
  |  Branch (269:14): [True: 44.8k, False: 1.08G]
  ------------------
  270|  44.8k|            grow_buffer(b, required);
  271|  44.8k|         }
  272|  1.08G|         return true;
  273|       |      }
  274|       |      else if constexpr (has_bounded_capacity<Buffer>) {
  275|       |         if (required > buffer_traits<Buffer>::capacity(b)) [[unlikely]] {
  276|       |            ctx.error = error_code::buffer_overflow;
  277|       |            return false;
  278|       |         }
  279|       |         return true;
  280|       |      }
  281|       |      else {
  282|       |         return true; // Raw pointer or other - trust caller
  283|       |      }
  284|  1.08G|   }
_ZN3glz11grow_bufferINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEvRT_m:
  143|  44.8k|   {
  144|  44.8k|      using traits = buffer_traits<std::remove_cvref_t<B>>;
  145|  44.8k|      if constexpr (requires { traits::grow(b, required); }) {
  146|  44.8k|         traits::grow(b, required);
  147|       |      }
  148|       |      else {
  149|       |         // A user specialization written before `grow` existed: keep the growth it used to get.
  150|       |         resize_unfilled(b, 2 * required);
  151|       |      }
  152|  44.8k|   }
_ZN3glz13buffer_traitsINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE4growERS7_mQL_ZNS_13buffer_traits12is_resizableEE:
  118|  44.8k|      {
  119|  44.8k|         resize_unfilled(b, 2 * required);
  120|  44.8k|      }
_ZN3glz15resize_unfilledINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEvRT_m:
   63|  44.8k|   {
   64|  44.8k|      if constexpr (requires { b.resize_and_overwrite(n, [](auto*, size_t written) { return written; }); }) {
   65|  44.8k|         b.resize_and_overwrite(n, [](auto*, size_t written) noexcept { return written; });
   66|       |      }
   67|       |      else {
   68|       |         b.resize(n);
   69|       |      }
   70|  44.8k|   }
_ZZN3glz15resize_unfilledINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEvRT_mENKUlPS8_mE_clIcEEDaSA_m:
   65|  44.8k|         b.resize_and_overwrite(n, [](auto*, size_t written) noexcept { return written; });

_ZN3glz10get_memberIR9my_structRiEEDcOT_OT0_:
  677|  3.44k|   {
  678|  3.44k|      using V = std::decay_t<decltype(element)>;
  679|       |      if constexpr (std::is_member_object_pointer_v<V>) {
  680|       |         return value.*element;
  681|       |      }
  682|       |      else if constexpr (std::is_member_function_pointer_v<V>) {
  683|       |         return element;
  684|       |      }
  685|       |      else if constexpr (std::invocable<Element, Value> && not eigen_t<Element>) {
  686|       |         // Eigen places a static_assert inside of the operator()(), so we must target
  687|       |         // matrix types and reject them from the invocable check
  688|       |         // Eigen ought to put the check in the `enable_if` for operator()()
  689|       |         return std::invoke(std::forward<Element>(element), std::forward<Value>(value));
  690|       |      }
  691|       |      else if constexpr (std::is_pointer_v<V> && !std::is_reference_v<Element>) {
  692|       |         if constexpr (std::invocable<decltype(*element), Value>) {
  693|       |            return std::invoke(*element, std::forward<Value>(value));
  694|       |         }
  695|       |         else {
  696|       |            return *element;
  697|       |         }
  698|       |      }
  699|  3.44k|      else {
  700|  3.44k|         return element;
  701|  3.44k|      }
  702|  3.44k|   }
_ZN3glz10get_memberIR9my_structRdEEDcOT_OT0_:
  677|  3.09k|   {
  678|  3.09k|      using V = std::decay_t<decltype(element)>;
  679|       |      if constexpr (std::is_member_object_pointer_v<V>) {
  680|       |         return value.*element;
  681|       |      }
  682|       |      else if constexpr (std::is_member_function_pointer_v<V>) {
  683|       |         return element;
  684|       |      }
  685|       |      else if constexpr (std::invocable<Element, Value> && not eigen_t<Element>) {
  686|       |         // Eigen places a static_assert inside of the operator()(), so we must target
  687|       |         // matrix types and reject them from the invocable check
  688|       |         // Eigen ought to put the check in the `enable_if` for operator()()
  689|       |         return std::invoke(std::forward<Element>(element), std::forward<Value>(value));
  690|       |      }
  691|       |      else if constexpr (std::is_pointer_v<V> && !std::is_reference_v<Element>) {
  692|       |         if constexpr (std::invocable<decltype(*element), Value>) {
  693|       |            return std::invoke(*element, std::forward<Value>(value));
  694|       |         }
  695|       |         else {
  696|       |            return *element;
  697|       |         }
  698|       |      }
  699|  3.09k|      else {
  700|  3.09k|         return element;
  701|  3.09k|      }
  702|  3.09k|   }
_ZN3glz10get_memberIR9my_structRNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEDcOT_OT0_:
  677|  2.09k|   {
  678|  2.09k|      using V = std::decay_t<decltype(element)>;
  679|       |      if constexpr (std::is_member_object_pointer_v<V>) {
  680|       |         return value.*element;
  681|       |      }
  682|       |      else if constexpr (std::is_member_function_pointer_v<V>) {
  683|       |         return element;
  684|       |      }
  685|       |      else if constexpr (std::invocable<Element, Value> && not eigen_t<Element>) {
  686|       |         // Eigen places a static_assert inside of the operator()(), so we must target
  687|       |         // matrix types and reject them from the invocable check
  688|       |         // Eigen ought to put the check in the `enable_if` for operator()()
  689|       |         return std::invoke(std::forward<Element>(element), std::forward<Value>(value));
  690|       |      }
  691|       |      else if constexpr (std::is_pointer_v<V> && !std::is_reference_v<Element>) {
  692|       |         if constexpr (std::invocable<decltype(*element), Value>) {
  693|       |            return std::invoke(*element, std::forward<Value>(value));
  694|       |         }
  695|       |         else {
  696|       |            return *element;
  697|       |         }
  698|       |      }
  699|  2.09k|      else {
  700|  2.09k|         return element;
  701|  2.09k|      }
  702|  2.09k|   }
_ZN3glz10get_memberIR9my_structRNSt3__15arrayImLm3EEEEEDcOT_OT0_:
  677|  4.52k|   {
  678|  4.52k|      using V = std::decay_t<decltype(element)>;
  679|       |      if constexpr (std::is_member_object_pointer_v<V>) {
  680|       |         return value.*element;
  681|       |      }
  682|       |      else if constexpr (std::is_member_function_pointer_v<V>) {
  683|       |         return element;
  684|       |      }
  685|       |      else if constexpr (std::invocable<Element, Value> && not eigen_t<Element>) {
  686|       |         // Eigen places a static_assert inside of the operator()(), so we must target
  687|       |         // matrix types and reject them from the invocable check
  688|       |         // Eigen ought to put the check in the `enable_if` for operator()()
  689|       |         return std::invoke(std::forward<Element>(element), std::forward<Value>(value));
  690|       |      }
  691|       |      else if constexpr (std::is_pointer_v<V> && !std::is_reference_v<Element>) {
  692|       |         if constexpr (std::invocable<decltype(*element), Value>) {
  693|       |            return std::invoke(*element, std::forward<Value>(value));
  694|       |         }
  695|       |         else {
  696|       |            return *element;
  697|       |         }
  698|       |      }
  699|  4.52k|      else {
  700|  4.52k|         return element;
  701|  4.52k|      }
  702|  4.52k|   }
_ZN3glz8str_viewINSt3__117basic_string_viewIcNS1_11char_traitsIcEEEERKS5_EES5_OT0_:
  341|  1.91M|   {
  342|  1.91M|      if constexpr (std::same_as<std::decay_t<T>, std::string_view>) {
  343|  1.91M|         return value; // already the answer; rebuilding it from data() and size() costs instructions
  344|       |      }
  345|       |      else if constexpr (!char_array_t<T> && std::is_pointer_v<std::decay_t<T>>) {
  346|       |         return value ? std::string_view{value} : std::string_view{};
  347|       |      }
  348|       |      else if constexpr (has_data<T> && has_size<T>) {
  349|       |         return std::string_view{value.data(), value.size()};
  350|       |      }
  351|       |      else {
  352|       |         return std::string_view{value};
  353|       |      }
  354|  1.91M|   }

_ZN3glz10call_scopeINS_7contextEEC2ERS1_:
  272|  24.1k|      explicit call_scope(Ctx& c) noexcept : ctx(c), depth(c.depth)
  273|  24.1k|      {
  274|  24.1k|         ctx.error = error_code::none;
  275|  24.1k|         ctx.custom_error_message = {};
  276|  24.1k|      }
_ZN3glz11depth_guardINS_7contextEEC2ERS1_m:
  215|  4.68k|      depth_guard(Ctx& c, const size_t limit = max_recursive_depth_limit) noexcept : ctx(c)
  216|  4.68k|      {
  217|  4.68k|         if (ctx.depth >= limit) [[unlikely]] {
  ------------------
  |  Branch (217:14): [True: 0, False: 4.68k]
  ------------------
  218|      0|            ctx.error = error_code::exceeded_max_recursive_depth;
  219|      0|            return;
  220|      0|         }
  221|  4.68k|         ++ctx.depth;
  222|  4.68k|         entered = true;
  223|  4.68k|      }
_ZNK3glz11depth_guardINS_7contextEEcvbEv:
  228|  4.68k|      explicit operator bool() const noexcept { return entered; }
_ZN3glz11depth_guardINS_7contextEED2Ev:
  225|  4.68k|      {
  226|  4.68k|         if (entered) --ctx.depth;
  ------------------
  |  Branch (226:14): [True: 4.68k, False: 0]
  ------------------
  227|  4.68k|      }
_ZN3glz10call_scopeINS_7contextEED2Ev:
  277|  24.1k|      ~call_scope() { ctx.depth = depth; }
_ZNK3glz9error_ctxcvbEv:
  148|  24.1k|      operator bool() const noexcept { return ec != error_code::none; }
_ZN3glz12indent_guardINS_7contextEEC2ERS1_m:
  241|  6.45M|      indent_guard(Ctx& c, const size_t indentation_step) noexcept : ctx(c), step(indentation_step)
  242|  6.45M|      {
  243|  6.45M|         ctx.depth += step;
  244|  6.45M|      }
_ZN3glz12indent_guardINS_7contextEED2Ev:
  245|  6.45M|      ~indent_guard() { ctx.depth -= step; }

_ZN3glz4readITnDaXtlNS_4optsELj1ELb1ELb0ELb1ELb1EEE9my_structTkNS_10contiguousERKNSt3__16vectorIcNS3_9allocatorIcEEEEQaa14read_supportedIT0_XdtT_6formatEEnt18is_input_streamingIT1_EEENS_9error_ctxERSA_OSB_:
  232|  24.1k|   {
  233|  24.1k|      format_context_t<Opts.format> ctx{};
  234|  24.1k|      return read<Opts>(value, buffer, ctx);
  235|  24.1k|   }
_ZN3glz4readITnDaXtlNS_4optsELj1ELb1ELb0ELb1ELb1EEE9my_structTkNS_10contiguousERKNSt3__16vectorIcNS3_9allocatorIcEEEETkNS_10is_contextERNS_7contextEQaa14read_supportedIT0_XdtT_6formatEEnt18is_input_streamingIT1_EEENS_9error_ctxERSC_OSD_OT2_:
  152|  24.1k|   {
  153|  24.1k|      static_assert(sizeof(decltype(*buffer.data())) == 1);
  154|       |
  155|  24.1k|      call_scope scope{ctx};
  156|       |
  157|  24.1k|      if constexpr (Opts.format != NDJSON) {
  158|  24.1k|         if (buffer.size() == 0) [[unlikely]] {
  ------------------
  |  Branch (158:14): [True: 0, False: 24.1k]
  ------------------
  159|      0|            ctx.error = error_code::no_read_input;
  160|      0|            return {0, ctx.error, ctx.custom_error_message};
  161|      0|         }
  162|  24.1k|      }
  163|       |
  164|       |      // The reader used to grow the caller's buffer by `padding_bytes` here and shrink it back on
  165|       |      // the way out, so that its fixed width loads could run off the end of the document into
  166|       |      // defined bytes. Every one of those loads is now bounded against `end` instead (see
  167|       |      // `chunk_min`), which costs the last chunk of the buffer its chunked path and nothing else --
  168|       |      // measurably less than the round trip did. `std::string::resize` is an ABI entry point on
  169|       |      // both libc++ and libstdc++, so neither call inlined and the parse was spilled around both
  170|       |      // for what amounted to a sixteen byte store; the price did not scale with the document, so on
  171|       |      // a small one it was the bulk of the call. A caller who does have that slack can still say so
  172|       |      // and get the unbounded loads back, and nobody else pays for the buffer being touched at all.
  173|  24.1k|      ctx.padded_input = check_is_padded(Opts);
  174|       |
  175|  24.1k|      static constexpr auto ParseOpts = parse_opts_for<Opts, Buf>();
  176|       |
  177|  24.1k|      auto [it, end] = read_iterators<ParseOpts>(buffer);
  178|  24.1k|      auto start = it;
  179|       |
  180|       |      // Bound the speculative re-parsing a variant resolution may do, in bytes, relative to this
  181|       |      // input. Seeded per read so a reused context starts fresh. See charge_speculation.
  182|  24.1k|      if constexpr (requires { ctx.speculation_budget; }) {
  183|  24.1k|         const size_t proportional = max_speculative_parse_factor * size_t(end - it);
  184|  24.1k|         ctx.speculation_budget =
  185|  24.1k|            (proportional > min_speculative_parse_bytes ? proportional : min_speculative_parse_bytes) + 2;
  ------------------
  |  Branch (185:14): [True: 985, False: 23.1k]
  ------------------
  186|  24.1k|      }
  187|       |
  188|       |      // A YAML context marks its outermost parse with stream_begin and seeds its expansion budgets
  189|       |      // there, so clearing it here is what makes those budgets per-read like the one above. A
  190|       |      // reused context would otherwise carry a spent budget into the next document and reject a
  191|       |      // valid one, and would leave stream_begin pointing into the buffer of the previous read.
  192|       |      // Nested YAML parses do not route through glz::read, so they still cannot reseed themselves.
  193|       |      if constexpr (requires { ctx.stream_begin; }) {
  194|       |         ctx.stream_begin = nullptr;
  195|       |      }
  196|       |
  197|       |      // Normalized off before dispatching: no reader branches on it any more, so leaving it set
  198|       |      // would split every instantiation below between callers who declared padding and callers who
  199|       |      // did not, for a flag none of them reads.
  200|  24.1k|      parse<Opts.format>::template op<ParseOpts>(value, ctx, it, end);
  201|       |
  202|  24.1k|      if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (202:11): [True: 24.0k, False: 67]
  ------------------
  203|  24.0k|         goto finish;
  204|  24.0k|      }
  205|       |
  206|       |      // The JSON RFC 8259 defines: JSON-text = ws value ws
  207|       |      // So, trailing whitespace is permitted and sometimes we want to
  208|       |      // validate this, even though this memory will not affect Glaze.
  209|       |      if constexpr (check_validate_trailing_whitespace(Opts)) {
  210|       |         if (it < end) {
  211|       |            skip_ws<ParseOpts>(ctx, it, end);
  212|       |            if (bool(ctx.error)) [[unlikely]] {
  213|       |               goto finish;
  214|       |            }
  215|       |            if (it != end) [[unlikely]] {
  216|       |               ctx.error = error_code::syntax_error;
  217|       |            }
  218|       |         }
  219|       |      }
  220|       |
  221|  24.1k|   finish:
  222|       |      // ParseOpts, not Opts: this reads `null_terminated` to tell a value that ended with the
  223|       |      // buffer from one that ran out, and it has to be told the same thing the parse was.
  224|  24.1k|      finalize_top_level_read<ParseOpts>(ctx, start, it, end);
  225|       |
  226|  24.1k|      return {size_t(it - start), ctx.error, ctx.custom_error_message};
  227|     67|   }
_ZN3glz14read_iteratorsITnDaXtlNS_4optsELj1ELb0ELb0ELb1ELb1EEETkNS_10contiguousERKNSt3__16vectorIcNS2_9allocatorIcEEEEEEDaOT0_:
   40|  24.1k|   {
   41|  24.1k|      static_assert(sizeof(decltype(*buffer.data())) == 1);
   42|       |
   43|  24.1k|      auto it = reinterpret_cast<const char*>(buffer.data());
   44|  24.1k|      auto end = it + buffer.size();
   45|       |
   46|  24.1k|      return std::pair{it, end};
   47|  24.1k|   }
_ZN3glz16exceeds_capacityINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEETkNS_10is_contextENS_7contextEEEbRT_mRT0_:
   28|  1.79k|   {
   29|       |      if constexpr (fixed_capacity_container<decltype(value)>) {
   30|       |         if (n > value.max_size()) [[unlikely]] {
   31|       |            ctx.error = error_code::exceeded_static_array_size;
   32|       |            return true;
   33|       |         }
   34|       |      }
   35|  1.79k|      return false;
   36|  1.79k|   }
_ZN3glz23finalize_top_level_readITnDaXtlNS_4optsELj1ELb0ELb0ELb1ELb1EEETkNS_10is_contextERNS_7contextEEEvOT0_PKcS7_S7_:
  131|  24.1k|   {
  132|       |      if constexpr (Opts.format == JSON && !check_null_terminated(Opts)) {
  133|       |         // Deliberately not [[unlikely]]: a body that ends with the buffer lands here on every
  134|       |         // successful read, which is the ordinary case for a registry parsing a wire span.
  135|       |         // start < it, not !=, because a streaming origin can be empty or overshoot on an error
  136|       |         // path; neither is an absent value.
  137|       |         if (ctx.error == error_code::end_reached && ctx.depth == 0 && it == end && start < it) {
  138|       |            context ws_ctx{}; // only written to when skip_ws parses a comment; the result is unused
  139|       |            const char* consumed = start;
  140|       |            skip_ws<Opts>(ws_ctx, consumed, it);
  141|       |            if (consumed == it) {
  142|       |               ctx.error = error_code::no_read_input;
  143|       |            }
  144|       |         }
  145|       |      }
  146|  24.1k|      finalize_read_context(ctx);
  147|  24.1k|   }
_ZN3glz21finalize_read_contextITkNS_10is_contextERNS_7contextEEEvOT_:
  109|  24.1k|   {
  110|  24.1k|      settle_partial_read_complete(ctx);
  111|  24.1k|      settle_end_reached(ctx);
  112|  24.1k|   }
_ZN3glz28settle_partial_read_completeITkNS_10is_contextERNS_7contextEEEvOT_:
  102|  24.1k|   {
  103|  24.1k|      if (ctx.error == error_code::partial_read_complete) {
  ------------------
  |  Branch (103:11): [True: 0, False: 24.1k]
  ------------------
  104|      0|         ctx.error = error_code::none;
  105|      0|      }
  106|  24.1k|   }
_ZN3glz18settle_end_reachedITkNS_10is_contextERNS_7contextEEEvOT_:
   88|  24.1k|   {
   89|  24.1k|      if (ctx.error == error_code::end_reached) {
  ------------------
  |  Branch (89:11): [True: 0, False: 24.1k]
  ------------------
   90|      0|         ctx.error = (ctx.depth == 0) ? error_code::none : error_code::unexpected_end;
  ------------------
  |  Branch (90:22): [True: 0, False: 0]
  ------------------
   91|      0|      }
   92|  24.1k|   }

_ZN3glz21decode_hash_with_sizeILj1E9my_structXtlNS_11hash_info_tIS1_Lm256EEELNS_9hash_typeE1EtlNSt3__15arrayIhLm256EEEtlA256_hLh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh3ELh4ELh4ELh1ELh4ELh4ELh4ELh2ELh0ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4EEELm1ELm5EEELS4_1EE2opIRPKcSD_EEmOT_OT0_m:
 2805|  14.0k|      {
 2806|  14.0k|         if (n < HashInfo.min_length || n > HashInfo.max_length) [[unlikely]] {
  ------------------
  |  Branch (2806:14): [True: 547, False: 13.5k]
  |  Branch (2806:41): [True: 174, False: 13.3k]
  ------------------
 2807|    721|            return N;
 2808|    721|         }
 2809|  13.3k|         return decode_hash_with_size_impl<Format, T, HashInfo, Type>::op(it, end, n);
 2810|  14.0k|      }
_ZN3glz26decode_hash_with_size_implILj1E9my_structXtlNS_11hash_info_tIS1_Lm256EEELNS_9hash_typeE1EtlNSt3__15arrayIhLm256EEEtlA256_hLh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh3ELh4ELh4ELh1ELh4ELh4ELh4ELh2ELh0ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4EEELm1ELm5EEELS4_1EE2opIRPKcSD_EEmOT_OT0_m:
 2858|  13.3k|      {
 2859|       |         // unique_index < min_length <= n, so it[unique_index] is within the key (the wrapper has
 2860|       |         // already rejected lengths outside [min_length, max_length]).
 2861|       |         if constexpr (HashInfo.sized_hash) {
 2862|       |            const auto h = bitmix(uint16_t(it[HashInfo.unique_index]) | (uint16_t(n) << 8), HashInfo.seed);
 2863|       |            return HashInfo.table[h % bsize];
 2864|       |         }
 2865|  13.3k|         else {
 2866|       |            if constexpr (N == 2) {
 2867|       |               // Avoids using a hash table
 2868|       |               constexpr auto first_key_char = reflect<T>::keys[0][uindex];
 2869|       |               return size_t(bool(it[uindex] ^ first_key_char));
 2870|       |            }
 2871|  13.3k|            else {
 2872|  13.3k|               return HashInfo.table[uint8_t(it[uindex])];
 2873|  13.3k|            }
 2874|  13.3k|         }
 2875|  13.3k|      }

_ZN3glz3getILm0ETkNS_12tuple_detail9indexableENS_5tupleIJRiRdRNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEERNS5_5arrayImLm3EEEEEEEEDcOT0_:
  116|  3.44k|   {
  117|  3.44k|      using D = std::remove_cvref_t<Tup>;
  118|  3.44k|      if constexpr (tuple_detail::is_tuple<D>) {
  119|  3.44k|         static_assert(I < D::N, "glz::get index is out of range");
  120|  3.44k|         using T = typename D::template type_at<I>;
  121|       |         if constexpr (std::is_reference_v<Tup> || std::is_const_v<std::remove_reference_t<Tup>>) {
  122|       |            // An lvalue, or a const tuple of either value category: element access carries the
  123|       |            // constness of the tuple, except for elements that are themselves references.
  124|       |            using leaf = tuple_detail::match_const_t<std::remove_reference_t<Tup>, tuple_detail::elem<I, T>>;
  125|       |            return (static_cast<leaf&>(tup).value);
  126|       |         }
  127|  3.44k|         else {
  128|  3.44k|            return static_cast<T&&>(static_cast<tuple_detail::elem<I, T>&>(tup).value);
  129|  3.44k|         }
  130|       |      }
  131|       |      else {
  132|       |         return (static_cast<Tup&&>(tup)[I]);
  133|       |      }
  134|  3.44k|   }
_ZN3glz3tieIJidNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS1_5arrayImLm3EEEEEENS_5tupleIJDpRT_EEESD_:
  325|  13.1k|   {
  326|  13.1k|      return {{{ts}...}};
  327|  13.1k|   }
_ZN3glz3getILm1ETkNS_12tuple_detail9indexableENS_5tupleIJRiRdRNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEERNS5_5arrayImLm3EEEEEEEEDcOT0_:
  116|  3.09k|   {
  117|  3.09k|      using D = std::remove_cvref_t<Tup>;
  118|  3.09k|      if constexpr (tuple_detail::is_tuple<D>) {
  119|  3.09k|         static_assert(I < D::N, "glz::get index is out of range");
  120|  3.09k|         using T = typename D::template type_at<I>;
  121|       |         if constexpr (std::is_reference_v<Tup> || std::is_const_v<std::remove_reference_t<Tup>>) {
  122|       |            // An lvalue, or a const tuple of either value category: element access carries the
  123|       |            // constness of the tuple, except for elements that are themselves references.
  124|       |            using leaf = tuple_detail::match_const_t<std::remove_reference_t<Tup>, tuple_detail::elem<I, T>>;
  125|       |            return (static_cast<leaf&>(tup).value);
  126|       |         }
  127|  3.09k|         else {
  128|  3.09k|            return static_cast<T&&>(static_cast<tuple_detail::elem<I, T>&>(tup).value);
  129|  3.09k|         }
  130|       |      }
  131|       |      else {
  132|       |         return (static_cast<Tup&&>(tup)[I]);
  133|       |      }
  134|  3.09k|   }
_ZN3glz3getILm2ETkNS_12tuple_detail9indexableENS_5tupleIJRiRdRNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEERNS5_5arrayImLm3EEEEEEEEDcOT0_:
  116|  2.09k|   {
  117|  2.09k|      using D = std::remove_cvref_t<Tup>;
  118|  2.09k|      if constexpr (tuple_detail::is_tuple<D>) {
  119|  2.09k|         static_assert(I < D::N, "glz::get index is out of range");
  120|  2.09k|         using T = typename D::template type_at<I>;
  121|       |         if constexpr (std::is_reference_v<Tup> || std::is_const_v<std::remove_reference_t<Tup>>) {
  122|       |            // An lvalue, or a const tuple of either value category: element access carries the
  123|       |            // constness of the tuple, except for elements that are themselves references.
  124|       |            using leaf = tuple_detail::match_const_t<std::remove_reference_t<Tup>, tuple_detail::elem<I, T>>;
  125|       |            return (static_cast<leaf&>(tup).value);
  126|       |         }
  127|  2.09k|         else {
  128|  2.09k|            return static_cast<T&&>(static_cast<tuple_detail::elem<I, T>&>(tup).value);
  129|  2.09k|         }
  130|       |      }
  131|       |      else {
  132|       |         return (static_cast<Tup&&>(tup)[I]);
  133|       |      }
  134|  2.09k|   }
_ZN3glz3getILm3ETkNS_12tuple_detail9indexableENS_5tupleIJRiRdRNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEERNS5_5arrayImLm3EEEEEEEEDcOT0_:
  116|  4.52k|   {
  117|  4.52k|      using D = std::remove_cvref_t<Tup>;
  118|  4.52k|      if constexpr (tuple_detail::is_tuple<D>) {
  119|  4.52k|         static_assert(I < D::N, "glz::get index is out of range");
  120|  4.52k|         using T = typename D::template type_at<I>;
  121|       |         if constexpr (std::is_reference_v<Tup> || std::is_const_v<std::remove_reference_t<Tup>>) {
  122|       |            // An lvalue, or a const tuple of either value category: element access carries the
  123|       |            // constness of the tuple, except for elements that are themselves references.
  124|       |            using leaf = tuple_detail::match_const_t<std::remove_reference_t<Tup>, tuple_detail::elem<I, T>>;
  125|       |            return (static_cast<leaf&>(tup).value);
  126|       |         }
  127|  4.52k|         else {
  128|  4.52k|            return static_cast<T&&>(static_cast<tuple_detail::elem<I, T>&>(tup).value);
  129|  4.52k|         }
  130|       |      }
  131|       |      else {
  132|       |         return (static_cast<Tup&&>(tup)[I]);
  133|       |      }
  134|  4.52k|   }

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

_ZN3glz6detail9emit_charINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEETkNS_10is_contextENS_7contextEEEbRT0_cRT_Rm:
 1154|   541M|      {
 1155|   541M|         if (!ensure_space(ctx, out, ix + 1)) [[unlikely]] {
  ------------------
  |  Branch (1155:14): [True: 0, False: 541M]
  ------------------
 1156|      0|            return false;
 1157|      0|         }
 1158|   541M|         dump<false>(c, out, ix);
 1159|   541M|         return true;
 1160|   541M|      }
_ZN3glz6detail12emit_literalITnNS_14string_literalEXtlNS2_ILm5EEEtlA5_cLc116ELc114ELc117ELc101EEEENSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEETkNS_10is_contextENS_7contextEEEbRT1_RT0_Rm:
 1164|  90.3M|      {
 1165|  90.3M|         static constexpr auto s = str.sv();
 1166|  90.3M|         if (!ensure_space(ctx, out, ix + s.size())) [[unlikely]] {
  ------------------
  |  Branch (1166:14): [True: 0, False: 90.3M]
  ------------------
 1167|      0|            return false;
 1168|      0|         }
 1169|  90.3M|         dump<false>(s, out, ix);
 1170|  90.3M|         return true;
 1171|  90.3M|      }
_ZN3glz6detail12emit_literalITnNS_14string_literalEXtlNS2_ILm6EEEtlA6_cLc102ELc97ELc108ELc115ELc101EEEENSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEETkNS_10is_contextENS_7contextEEEbRT1_RT0_Rm:
 1164|   399M|      {
 1165|   399M|         static constexpr auto s = str.sv();
 1166|   399M|         if (!ensure_space(ctx, out, ix + s.size())) [[unlikely]] {
  ------------------
  |  Branch (1166:14): [True: 0, False: 399M]
  ------------------
 1167|      0|            return false;
 1168|      0|         }
 1169|   399M|         dump<false>(s, out, ix);
 1170|   399M|         return true;
 1171|   399M|      }
_ZN3glz6detail12emit_literalITnNS_14string_literalEXtlNS2_ILm5EEEtlA5_cLc110ELc117ELc108ELc108EEEENSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEETkNS_10is_contextENS_7contextEEEbRT1_RT0_Rm:
 1164|  13.8M|      {
 1165|  13.8M|         static constexpr auto s = str.sv();
 1166|  13.8M|         if (!ensure_space(ctx, out, ix + s.size())) [[unlikely]] {
  ------------------
  |  Branch (1166:14): [True: 0, False: 13.8M]
  ------------------
 1167|      0|            return false;
 1168|      0|         }
 1169|  13.8M|         dump<false>(s, out, ix);
 1170|  13.8M|         return true;
 1171|  13.8M|      }
_ZN3glz2toILj10EfE2opITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERfTkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_:
  814|  1.92M|      {
  815|  1.92M|         if constexpr (not check_write_unchecked(Opts)) {
  816|  1.92M|            static_assert(required_padding<T>());
  817|  1.92M|            if (!ensure_space(ctx, b, ix + required_padding<T>())) [[unlikely]] {
  ------------------
  |  Branch (817:17): [True: 0, False: 1.92M]
  ------------------
  818|      0|               return;
  819|      0|            }
  820|  1.92M|         }
  821|       |
  822|  1.92M|         static constexpr auto O = write_unchecked_on<Opts>();
  823|       |
  824|       |         if constexpr (check_quoted_num(Opts)) {
  825|       |            std::memcpy(&b[ix], "\"", 1);
  826|       |            ++ix;
  827|       |            write_chars::op<O>(value, ctx, b, ix);
  828|       |            std::memcpy(&b[ix], "\"", 1);
  829|       |            ++ix;
  830|       |         }
  831|  1.92M|         else {
  832|  1.92M|            write_chars::op<O>(value, ctx, b, ix);
  833|  1.92M|         }
  834|  1.92M|      }
_ZN3glz16required_paddingIfEEmv:
  538|  1.92M|   {
  539|  1.92M|      constexpr auto value = []() -> size_t {
  540|  1.92M|         if constexpr (boolean_like<T>) {
  541|  1.92M|            return 8;
  542|  1.92M|         }
  543|  1.92M|         else if constexpr (num_t<T>) {
  544|  1.92M|            if constexpr (std::floating_point<T>) {
  545|  1.92M|               if constexpr (sizeof(T) > 8) {
  546|  1.92M|                  return 64;
  547|  1.92M|               }
  548|  1.92M|               else if constexpr (sizeof(T) > 4) {
  549|       |                  // zmij scratch + 4 for optional quotes and trailing comma.
  550|  1.92M|                  return zmij::double_buffer_size + 4;
  551|  1.92M|               }
  552|  1.92M|               else {
  553|  1.92M|                  return zmij::float_buffer_size + 4;
  554|  1.92M|               }
  555|  1.92M|            }
  556|  1.92M|            else if constexpr (sizeof(T) > 4) {
  557|  1.92M|               return 24;
  558|  1.92M|            }
  559|  1.92M|            else if constexpr (sizeof(T) > 2) {
  560|  1.92M|               return 16;
  561|  1.92M|            }
  562|  1.92M|            else {
  563|  1.92M|               return 8;
  564|  1.92M|            }
  565|  1.92M|         }
  566|  1.92M|         else if constexpr (nullable_like<T>) {
  567|  1.92M|            if constexpr (has_value_type<T>) {
  568|  1.92M|               return required_padding<typename T::value_type>();
  569|  1.92M|            }
  570|  1.92M|            else if constexpr (has_element_type<T>) {
  571|  1.92M|               return required_padding<typename T::element_type>();
  572|  1.92M|            }
  573|  1.92M|            else {
  574|  1.92M|               return 0;
  575|  1.92M|            }
  576|  1.92M|         }
  577|  1.92M|         else if constexpr (always_null_t<T>) {
  578|  1.92M|            return 8;
  579|  1.92M|         }
  580|  1.92M|         else {
  581|  1.92M|            return 0;
  582|  1.92M|         }
  583|  1.92M|      }();
  584|       |
  585|       |      if constexpr (value >= (write_padding_bytes - 16)) {
  586|       |         // we always require 16 bytes available from write_padding_bytes
  587|       |         // for opening and closing characters
  588|       |         return 0;
  589|       |      }
  590|  1.92M|      return value;
  591|  1.92M|   }
_ZN3glz2toILj10EdE2opITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERdTkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_:
  814|  1.30M|      {
  815|  1.30M|         if constexpr (not check_write_unchecked(Opts)) {
  816|  1.30M|            static_assert(required_padding<T>());
  817|  1.30M|            if (!ensure_space(ctx, b, ix + required_padding<T>())) [[unlikely]] {
  ------------------
  |  Branch (817:17): [True: 0, False: 1.30M]
  ------------------
  818|      0|               return;
  819|      0|            }
  820|  1.30M|         }
  821|       |
  822|  1.30M|         static constexpr auto O = write_unchecked_on<Opts>();
  823|       |
  824|       |         if constexpr (check_quoted_num(Opts)) {
  825|       |            std::memcpy(&b[ix], "\"", 1);
  826|       |            ++ix;
  827|       |            write_chars::op<O>(value, ctx, b, ix);
  828|       |            std::memcpy(&b[ix], "\"", 1);
  829|       |            ++ix;
  830|       |         }
  831|  1.30M|         else {
  832|  1.30M|            write_chars::op<O>(value, ctx, b, ix);
  833|  1.30M|         }
  834|  1.30M|      }
_ZN3glz16required_paddingIdEEmv:
  538|  1.30M|   {
  539|  1.30M|      constexpr auto value = []() -> size_t {
  540|  1.30M|         if constexpr (boolean_like<T>) {
  541|  1.30M|            return 8;
  542|  1.30M|         }
  543|  1.30M|         else if constexpr (num_t<T>) {
  544|  1.30M|            if constexpr (std::floating_point<T>) {
  545|  1.30M|               if constexpr (sizeof(T) > 8) {
  546|  1.30M|                  return 64;
  547|  1.30M|               }
  548|  1.30M|               else if constexpr (sizeof(T) > 4) {
  549|       |                  // zmij scratch + 4 for optional quotes and trailing comma.
  550|  1.30M|                  return zmij::double_buffer_size + 4;
  551|  1.30M|               }
  552|  1.30M|               else {
  553|  1.30M|                  return zmij::float_buffer_size + 4;
  554|  1.30M|               }
  555|  1.30M|            }
  556|  1.30M|            else if constexpr (sizeof(T) > 4) {
  557|  1.30M|               return 24;
  558|  1.30M|            }
  559|  1.30M|            else if constexpr (sizeof(T) > 2) {
  560|  1.30M|               return 16;
  561|  1.30M|            }
  562|  1.30M|            else {
  563|  1.30M|               return 8;
  564|  1.30M|            }
  565|  1.30M|         }
  566|  1.30M|         else if constexpr (nullable_like<T>) {
  567|  1.30M|            if constexpr (has_value_type<T>) {
  568|  1.30M|               return required_padding<typename T::value_type>();
  569|  1.30M|            }
  570|  1.30M|            else if constexpr (has_element_type<T>) {
  571|  1.30M|               return required_padding<typename T::element_type>();
  572|  1.30M|            }
  573|  1.30M|            else {
  574|  1.30M|               return 0;
  575|  1.30M|            }
  576|  1.30M|         }
  577|  1.30M|         else if constexpr (always_null_t<T>) {
  578|  1.30M|            return 8;
  579|  1.30M|         }
  580|  1.30M|         else {
  581|  1.30M|            return 0;
  582|  1.30M|         }
  583|  1.30M|      }();
  584|       |
  585|       |      if constexpr (value >= (write_padding_bytes - 16)) {
  586|       |         // we always require 16 bytes available from write_padding_bytes
  587|       |         // for opening and closing characters
  588|       |         return 0;
  589|       |      }
  590|  1.30M|      return value;
  591|  1.30M|   }
_ZN3glz2toILj10EaE2opITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERaTkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_:
  814|   864k|      {
  815|   864k|         if constexpr (not check_write_unchecked(Opts)) {
  816|   864k|            static_assert(required_padding<T>());
  817|   864k|            if (!ensure_space(ctx, b, ix + required_padding<T>())) [[unlikely]] {
  ------------------
  |  Branch (817:17): [True: 0, False: 864k]
  ------------------
  818|      0|               return;
  819|      0|            }
  820|   864k|         }
  821|       |
  822|   864k|         static constexpr auto O = write_unchecked_on<Opts>();
  823|       |
  824|       |         if constexpr (check_quoted_num(Opts)) {
  825|       |            std::memcpy(&b[ix], "\"", 1);
  826|       |            ++ix;
  827|       |            write_chars::op<O>(value, ctx, b, ix);
  828|       |            std::memcpy(&b[ix], "\"", 1);
  829|       |            ++ix;
  830|       |         }
  831|   864k|         else {
  832|   864k|            write_chars::op<O>(value, ctx, b, ix);
  833|   864k|         }
  834|   864k|      }
_ZN3glz16required_paddingIaEEmv:
  538|   864k|   {
  539|   864k|      constexpr auto value = []() -> size_t {
  540|   864k|         if constexpr (boolean_like<T>) {
  541|   864k|            return 8;
  542|   864k|         }
  543|   864k|         else if constexpr (num_t<T>) {
  544|   864k|            if constexpr (std::floating_point<T>) {
  545|   864k|               if constexpr (sizeof(T) > 8) {
  546|   864k|                  return 64;
  547|   864k|               }
  548|   864k|               else if constexpr (sizeof(T) > 4) {
  549|       |                  // zmij scratch + 4 for optional quotes and trailing comma.
  550|   864k|                  return zmij::double_buffer_size + 4;
  551|   864k|               }
  552|   864k|               else {
  553|   864k|                  return zmij::float_buffer_size + 4;
  554|   864k|               }
  555|   864k|            }
  556|   864k|            else if constexpr (sizeof(T) > 4) {
  557|   864k|               return 24;
  558|   864k|            }
  559|   864k|            else if constexpr (sizeof(T) > 2) {
  560|   864k|               return 16;
  561|   864k|            }
  562|   864k|            else {
  563|   864k|               return 8;
  564|   864k|            }
  565|   864k|         }
  566|   864k|         else if constexpr (nullable_like<T>) {
  567|   864k|            if constexpr (has_value_type<T>) {
  568|   864k|               return required_padding<typename T::value_type>();
  569|   864k|            }
  570|   864k|            else if constexpr (has_element_type<T>) {
  571|   864k|               return required_padding<typename T::element_type>();
  572|   864k|            }
  573|   864k|            else {
  574|   864k|               return 0;
  575|   864k|            }
  576|   864k|         }
  577|   864k|         else if constexpr (always_null_t<T>) {
  578|   864k|            return 8;
  579|   864k|         }
  580|   864k|         else {
  581|   864k|            return 0;
  582|   864k|         }
  583|   864k|      }();
  584|       |
  585|       |      if constexpr (value >= (write_padding_bytes - 16)) {
  586|       |         // we always require 16 bytes available from write_padding_bytes
  587|       |         // for opening and closing characters
  588|       |         return 0;
  589|       |      }
  590|   864k|      return value;
  591|   864k|   }
_ZN3glz2toILj10EsE2opITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERsTkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_:
  814|  2.00M|      {
  815|  2.00M|         if constexpr (not check_write_unchecked(Opts)) {
  816|  2.00M|            static_assert(required_padding<T>());
  817|  2.00M|            if (!ensure_space(ctx, b, ix + required_padding<T>())) [[unlikely]] {
  ------------------
  |  Branch (817:17): [True: 0, False: 2.00M]
  ------------------
  818|      0|               return;
  819|      0|            }
  820|  2.00M|         }
  821|       |
  822|  2.00M|         static constexpr auto O = write_unchecked_on<Opts>();
  823|       |
  824|       |         if constexpr (check_quoted_num(Opts)) {
  825|       |            std::memcpy(&b[ix], "\"", 1);
  826|       |            ++ix;
  827|       |            write_chars::op<O>(value, ctx, b, ix);
  828|       |            std::memcpy(&b[ix], "\"", 1);
  829|       |            ++ix;
  830|       |         }
  831|  2.00M|         else {
  832|  2.00M|            write_chars::op<O>(value, ctx, b, ix);
  833|  2.00M|         }
  834|  2.00M|      }
_ZN3glz16required_paddingIsEEmv:
  538|  2.00M|   {
  539|  2.00M|      constexpr auto value = []() -> size_t {
  540|  2.00M|         if constexpr (boolean_like<T>) {
  541|  2.00M|            return 8;
  542|  2.00M|         }
  543|  2.00M|         else if constexpr (num_t<T>) {
  544|  2.00M|            if constexpr (std::floating_point<T>) {
  545|  2.00M|               if constexpr (sizeof(T) > 8) {
  546|  2.00M|                  return 64;
  547|  2.00M|               }
  548|  2.00M|               else if constexpr (sizeof(T) > 4) {
  549|       |                  // zmij scratch + 4 for optional quotes and trailing comma.
  550|  2.00M|                  return zmij::double_buffer_size + 4;
  551|  2.00M|               }
  552|  2.00M|               else {
  553|  2.00M|                  return zmij::float_buffer_size + 4;
  554|  2.00M|               }
  555|  2.00M|            }
  556|  2.00M|            else if constexpr (sizeof(T) > 4) {
  557|  2.00M|               return 24;
  558|  2.00M|            }
  559|  2.00M|            else if constexpr (sizeof(T) > 2) {
  560|  2.00M|               return 16;
  561|  2.00M|            }
  562|  2.00M|            else {
  563|  2.00M|               return 8;
  564|  2.00M|            }
  565|  2.00M|         }
  566|  2.00M|         else if constexpr (nullable_like<T>) {
  567|  2.00M|            if constexpr (has_value_type<T>) {
  568|  2.00M|               return required_padding<typename T::value_type>();
  569|  2.00M|            }
  570|  2.00M|            else if constexpr (has_element_type<T>) {
  571|  2.00M|               return required_padding<typename T::element_type>();
  572|  2.00M|            }
  573|  2.00M|            else {
  574|  2.00M|               return 0;
  575|  2.00M|            }
  576|  2.00M|         }
  577|  2.00M|         else if constexpr (always_null_t<T>) {
  578|  2.00M|            return 8;
  579|  2.00M|         }
  580|  2.00M|         else {
  581|  2.00M|            return 0;
  582|  2.00M|         }
  583|  2.00M|      }();
  584|       |
  585|       |      if constexpr (value >= (write_padding_bytes - 16)) {
  586|       |         // we always require 16 bytes available from write_padding_bytes
  587|       |         // for opening and closing characters
  588|       |         return 0;
  589|       |      }
  590|  2.00M|      return value;
  591|  2.00M|   }
_ZN3glz2toILj10EiE2opITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERiTkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_:
  814|  1.08M|      {
  815|  1.08M|         if constexpr (not check_write_unchecked(Opts)) {
  816|  1.08M|            static_assert(required_padding<T>());
  817|  1.08M|            if (!ensure_space(ctx, b, ix + required_padding<T>())) [[unlikely]] {
  ------------------
  |  Branch (817:17): [True: 0, False: 1.08M]
  ------------------
  818|      0|               return;
  819|      0|            }
  820|  1.08M|         }
  821|       |
  822|  1.08M|         static constexpr auto O = write_unchecked_on<Opts>();
  823|       |
  824|       |         if constexpr (check_quoted_num(Opts)) {
  825|       |            std::memcpy(&b[ix], "\"", 1);
  826|       |            ++ix;
  827|       |            write_chars::op<O>(value, ctx, b, ix);
  828|       |            std::memcpy(&b[ix], "\"", 1);
  829|       |            ++ix;
  830|       |         }
  831|  1.08M|         else {
  832|  1.08M|            write_chars::op<O>(value, ctx, b, ix);
  833|  1.08M|         }
  834|  1.08M|      }
_ZN3glz16required_paddingIiEEmv:
  538|  1.08M|   {
  539|  1.08M|      constexpr auto value = []() -> size_t {
  540|  1.08M|         if constexpr (boolean_like<T>) {
  541|  1.08M|            return 8;
  542|  1.08M|         }
  543|  1.08M|         else if constexpr (num_t<T>) {
  544|  1.08M|            if constexpr (std::floating_point<T>) {
  545|  1.08M|               if constexpr (sizeof(T) > 8) {
  546|  1.08M|                  return 64;
  547|  1.08M|               }
  548|  1.08M|               else if constexpr (sizeof(T) > 4) {
  549|       |                  // zmij scratch + 4 for optional quotes and trailing comma.
  550|  1.08M|                  return zmij::double_buffer_size + 4;
  551|  1.08M|               }
  552|  1.08M|               else {
  553|  1.08M|                  return zmij::float_buffer_size + 4;
  554|  1.08M|               }
  555|  1.08M|            }
  556|  1.08M|            else if constexpr (sizeof(T) > 4) {
  557|  1.08M|               return 24;
  558|  1.08M|            }
  559|  1.08M|            else if constexpr (sizeof(T) > 2) {
  560|  1.08M|               return 16;
  561|  1.08M|            }
  562|  1.08M|            else {
  563|  1.08M|               return 8;
  564|  1.08M|            }
  565|  1.08M|         }
  566|  1.08M|         else if constexpr (nullable_like<T>) {
  567|  1.08M|            if constexpr (has_value_type<T>) {
  568|  1.08M|               return required_padding<typename T::value_type>();
  569|  1.08M|            }
  570|  1.08M|            else if constexpr (has_element_type<T>) {
  571|  1.08M|               return required_padding<typename T::element_type>();
  572|  1.08M|            }
  573|  1.08M|            else {
  574|  1.08M|               return 0;
  575|  1.08M|            }
  576|  1.08M|         }
  577|  1.08M|         else if constexpr (always_null_t<T>) {
  578|  1.08M|            return 8;
  579|  1.08M|         }
  580|  1.08M|         else {
  581|  1.08M|            return 0;
  582|  1.08M|         }
  583|  1.08M|      }();
  584|       |
  585|       |      if constexpr (value >= (write_padding_bytes - 16)) {
  586|       |         // we always require 16 bytes available from write_padding_bytes
  587|       |         // for opening and closing characters
  588|       |         return 0;
  589|       |      }
  590|  1.08M|      return value;
  591|  1.08M|   }
_ZN3glz2toILj10ElE2opITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERlTkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_:
  814|   732k|      {
  815|   732k|         if constexpr (not check_write_unchecked(Opts)) {
  816|   732k|            static_assert(required_padding<T>());
  817|   732k|            if (!ensure_space(ctx, b, ix + required_padding<T>())) [[unlikely]] {
  ------------------
  |  Branch (817:17): [True: 0, False: 732k]
  ------------------
  818|      0|               return;
  819|      0|            }
  820|   732k|         }
  821|       |
  822|   732k|         static constexpr auto O = write_unchecked_on<Opts>();
  823|       |
  824|       |         if constexpr (check_quoted_num(Opts)) {
  825|       |            std::memcpy(&b[ix], "\"", 1);
  826|       |            ++ix;
  827|       |            write_chars::op<O>(value, ctx, b, ix);
  828|       |            std::memcpy(&b[ix], "\"", 1);
  829|       |            ++ix;
  830|       |         }
  831|   732k|         else {
  832|   732k|            write_chars::op<O>(value, ctx, b, ix);
  833|   732k|         }
  834|   732k|      }
_ZN3glz16required_paddingIlEEmv:
  538|   732k|   {
  539|   732k|      constexpr auto value = []() -> size_t {
  540|   732k|         if constexpr (boolean_like<T>) {
  541|   732k|            return 8;
  542|   732k|         }
  543|   732k|         else if constexpr (num_t<T>) {
  544|   732k|            if constexpr (std::floating_point<T>) {
  545|   732k|               if constexpr (sizeof(T) > 8) {
  546|   732k|                  return 64;
  547|   732k|               }
  548|   732k|               else if constexpr (sizeof(T) > 4) {
  549|       |                  // zmij scratch + 4 for optional quotes and trailing comma.
  550|   732k|                  return zmij::double_buffer_size + 4;
  551|   732k|               }
  552|   732k|               else {
  553|   732k|                  return zmij::float_buffer_size + 4;
  554|   732k|               }
  555|   732k|            }
  556|   732k|            else if constexpr (sizeof(T) > 4) {
  557|   732k|               return 24;
  558|   732k|            }
  559|   732k|            else if constexpr (sizeof(T) > 2) {
  560|   732k|               return 16;
  561|   732k|            }
  562|   732k|            else {
  563|   732k|               return 8;
  564|   732k|            }
  565|   732k|         }
  566|   732k|         else if constexpr (nullable_like<T>) {
  567|   732k|            if constexpr (has_value_type<T>) {
  568|   732k|               return required_padding<typename T::value_type>();
  569|   732k|            }
  570|   732k|            else if constexpr (has_element_type<T>) {
  571|   732k|               return required_padding<typename T::element_type>();
  572|   732k|            }
  573|   732k|            else {
  574|   732k|               return 0;
  575|   732k|            }
  576|   732k|         }
  577|   732k|         else if constexpr (always_null_t<T>) {
  578|   732k|            return 8;
  579|   732k|         }
  580|   732k|         else {
  581|   732k|            return 0;
  582|   732k|         }
  583|   732k|      }();
  584|       |
  585|       |      if constexpr (value >= (write_padding_bytes - 16)) {
  586|       |         // we always require 16 bytes available from write_padding_bytes
  587|       |         // for opening and closing characters
  588|       |         return 0;
  589|       |      }
  590|   732k|      return value;
  591|   732k|   }
_ZN3glz2toILj10EhE2opITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERhTkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_:
  814|  2.22M|      {
  815|  2.22M|         if constexpr (not check_write_unchecked(Opts)) {
  816|  2.22M|            static_assert(required_padding<T>());
  817|  2.22M|            if (!ensure_space(ctx, b, ix + required_padding<T>())) [[unlikely]] {
  ------------------
  |  Branch (817:17): [True: 0, False: 2.22M]
  ------------------
  818|      0|               return;
  819|      0|            }
  820|  2.22M|         }
  821|       |
  822|  2.22M|         static constexpr auto O = write_unchecked_on<Opts>();
  823|       |
  824|       |         if constexpr (check_quoted_num(Opts)) {
  825|       |            std::memcpy(&b[ix], "\"", 1);
  826|       |            ++ix;
  827|       |            write_chars::op<O>(value, ctx, b, ix);
  828|       |            std::memcpy(&b[ix], "\"", 1);
  829|       |            ++ix;
  830|       |         }
  831|  2.22M|         else {
  832|  2.22M|            write_chars::op<O>(value, ctx, b, ix);
  833|  2.22M|         }
  834|  2.22M|      }
_ZN3glz16required_paddingIhEEmv:
  538|  2.22M|   {
  539|  2.22M|      constexpr auto value = []() -> size_t {
  540|  2.22M|         if constexpr (boolean_like<T>) {
  541|  2.22M|            return 8;
  542|  2.22M|         }
  543|  2.22M|         else if constexpr (num_t<T>) {
  544|  2.22M|            if constexpr (std::floating_point<T>) {
  545|  2.22M|               if constexpr (sizeof(T) > 8) {
  546|  2.22M|                  return 64;
  547|  2.22M|               }
  548|  2.22M|               else if constexpr (sizeof(T) > 4) {
  549|       |                  // zmij scratch + 4 for optional quotes and trailing comma.
  550|  2.22M|                  return zmij::double_buffer_size + 4;
  551|  2.22M|               }
  552|  2.22M|               else {
  553|  2.22M|                  return zmij::float_buffer_size + 4;
  554|  2.22M|               }
  555|  2.22M|            }
  556|  2.22M|            else if constexpr (sizeof(T) > 4) {
  557|  2.22M|               return 24;
  558|  2.22M|            }
  559|  2.22M|            else if constexpr (sizeof(T) > 2) {
  560|  2.22M|               return 16;
  561|  2.22M|            }
  562|  2.22M|            else {
  563|  2.22M|               return 8;
  564|  2.22M|            }
  565|  2.22M|         }
  566|  2.22M|         else if constexpr (nullable_like<T>) {
  567|  2.22M|            if constexpr (has_value_type<T>) {
  568|  2.22M|               return required_padding<typename T::value_type>();
  569|  2.22M|            }
  570|  2.22M|            else if constexpr (has_element_type<T>) {
  571|  2.22M|               return required_padding<typename T::element_type>();
  572|  2.22M|            }
  573|  2.22M|            else {
  574|  2.22M|               return 0;
  575|  2.22M|            }
  576|  2.22M|         }
  577|  2.22M|         else if constexpr (always_null_t<T>) {
  578|  2.22M|            return 8;
  579|  2.22M|         }
  580|  2.22M|         else {
  581|  2.22M|            return 0;
  582|  2.22M|         }
  583|  2.22M|      }();
  584|       |
  585|       |      if constexpr (value >= (write_padding_bytes - 16)) {
  586|       |         // we always require 16 bytes available from write_padding_bytes
  587|       |         // for opening and closing characters
  588|       |         return 0;
  589|       |      }
  590|  2.22M|      return value;
  591|  2.22M|   }
_ZN3glz2toILj10EtE2opITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERtTkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_:
  814|  1.77M|      {
  815|  1.77M|         if constexpr (not check_write_unchecked(Opts)) {
  816|  1.77M|            static_assert(required_padding<T>());
  817|  1.77M|            if (!ensure_space(ctx, b, ix + required_padding<T>())) [[unlikely]] {
  ------------------
  |  Branch (817:17): [True: 0, False: 1.77M]
  ------------------
  818|      0|               return;
  819|      0|            }
  820|  1.77M|         }
  821|       |
  822|  1.77M|         static constexpr auto O = write_unchecked_on<Opts>();
  823|       |
  824|       |         if constexpr (check_quoted_num(Opts)) {
  825|       |            std::memcpy(&b[ix], "\"", 1);
  826|       |            ++ix;
  827|       |            write_chars::op<O>(value, ctx, b, ix);
  828|       |            std::memcpy(&b[ix], "\"", 1);
  829|       |            ++ix;
  830|       |         }
  831|  1.77M|         else {
  832|  1.77M|            write_chars::op<O>(value, ctx, b, ix);
  833|  1.77M|         }
  834|  1.77M|      }
_ZN3glz16required_paddingItEEmv:
  538|  1.77M|   {
  539|  1.77M|      constexpr auto value = []() -> size_t {
  540|  1.77M|         if constexpr (boolean_like<T>) {
  541|  1.77M|            return 8;
  542|  1.77M|         }
  543|  1.77M|         else if constexpr (num_t<T>) {
  544|  1.77M|            if constexpr (std::floating_point<T>) {
  545|  1.77M|               if constexpr (sizeof(T) > 8) {
  546|  1.77M|                  return 64;
  547|  1.77M|               }
  548|  1.77M|               else if constexpr (sizeof(T) > 4) {
  549|       |                  // zmij scratch + 4 for optional quotes and trailing comma.
  550|  1.77M|                  return zmij::double_buffer_size + 4;
  551|  1.77M|               }
  552|  1.77M|               else {
  553|  1.77M|                  return zmij::float_buffer_size + 4;
  554|  1.77M|               }
  555|  1.77M|            }
  556|  1.77M|            else if constexpr (sizeof(T) > 4) {
  557|  1.77M|               return 24;
  558|  1.77M|            }
  559|  1.77M|            else if constexpr (sizeof(T) > 2) {
  560|  1.77M|               return 16;
  561|  1.77M|            }
  562|  1.77M|            else {
  563|  1.77M|               return 8;
  564|  1.77M|            }
  565|  1.77M|         }
  566|  1.77M|         else if constexpr (nullable_like<T>) {
  567|  1.77M|            if constexpr (has_value_type<T>) {
  568|  1.77M|               return required_padding<typename T::value_type>();
  569|  1.77M|            }
  570|  1.77M|            else if constexpr (has_element_type<T>) {
  571|  1.77M|               return required_padding<typename T::element_type>();
  572|  1.77M|            }
  573|  1.77M|            else {
  574|  1.77M|               return 0;
  575|  1.77M|            }
  576|  1.77M|         }
  577|  1.77M|         else if constexpr (always_null_t<T>) {
  578|  1.77M|            return 8;
  579|  1.77M|         }
  580|  1.77M|         else {
  581|  1.77M|            return 0;
  582|  1.77M|         }
  583|  1.77M|      }();
  584|       |
  585|       |      if constexpr (value >= (write_padding_bytes - 16)) {
  586|       |         // we always require 16 bytes available from write_padding_bytes
  587|       |         // for opening and closing characters
  588|       |         return 0;
  589|       |      }
  590|  1.77M|      return value;
  591|  1.77M|   }
_ZN3glz2toILj10EjE2opITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERjTkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_:
  814|   951k|      {
  815|   951k|         if constexpr (not check_write_unchecked(Opts)) {
  816|   951k|            static_assert(required_padding<T>());
  817|   951k|            if (!ensure_space(ctx, b, ix + required_padding<T>())) [[unlikely]] {
  ------------------
  |  Branch (817:17): [True: 0, False: 951k]
  ------------------
  818|      0|               return;
  819|      0|            }
  820|   951k|         }
  821|       |
  822|   951k|         static constexpr auto O = write_unchecked_on<Opts>();
  823|       |
  824|       |         if constexpr (check_quoted_num(Opts)) {
  825|       |            std::memcpy(&b[ix], "\"", 1);
  826|       |            ++ix;
  827|       |            write_chars::op<O>(value, ctx, b, ix);
  828|       |            std::memcpy(&b[ix], "\"", 1);
  829|       |            ++ix;
  830|       |         }
  831|   951k|         else {
  832|   951k|            write_chars::op<O>(value, ctx, b, ix);
  833|   951k|         }
  834|   951k|      }
_ZN3glz16required_paddingIjEEmv:
  538|   951k|   {
  539|   951k|      constexpr auto value = []() -> size_t {
  540|   951k|         if constexpr (boolean_like<T>) {
  541|   951k|            return 8;
  542|   951k|         }
  543|   951k|         else if constexpr (num_t<T>) {
  544|   951k|            if constexpr (std::floating_point<T>) {
  545|   951k|               if constexpr (sizeof(T) > 8) {
  546|   951k|                  return 64;
  547|   951k|               }
  548|   951k|               else if constexpr (sizeof(T) > 4) {
  549|       |                  // zmij scratch + 4 for optional quotes and trailing comma.
  550|   951k|                  return zmij::double_buffer_size + 4;
  551|   951k|               }
  552|   951k|               else {
  553|   951k|                  return zmij::float_buffer_size + 4;
  554|   951k|               }
  555|   951k|            }
  556|   951k|            else if constexpr (sizeof(T) > 4) {
  557|   951k|               return 24;
  558|   951k|            }
  559|   951k|            else if constexpr (sizeof(T) > 2) {
  560|   951k|               return 16;
  561|   951k|            }
  562|   951k|            else {
  563|   951k|               return 8;
  564|   951k|            }
  565|   951k|         }
  566|   951k|         else if constexpr (nullable_like<T>) {
  567|   951k|            if constexpr (has_value_type<T>) {
  568|   951k|               return required_padding<typename T::value_type>();
  569|   951k|            }
  570|   951k|            else if constexpr (has_element_type<T>) {
  571|   951k|               return required_padding<typename T::element_type>();
  572|   951k|            }
  573|   951k|            else {
  574|   951k|               return 0;
  575|   951k|            }
  576|   951k|         }
  577|   951k|         else if constexpr (always_null_t<T>) {
  578|   951k|            return 8;
  579|   951k|         }
  580|   951k|         else {
  581|   951k|            return 0;
  582|   951k|         }
  583|   951k|      }();
  584|       |
  585|       |      if constexpr (value >= (write_padding_bytes - 16)) {
  586|       |         // we always require 16 bytes available from write_padding_bytes
  587|       |         // for opening and closing characters
  588|       |         return 0;
  589|       |      }
  590|   951k|      return value;
  591|   951k|   }
_ZN3glz2toILj10EmE2opITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERmTkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_:
  814|   465k|      {
  815|   465k|         if constexpr (not check_write_unchecked(Opts)) {
  816|   465k|            static_assert(required_padding<T>());
  817|   465k|            if (!ensure_space(ctx, b, ix + required_padding<T>())) [[unlikely]] {
  ------------------
  |  Branch (817:17): [True: 0, False: 465k]
  ------------------
  818|      0|               return;
  819|      0|            }
  820|   465k|         }
  821|       |
  822|   465k|         static constexpr auto O = write_unchecked_on<Opts>();
  823|       |
  824|       |         if constexpr (check_quoted_num(Opts)) {
  825|       |            std::memcpy(&b[ix], "\"", 1);
  826|       |            ++ix;
  827|       |            write_chars::op<O>(value, ctx, b, ix);
  828|       |            std::memcpy(&b[ix], "\"", 1);
  829|       |            ++ix;
  830|       |         }
  831|   465k|         else {
  832|   465k|            write_chars::op<O>(value, ctx, b, ix);
  833|   465k|         }
  834|   465k|      }
_ZN3glz16required_paddingImEEmv:
  538|   465k|   {
  539|   465k|      constexpr auto value = []() -> size_t {
  540|   465k|         if constexpr (boolean_like<T>) {
  541|   465k|            return 8;
  542|   465k|         }
  543|   465k|         else if constexpr (num_t<T>) {
  544|   465k|            if constexpr (std::floating_point<T>) {
  545|   465k|               if constexpr (sizeof(T) > 8) {
  546|   465k|                  return 64;
  547|   465k|               }
  548|   465k|               else if constexpr (sizeof(T) > 4) {
  549|       |                  // zmij scratch + 4 for optional quotes and trailing comma.
  550|   465k|                  return zmij::double_buffer_size + 4;
  551|   465k|               }
  552|   465k|               else {
  553|   465k|                  return zmij::float_buffer_size + 4;
  554|   465k|               }
  555|   465k|            }
  556|   465k|            else if constexpr (sizeof(T) > 4) {
  557|   465k|               return 24;
  558|   465k|            }
  559|   465k|            else if constexpr (sizeof(T) > 2) {
  560|   465k|               return 16;
  561|   465k|            }
  562|   465k|            else {
  563|   465k|               return 8;
  564|   465k|            }
  565|   465k|         }
  566|   465k|         else if constexpr (nullable_like<T>) {
  567|   465k|            if constexpr (has_value_type<T>) {
  568|   465k|               return required_padding<typename T::value_type>();
  569|   465k|            }
  570|   465k|            else if constexpr (has_element_type<T>) {
  571|   465k|               return required_padding<typename T::element_type>();
  572|   465k|            }
  573|   465k|            else {
  574|   465k|               return 0;
  575|   465k|            }
  576|   465k|         }
  577|   465k|         else if constexpr (always_null_t<T>) {
  578|   465k|            return 8;
  579|   465k|         }
  580|   465k|         else {
  581|   465k|            return 0;
  582|   465k|         }
  583|   465k|      }();
  584|       |
  585|       |      if constexpr (value >= (write_padding_bytes - 16)) {
  586|       |         // we always require 16 bytes available from write_padding_bytes
  587|       |         // for opening and closing characters
  588|       |         return 0;
  589|       |      }
  590|   465k|      return value;
  591|   465k|   }
_ZN3glz6detail21emit_untrusted_stringITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEETkNS_10is_contextENS_7contextEEEvRT1_NS3_17basic_string_viewIcS6_EERT0_Rm:
 1140|  1.91M|      {
 1141|  1.91M|         to<JSON, std::string_view>::template op<untrusted_string_emit_opts<Opts>>(s, ctx, out, ix);
 1142|  1.91M|      }
_ZN3glz2toILj10ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEE2opITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj256EEERNS1_12basic_stringIcS4_NS1_9allocatorIcEEEERKS5_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_:
  845|  1.91M|      {
  846|       |         if constexpr (check_string_as_number(Opts)) {
  847|       |            const sv str = [&]() -> const sv {
  848|       |               if constexpr (array_char_t<T>) {
  849|       |                  const auto* start = value.data();
  850|       |                  const auto* end = static_cast<const char*>(std::memchr(start, '\0', value.size()));
  851|       |                  return sv{start, end ? size_t(end - start) : value.size()};
  852|       |               }
  853|       |               else if constexpr (u8str_t<T>) {
  854|       |                  return sv{reinterpret_cast<const char*>(value.data()), value.size()};
  855|       |               }
  856|       |               else {
  857|       |                  return str_view<T>(value);
  858|       |               }
  859|       |            }();
  860|       |            if (!ensure_space(ctx, b, ix + str.size() + write_padding_bytes)) [[unlikely]] {
  861|       |               return;
  862|       |            }
  863|       |            dump_maybe_empty<false>(str, b, ix);
  864|       |         }
  865|       |         else if constexpr (char_t<T>) {
  866|       |            if constexpr (check_unquoted(Opts)) {
  867|       |               dump(value, b, ix);
  868|       |            }
  869|       |            else {
  870|       |               // 8 bytes is enough for quotes and escaped character (worst case: \uXXXX = 6 + 2 quotes)
  871|       |               if (!ensure_space(ctx, b, ix + 8)) [[unlikely]] {
  872|       |                  return;
  873|       |               }
  874|       |
  875|       |               std::memcpy(&b[ix], "\"", 1);
  876|       |               ++ix;
  877|       |               if (const auto escaped = char_escape_table[uint8_t(value)]; escaped) {
  878|       |                  std::memcpy(&b[ix], &escaped, 2);
  879|       |                  ix += 2;
  880|       |               }
  881|       |               else if (value == '\0') {
  882|       |                  // null character treated as empty string
  883|       |               }
  884|       |               else if constexpr (check_escape_control_characters(Opts)) {
  885|       |                  if (uint8_t(value) < 0x20) {
  886|       |                     // Write as \uXXXX format
  887|       |                     char unicode_escape[6] = {'\\', 'u', '0', '0', '0', '0'};
  888|       |                     constexpr char hex_digits[] = "0123456789ABCDEF";
  889|       |                     unicode_escape[4] = hex_digits[(value >> 4) & 0xF];
  890|       |                     unicode_escape[5] = hex_digits[value & 0xF];
  891|       |                     std::memcpy(&b[ix], unicode_escape, 6);
  892|       |                     ix += 6;
  893|       |                  }
  894|       |                  else {
  895|       |                     std::memcpy(&b[ix], &value, 1);
  896|       |                     ++ix;
  897|       |                  }
  898|       |               }
  899|       |               else {
  900|       |                  if constexpr (check_reject_control_characters(Opts)) {
  901|       |                     if (uint8_t(value) < 0x20) [[unlikely]] {
  902|       |                        ctx.error = error_code::invalid_control_character;
  903|       |                     }
  904|       |                  }
  905|       |                  std::memcpy(&b[ix], &value, 1);
  906|       |                  ++ix;
  907|       |               }
  908|       |               std::memcpy(&b[ix], "\"", 1);
  909|       |               ++ix;
  910|       |            }
  911|       |         }
  912|  1.91M|         else {
  913|       |            if constexpr (check_raw_string(Opts)) {
  914|       |               const sv str = [&]() -> const sv {
  915|       |                  if constexpr (u8str_t<T>) {
  916|       |                     return sv{reinterpret_cast<const char*>(value.data()), value.size()};
  917|       |                  }
  918|       |                  else {
  919|       |                     return str_view<T>(value);
  920|       |                  }
  921|       |               }();
  922|       |
  923|       |               // We need space for quotes and the string length: 2 + n.
  924|       |               // Use +8 for extra buffer
  925|       |               if (!ensure_space(ctx, b, ix + 8 + str.size())) [[unlikely]] {
  926|       |                  return;
  927|       |               }
  928|       |               // now we don't have to check writing
  929|       |
  930|       |               if constexpr (not check_unquoted(Opts)) {
  931|       |                  std::memcpy(&b[ix], "\"", 1);
  932|       |                  ++ix;
  933|       |               }
  934|       |               if (str.size()) [[likely]] {
  935|       |                  const auto n = str.size();
  936|       |                  std::memcpy(&b[ix], str.data(), n);
  937|       |                  ix += n;
  938|       |               }
  939|       |               if constexpr (not check_unquoted(Opts)) {
  940|       |                  std::memcpy(&b[ix], "\"", 1);
  941|       |                  ++ix;
  942|       |               }
  943|       |            }
  944|  1.91M|            else {
  945|  1.91M|               const sv str = [&]() -> const sv {
  946|  1.91M|                  if constexpr (array_char_t<T>) {
  947|  1.91M|                     return sv{value.data(), value.size()};
  948|  1.91M|                  }
  949|  1.91M|                  else if constexpr (u8str_t<T>) {
  950|  1.91M|                     return sv{reinterpret_cast<const char*>(value.data()), value.size()};
  951|  1.91M|                  }
  952|  1.91M|                  else {
  953|  1.91M|                     return str_view<T>(value);
  954|  1.91M|                  }
  955|  1.91M|               }();
  956|  1.91M|               const auto n = str.size();
  957|       |
  958|       |               // In the case n == 0 we need two characters for quotes.
  959|       |               // For each individual character we need room for two characters to handle escapes.
  960|       |               // When using Unicode escapes, we might need up to 6 characters (\uXXXX) per character
  961|       |               if constexpr (check_escape_control_characters(Opts)) {
  962|       |                  if constexpr (has_bounded_capacity<B>) {
  963|       |                     // 6 bytes per character is a ceiling only a string of nothing but control
  964|       |                     // characters reaches. A resizable buffer merely over-allocates against it,
  965|       |                     // but a fixed buffer has nowhere to grow, so the ceiling would reject output
  966|       |                     // that fits. Measuring the string answers exactly, at the cost of a pass over
  967|       |                     // it, so bracket the measurement between two O(1) bounds and only pay it when
  968|       |                     // the answer is still in doubt: the ceiling fitting means yes, and the floor
  969|       |                     // of one byte per character not fitting means no.
  970|       |                     const size_t capacity = buffer_traits<std::remove_cvref_t<B>>::capacity(b);
  971|       |                     size_t required = ix + 10 + 6 * n;
  972|       |                     if (required > capacity) [[unlikely]] {
  973|       |                        required = ix + 10 + n;
  974|       |                        if (required <= capacity) {
  975|       |                           required = ix + 10 + detail::escaped_string_size(str);
  976|       |                        }
  977|       |                     }
  978|       |                     if (!ensure_space(ctx, b, required)) [[unlikely]] {
  979|       |                        return;
  980|       |                     }
  981|       |                  }
  982|       |                  // We need 2 + 6 * n characters in the worst case (all control chars)
  983|       |                  else if (!ensure_space(ctx, b, ix + 10 + 6 * n)) [[unlikely]] {
  984|       |                     return;
  985|       |                  }
  986|       |               }
  987|  1.91M|               else {
  988|       |                  // Using the original sizing
  989|  1.91M|                  if (!ensure_space(ctx, b, ix + 10 + 2 * n)) [[unlikely]] {
  ------------------
  |  Branch (989:23): [True: 0, False: 1.91M]
  ------------------
  990|      0|                     return;
  991|      0|                  }
  992|  1.91M|               }
  993|       |               // now we don't have to check writing
  994|       |
  995|       |               if constexpr (check_unquoted(Opts)) {
  996|       |                  if (n) {
  997|       |                     std::memcpy(&b[ix], str.data(), n);
  998|       |                     ix += n;
  999|       |                  }
 1000|       |               }
 1001|  1.91M|               else {
 1002|  1.91M|                  std::memcpy(&b[ix], "\"", 1);
 1003|  1.91M|                  ++ix;
 1004|       |
 1005|  1.91M|                  const auto* c = str.data();
 1006|  1.91M|                  const auto* const e = c + n;
 1007|  1.91M|                  const auto start = &b[ix];
 1008|  1.91M|                  auto data = start;
 1009|       |
 1010|       |                  // By default we don't escape control characters for performance. Invalid JSON characters
 1011|       |                  // result in null characters in the output, making the JSON invalid — these would then be
 1012|       |                  // detected upon reading. Enable the `escape_control_characters` option to properly escape
 1013|       |                  // control characters (0x00–0x1F) as \uXXXX sequences.
 1014|       |
 1015|       |                  // Escape handler: writes the escaped form of *c into data, advances both pointers
 1016|  1.91M|                  auto write_escape = [&]() {
 1017|  1.91M|                     if constexpr (check_escape_control_characters(Opts)) {
 1018|  1.91M|                        if (const auto escaped = char_escape_table[uint8_t(*c)]; escaped) {
 1019|  1.91M|                           std::memcpy(data, &escaped, 2);
 1020|  1.91M|                           data += 2;
 1021|  1.91M|                        }
 1022|  1.91M|                        else {
 1023|  1.91M|                           char unicode_escape[6] = {'\\', 'u', '0', '0', '0', '0'};
 1024|  1.91M|                           constexpr char hex_digits[] = "0123456789ABCDEF";
 1025|  1.91M|                           unicode_escape[4] = hex_digits[(uint8_t(*c) >> 4) & 0xF];
 1026|  1.91M|                           unicode_escape[5] = hex_digits[uint8_t(*c) & 0xF];
 1027|  1.91M|                           std::memcpy(data, unicode_escape, 6);
 1028|  1.91M|                           data += 6;
 1029|  1.91M|                        }
 1030|  1.91M|                     }
 1031|  1.91M|                     else {
 1032|  1.91M|                        if constexpr (check_reject_control_characters(Opts)) {
 1033|       |                           // A control character with no two-character escape cannot be written
 1034|       |                           // without \uXXXX. The table entry is zero, so the memcpy below would
 1035|       |                           // put two NULs where one byte was. Flag it and let the loop finish:
 1036|       |                           // returning early here would leave c un-advanced and the SIMD scan
 1037|       |                           // would find the same byte forever. The output is abandoned anyway.
 1038|  1.91M|                           if (char_escape_table[uint8_t(*c)] == 0) [[unlikely]] {
 1039|  1.91M|                              ctx.error = error_code::invalid_control_character;
 1040|  1.91M|                           }
 1041|  1.91M|                        }
 1042|  1.91M|                        std::memcpy(data, &char_escape_table[uint8_t(*c)], 2);
 1043|  1.91M|                        data += 2;
 1044|  1.91M|                     }
 1045|  1.91M|                     ++c;
 1046|  1.91M|                  };
 1047|       |
 1048|       |                  // Adding a helper here means adding a branch to string_escape_simd() in
 1049|       |                  // simd/backends.hpp, which names the widest one this cascade invokes, and a row
 1050|       |                  // to known_builds in tests/json_test/utf8_validation_test.cpp, which checks it.
 1051|       |#if defined(GLZ_USE_AVX2)
 1052|       |                  detail::avx2_string_escape(c, e, data, n, write_escape);
 1053|       |#endif
 1054|  1.91M|#if defined(GLZ_USE_SSE2)
 1055|  1.91M|                  detail::sse2_string_escape(c, e, data, n, write_escape);
 1056|       |#elif defined(GLZ_USE_NEON)
 1057|       |                  detail::neon_string_escape(c, e, data, n, write_escape);
 1058|       |#endif
 1059|       |
 1060|       |                  // SWAR: 8 bytes at a time
 1061|  1.91M|                  if (n > 7) {
  ------------------
  |  Branch (1061:23): [True: 1.13k, False: 1.91M]
  ------------------
 1062|  3.40k|                     for (const auto end_m7 = e - 7; c < end_m7;) {
  ------------------
  |  Branch (1062:54): [True: 2.26k, False: 1.13k]
  ------------------
 1063|  2.26k|                        std::memcpy(data, c, 8);
 1064|  2.26k|                        uint64_t swar;
 1065|  2.26k|                        std::memcpy(&swar, c, 8);
 1066|       |                        if constexpr (std::endian::native == std::endian::big) {
 1067|       |                           swar = std::byteswap(swar);
 1068|       |                        }
 1069|       |
 1070|  2.26k|                        constexpr uint64_t lo7_mask = repeat_byte8(0b01111111);
 1071|  2.26k|                        const uint64_t lo7 = swar & lo7_mask;
 1072|  2.26k|                        const uint64_t quote = (lo7 ^ repeat_byte8('"')) + lo7_mask;
 1073|  2.26k|                        const uint64_t backslash = (lo7 ^ repeat_byte8('\\')) + lo7_mask;
 1074|  2.26k|                        const uint64_t less_32 = (swar & repeat_byte8(0b01100000)) + lo7_mask;
 1075|  2.26k|                        uint64_t next = ~((quote & backslash & less_32) | swar);
 1076|       |
 1077|  2.26k|                        next &= repeat_byte8(0b10000000);
 1078|  2.26k|                        if (next == 0) {
  ------------------
  |  Branch (1078:29): [True: 392, False: 1.87k]
  ------------------
 1079|    392|                           data += 8;
 1080|    392|                           c += 8;
 1081|    392|                           continue;
 1082|    392|                        }
 1083|       |
 1084|  1.87k|                        const auto length = (countr_zero(next) >> 3);
 1085|  1.87k|                        c += length;
 1086|  1.87k|                        data += length;
 1087|  1.87k|                        write_escape();
 1088|  1.87k|                     }
 1089|  1.13k|                  }
 1090|       |
 1091|       |                  // Scalar tail
 1092|  1.93M|                  for (; c < e; ++c) {
  ------------------
  |  Branch (1092:26): [True: 18.0k, False: 1.91M]
  ------------------
 1093|  18.0k|                     if (const auto escaped = char_escape_table[uint8_t(*c)]; escaped) {
  ------------------
  |  Branch (1093:79): [True: 1.38k, False: 16.6k]
  ------------------
 1094|  1.38k|                        std::memcpy(data, &escaped, 2);
 1095|  1.38k|                        data += 2;
 1096|  1.38k|                     }
 1097|       |                     else if constexpr (check_escape_control_characters(Opts)) {
 1098|       |                        if (uint8_t(*c) < 0x20) {
 1099|       |                           char unicode_escape[6] = {'\\', 'u', '0', '0', '0', '0'};
 1100|       |                           constexpr char hex_digits[] = "0123456789ABCDEF";
 1101|       |                           unicode_escape[4] = hex_digits[(uint8_t(*c) >> 4) & 0xF];
 1102|       |                           unicode_escape[5] = hex_digits[uint8_t(*c) & 0xF];
 1103|       |                           std::memcpy(data, unicode_escape, 6);
 1104|       |                           data += 6;
 1105|       |                        }
 1106|       |                        else {
 1107|       |                           std::memcpy(data, c, 1);
 1108|       |                           ++data;
 1109|       |                        }
 1110|       |                     }
 1111|  16.6k|                     else {
 1112|  16.6k|                        if constexpr (check_reject_control_characters(Opts)) {
 1113|  16.6k|                           if (uint8_t(*c) < 0x20) [[unlikely]] {
  ------------------
  |  Branch (1113:32): [True: 1.32k, False: 15.3k]
  ------------------
 1114|  1.32k|                              ctx.error = error_code::invalid_control_character;
 1115|  1.32k|                           }
 1116|  16.6k|                        }
 1117|  16.6k|                        std::memcpy(data, c, 1);
 1118|  16.6k|                        ++data;
 1119|  16.6k|                     }
 1120|  18.0k|                  }
 1121|       |
 1122|  1.91M|                  ix += size_t(data - start);
 1123|       |
 1124|  1.91M|                  std::memcpy(&b[ix], "\"", 1);
 1125|  1.91M|                  ++ix;
 1126|  1.91M|               }
 1127|  1.91M|            }
 1128|  1.91M|         }
 1129|  1.91M|      }
_ZZN3glz2toILj10ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEE2opITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj256EEERNS1_12basic_stringIcS4_NS1_9allocatorIcEEEERKS5_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_ENKUlvE_clEv:
  945|  1.91M|               const sv str = [&]() -> const sv {
  946|       |                  if constexpr (array_char_t<T>) {
  947|       |                     return sv{value.data(), value.size()};
  948|       |                  }
  949|       |                  else if constexpr (u8str_t<T>) {
  950|       |                     return sv{reinterpret_cast<const char*>(value.data()), value.size()};
  951|       |                  }
  952|  1.91M|                  else {
  953|  1.91M|                     return str_view<T>(value);
  954|  1.91M|                  }
  955|  1.91M|               }();
_ZZN3glz2toILj10ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEE2opITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj256EEERNS1_12basic_stringIcS4_NS1_9allocatorIcEEEERKS5_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_ENKUlvE0_clEv:
 1016|  3.28M|                  auto write_escape = [&]() {
 1017|       |                     if constexpr (check_escape_control_characters(Opts)) {
 1018|       |                        if (const auto escaped = char_escape_table[uint8_t(*c)]; escaped) {
 1019|       |                           std::memcpy(data, &escaped, 2);
 1020|       |                           data += 2;
 1021|       |                        }
 1022|       |                        else {
 1023|       |                           char unicode_escape[6] = {'\\', 'u', '0', '0', '0', '0'};
 1024|       |                           constexpr char hex_digits[] = "0123456789ABCDEF";
 1025|       |                           unicode_escape[4] = hex_digits[(uint8_t(*c) >> 4) & 0xF];
 1026|       |                           unicode_escape[5] = hex_digits[uint8_t(*c) & 0xF];
 1027|       |                           std::memcpy(data, unicode_escape, 6);
 1028|       |                           data += 6;
 1029|       |                        }
 1030|       |                     }
 1031|  3.28M|                     else {
 1032|  3.28M|                        if constexpr (check_reject_control_characters(Opts)) {
 1033|       |                           // A control character with no two-character escape cannot be written
 1034|       |                           // without \uXXXX. The table entry is zero, so the memcpy below would
 1035|       |                           // put two NULs where one byte was. Flag it and let the loop finish:
 1036|       |                           // returning early here would leave c un-advanced and the SIMD scan
 1037|       |                           // would find the same byte forever. The output is abandoned anyway.
 1038|  3.28M|                           if (char_escape_table[uint8_t(*c)] == 0) [[unlikely]] {
  ------------------
  |  Branch (1038:32): [True: 3.18M, False: 104k]
  ------------------
 1039|  3.18M|                              ctx.error = error_code::invalid_control_character;
 1040|  3.18M|                           }
 1041|  3.28M|                        }
 1042|  3.28M|                        std::memcpy(data, &char_escape_table[uint8_t(*c)], 2);
 1043|  3.28M|                        data += 2;
 1044|  3.28M|                     }
 1045|  3.28M|                     ++c;
 1046|  3.28M|                  };
_ZN3glz6detail12emit_literalITnNS_14string_literalEXtlNS2_ILm10EEEtlA10_cLc34ELc108ELc97ELc121ELc111ELc117ELc116ELc34ELc58EEEENSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEETkNS_10is_contextENS_7contextEEEbRT1_RT0_Rm:
 1164|  6.44M|      {
 1165|  6.44M|         static constexpr auto s = str.sv();
 1166|  6.44M|         if (!ensure_space(ctx, out, ix + s.size())) [[unlikely]] {
  ------------------
  |  Branch (1166:14): [True: 0, False: 6.44M]
  ------------------
 1167|      0|            return false;
 1168|      0|         }
 1169|  6.44M|         dump<false>(s, out, ix);
 1170|  6.44M|         return true;
 1171|  6.44M|      }
_ZN3glz6detail12emit_literalITnNS_14string_literalEXtlNS2_ILm15EEEtlA15_cLc34ELc108ELc97ELc121ELc111ELc117ELc116ELc95ELc114ELc105ELc103ELc104ELc116ELc34EEEENSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEETkNS_10is_contextENS_7contextEEEbRT1_RT0_Rm:
 1164|   144k|      {
 1165|   144k|         static constexpr auto s = str.sv();
 1166|   144k|         if (!ensure_space(ctx, out, ix + s.size())) [[unlikely]] {
  ------------------
  |  Branch (1166:14): [True: 0, False: 144k]
  ------------------
 1167|      0|            return false;
 1168|      0|         }
 1169|   144k|         dump<false>(s, out, ix);
 1170|   144k|         return true;
 1171|   144k|      }
_ZN3glz6detail12emit_literalITnNS_14string_literalEXtlNS2_ILm14EEEtlA14_cLc34ELc108ELc97ELc121ELc111ELc117ELc116ELc95ELc108ELc101ELc102ELc116ELc34EEEENSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEETkNS_10is_contextENS_7contextEEEbRT1_RT0_Rm:
 1164|  6.29M|      {
 1165|  6.29M|         static constexpr auto s = str.sv();
 1166|  6.29M|         if (!ensure_space(ctx, out, ix + s.size())) [[unlikely]] {
  ------------------
  |  Branch (1166:14): [True: 0, False: 6.29M]
  ------------------
 1167|      0|            return false;
 1168|      0|         }
 1169|  6.29M|         dump<false>(s, out, ix);
 1170|  6.29M|         return true;
 1171|  6.29M|      }
_ZN3glz6detail12emit_literalITnNS_14string_literalEXtlNS2_ILm11EEEtlA11_cLc34ELc101ELc120ELc116ELc101ELc110ELc116ELc115ELc34ELc58EEEENSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEETkNS_10is_contextENS_7contextEEEbRT1_RT0_Rm:
 1164|  6.44M|      {
 1165|  6.44M|         static constexpr auto s = str.sv();
 1166|  6.44M|         if (!ensure_space(ctx, out, ix + s.size())) [[unlikely]] {
  ------------------
  |  Branch (1166:14): [True: 0, False: 6.44M]
  ------------------
 1167|      0|            return false;
 1168|      0|         }
 1169|  6.44M|         dump<false>(s, out, ix);
 1170|  6.44M|         return true;
 1171|  6.44M|      }
_ZN3glz6detail12emit_literalITnNS_14string_literalEXtlNS2_ILm9EEEtlA9_cLc34ELc118ELc97ELc108ELc117ELc101ELc34ELc58EEEENSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEETkNS_10is_contextENS_7contextEEEbRT1_RT0_Rm:
 1164|  6.41M|      {
 1165|  6.41M|         static constexpr auto s = str.sv();
 1166|  6.41M|         if (!ensure_space(ctx, out, ix + s.size())) [[unlikely]] {
  ------------------
  |  Branch (1166:14): [True: 0, False: 6.41M]
  ------------------
 1167|      0|            return false;
 1168|      0|         }
 1169|  6.41M|         dump<false>(s, out, ix);
 1170|  6.41M|         return true;
 1171|  6.41M|      }

_ZN3glz6to_tieIR9my_structLm4EQleT0_L_ZNS_6detail25max_pure_reflection_countEEEEDcOT_:
  137|  13.1k|   {
  138|       |      if constexpr (N == 0) {
  139|       |         return tuple{};
  140|       |      }
  141|       |      else if constexpr (N == 1) {
  142|       |         auto& [p] = t;
  143|       |         return glz::tie(p);
  144|       |      }
  145|       |      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|  13.1k|      else if constexpr (N == 4) {
  154|  13.1k|         auto& [p0, p1, p2, p3] = t;
  155|  13.1k|         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|  13.1k|   }

_ZN3glz6detail18sse2_string_escapeIcRZNS_2toILj10ENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEE2opITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj256EEERNS3_12basic_stringIcS6_NS3_9allocatorIcEEEERKS7_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_EUlvE0_EEvRPKcSV_RPT_mSP_:
   20|  1.91M|   {
   21|       |      // SSE2: 16 bytes at a time with direct comparison instructions
   22|  1.91M|      if (n > 15) {
  ------------------
  |  Branch (22:11): [True: 838, False: 1.91M]
  ------------------
   23|    838|         const __m128i quote_vec = _mm_set1_epi8('"');
   24|    838|         const __m128i bs_vec = _mm_set1_epi8('\\');
   25|    838|         const __m128i ctrl_mask = _mm_set1_epi8(static_cast<int8_t>(0xE0));
   26|    838|         const __m128i zero = _mm_setzero_si128();
   27|       |
   28|  3.35M|         for (const char* end_m15 = e - 15; c < end_m15;) {
  ------------------
  |  Branch (28:45): [True: 3.35M, False: 838]
  ------------------
   29|  3.35M|            __m128i v = _mm_loadu_si128(reinterpret_cast<const __m128i*>(c));
   30|  3.35M|            _mm_storeu_si128(reinterpret_cast<__m128i*>(data), v);
   31|       |
   32|  3.35M|            const uint32_t mask = static_cast<uint32_t>(
   33|  3.35M|               _mm_movemask_epi8(_mm_or_si128(_mm_or_si128(_mm_cmpeq_epi8(v, quote_vec), _mm_cmpeq_epi8(v, bs_vec)),
   34|  3.35M|                                              _mm_cmpeq_epi8(_mm_and_si128(v, ctrl_mask), zero))));
   35|       |
   36|  3.35M|            if (mask == 0) {
  ------------------
  |  Branch (36:17): [True: 65.8k, False: 3.28M]
  ------------------
   37|  65.8k|               data += 16;
   38|  65.8k|               c += 16;
   39|  65.8k|               continue;
   40|  65.8k|            }
   41|       |
   42|  3.28M|            const uint32_t length = countr_zero(mask);
   43|  3.28M|            c += length;
   44|  3.28M|            data += length;
   45|  3.28M|            write_escape();
   46|  3.28M|         }
   47|    838|      }
   48|  1.91M|   }

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

_ZN3glz7compareILm1EcEEbPKT0_S3_:
  122|  6.54k|   {
  123|       |      if constexpr (Count > 8) {
  124|       |         return 0 == std::memcmp(lhs, rhs, Count);
  125|       |         // return internal_compare(lhs, rhs, Count);
  126|       |      }
  127|       |      else if constexpr (Count == 8) {
  128|       |         uint64_t l, r;
  129|       |         std::memcpy(&l, lhs, 8);
  130|       |         std::memcpy(&r, rhs, 8);
  131|       |         return l == r;
  132|       |      }
  133|       |      else if constexpr (Count == 7) {
  134|       |         uint32_t l, r;
  135|       |         std::memcpy(&l, lhs, 4);
  136|       |         std::memcpy(&r, rhs, 4);
  137|       |         uint32_t l2, r2;
  138|       |         std::memcpy(&l2, lhs + 3, 4);
  139|       |         std::memcpy(&r2, rhs + 3, 4);
  140|       |         return (l == r) & (l2 == r2);
  141|       |      }
  142|       |      else if constexpr (Count == 6) {
  143|       |         uint32_t l, r;
  144|       |         std::memcpy(&l, lhs, 4);
  145|       |         std::memcpy(&r, rhs, 4);
  146|       |         uint16_t l2, r2;
  147|       |         std::memcpy(&l2, lhs + 4, 2);
  148|       |         std::memcpy(&r2, rhs + 4, 2);
  149|       |         return (l == r) & (l2 == r2);
  150|       |      }
  151|       |      else if constexpr (Count == 5) {
  152|       |         uint32_t l, r;
  153|       |         std::memcpy(&l, lhs, 4);
  154|       |         std::memcpy(&r, rhs, 4);
  155|       |         return (l == r) & (lhs[4] == rhs[4]);
  156|       |      }
  157|       |      else if constexpr (Count == 4) {
  158|       |         uint32_t l, r;
  159|       |         std::memcpy(&l, lhs, 4);
  160|       |         std::memcpy(&r, rhs, 4);
  161|       |         return l == r;
  162|       |      }
  163|       |      else if constexpr (Count == 3) {
  164|       |         uint16_t l, r;
  165|       |         std::memcpy(&l, lhs, 2);
  166|       |         std::memcpy(&r, rhs, 2);
  167|       |         return (l == r) & (lhs[2] == rhs[2]);
  168|       |      }
  169|       |      else if constexpr (Count == 2) {
  170|       |         uint16_t l, r;
  171|       |         std::memcpy(&l, lhs, 2);
  172|       |         std::memcpy(&r, rhs, 2);
  173|       |         return l == r;
  174|       |      }
  175|  6.54k|      else if constexpr (Count == 1) {
  176|  6.54k|         return *lhs == *rhs;
  177|       |      }
  178|       |      else if constexpr (Count == 0) {
  179|       |         return true;
  180|       |      }
  181|  6.54k|   }
_ZN3glz7compareILm5EcEEbPKT0_S3_:
  122|  2.15k|   {
  123|       |      if constexpr (Count > 8) {
  124|       |         return 0 == std::memcmp(lhs, rhs, Count);
  125|       |         // return internal_compare(lhs, rhs, Count);
  126|       |      }
  127|       |      else if constexpr (Count == 8) {
  128|       |         uint64_t l, r;
  129|       |         std::memcpy(&l, lhs, 8);
  130|       |         std::memcpy(&r, rhs, 8);
  131|       |         return l == r;
  132|       |      }
  133|       |      else if constexpr (Count == 7) {
  134|       |         uint32_t l, r;
  135|       |         std::memcpy(&l, lhs, 4);
  136|       |         std::memcpy(&r, rhs, 4);
  137|       |         uint32_t l2, r2;
  138|       |         std::memcpy(&l2, lhs + 3, 4);
  139|       |         std::memcpy(&r2, rhs + 3, 4);
  140|       |         return (l == r) & (l2 == r2);
  141|       |      }
  142|       |      else if constexpr (Count == 6) {
  143|       |         uint32_t l, r;
  144|       |         std::memcpy(&l, lhs, 4);
  145|       |         std::memcpy(&r, rhs, 4);
  146|       |         uint16_t l2, r2;
  147|       |         std::memcpy(&l2, lhs + 4, 2);
  148|       |         std::memcpy(&r2, rhs + 4, 2);
  149|       |         return (l == r) & (l2 == r2);
  150|       |      }
  151|  2.15k|      else if constexpr (Count == 5) {
  152|  2.15k|         uint32_t l, r;
  153|  2.15k|         std::memcpy(&l, lhs, 4);
  154|  2.15k|         std::memcpy(&r, rhs, 4);
  155|  2.15k|         return (l == r) & (lhs[4] == rhs[4]);
  156|       |      }
  157|       |      else if constexpr (Count == 4) {
  158|       |         uint32_t l, r;
  159|       |         std::memcpy(&l, lhs, 4);
  160|       |         std::memcpy(&r, rhs, 4);
  161|       |         return l == r;
  162|       |      }
  163|       |      else if constexpr (Count == 3) {
  164|       |         uint16_t l, r;
  165|       |         std::memcpy(&l, lhs, 2);
  166|       |         std::memcpy(&r, rhs, 2);
  167|       |         return (l == r) & (lhs[2] == rhs[2]);
  168|       |      }
  169|       |      else if constexpr (Count == 2) {
  170|       |         uint16_t l, r;
  171|       |         std::memcpy(&l, lhs, 2);
  172|       |         std::memcpy(&r, rhs, 2);
  173|       |         return l == r;
  174|       |      }
  175|       |      else if constexpr (Count == 1) {
  176|       |         return *lhs == *rhs;
  177|       |      }
  178|       |      else if constexpr (Count == 0) {
  179|       |         return true;
  180|       |      }
  181|  2.15k|   }
_ZN3glz7compareILm3EcEEbPKT0_S3_:
  122|  4.57k|   {
  123|       |      if constexpr (Count > 8) {
  124|       |         return 0 == std::memcmp(lhs, rhs, Count);
  125|       |         // return internal_compare(lhs, rhs, Count);
  126|       |      }
  127|       |      else if constexpr (Count == 8) {
  128|       |         uint64_t l, r;
  129|       |         std::memcpy(&l, lhs, 8);
  130|       |         std::memcpy(&r, rhs, 8);
  131|       |         return l == r;
  132|       |      }
  133|       |      else if constexpr (Count == 7) {
  134|       |         uint32_t l, r;
  135|       |         std::memcpy(&l, lhs, 4);
  136|       |         std::memcpy(&r, rhs, 4);
  137|       |         uint32_t l2, r2;
  138|       |         std::memcpy(&l2, lhs + 3, 4);
  139|       |         std::memcpy(&r2, rhs + 3, 4);
  140|       |         return (l == r) & (l2 == r2);
  141|       |      }
  142|       |      else if constexpr (Count == 6) {
  143|       |         uint32_t l, r;
  144|       |         std::memcpy(&l, lhs, 4);
  145|       |         std::memcpy(&r, rhs, 4);
  146|       |         uint16_t l2, r2;
  147|       |         std::memcpy(&l2, lhs + 4, 2);
  148|       |         std::memcpy(&r2, rhs + 4, 2);
  149|       |         return (l == r) & (l2 == r2);
  150|       |      }
  151|       |      else if constexpr (Count == 5) {
  152|       |         uint32_t l, r;
  153|       |         std::memcpy(&l, lhs, 4);
  154|       |         std::memcpy(&r, rhs, 4);
  155|       |         return (l == r) & (lhs[4] == rhs[4]);
  156|       |      }
  157|       |      else if constexpr (Count == 4) {
  158|       |         uint32_t l, r;
  159|       |         std::memcpy(&l, lhs, 4);
  160|       |         std::memcpy(&r, rhs, 4);
  161|       |         return l == r;
  162|       |      }
  163|  4.57k|      else if constexpr (Count == 3) {
  164|  4.57k|         uint16_t l, r;
  165|  4.57k|         std::memcpy(&l, lhs, 2);
  166|  4.57k|         std::memcpy(&r, rhs, 2);
  167|  4.57k|         return (l == r) & (lhs[2] == rhs[2]);
  168|       |      }
  169|       |      else if constexpr (Count == 2) {
  170|       |         uint16_t l, r;
  171|       |         std::memcpy(&l, lhs, 2);
  172|       |         std::memcpy(&r, rhs, 2);
  173|       |         return l == r;
  174|       |      }
  175|       |      else if constexpr (Count == 1) {
  176|       |         return *lhs == *rhs;
  177|       |      }
  178|       |      else if constexpr (Count == 0) {
  179|       |         return true;
  180|       |      }
  181|  4.57k|   }

_ZN3glz4dumpILb0ENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEETkNS_10byte_sizedEcEEvT1_RT0_Rm:
  150|   541M|   {
  151|       |      if constexpr (Checked && vector_like<B>) {
  152|       |         if (ix == b.size()) [[unlikely]] {
  153|       |            grow_buffer(b, b.size() == 0 ? 64 : ix + 1);
  154|       |         }
  155|       |      }
  156|   541M|      assign_maybe_cast(c, b, ix);
  157|   541M|      ++ix;
  158|   541M|   }
_ZN3glz17assign_maybe_castITkNS_10byte_sizedEcNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEvT_RT0_Rm:
   95|   541M|   {
   96|   541M|      using V = std::decay_t<decltype(b[0])>;
   97|   541M|      using C = std::decay_t<decltype(c)>;
   98|   541M|      if constexpr (std::same_as<V, C>) {
   99|   541M|         b[ix] = c;
  100|       |      }
  101|       |      else {
  102|       |         b[ix] = static_cast<V>(c);
  103|       |      }
  104|   541M|   }
_ZN3glz4dumpILb0ENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEvNS1_17basic_string_viewIcS4_EERT0_Rm:
  192|   529M|   {
  193|   529M|      const auto n = str.size();
  194|   529M|      if constexpr (vector_like<B>) {
  195|       |         if constexpr (Checked) {
  196|       |            const auto k = ix + n;
  197|       |            if (ix + n > b.size()) [[unlikely]] {
  198|       |               grow_buffer(b, k);
  199|       |            }
  200|       |         }
  201|   529M|      }
  202|   529M|      std::memcpy(&b[ix], str.data(), n);
  203|   529M|      ix += n;
  204|   529M|   }

_ZN3glz5visitILm4EZNS_4fromILj1E9my_structE2opITnDaXtlNS_4optsELj1ELb0ELb0ELb1ELb1EEETnNS_14string_literalEXtlNS6_ILm1EEEEERS2_TkNS_10is_contextERNS_7contextERPKcSC_Qeqcl23check_structs_as_arraysTL0__ELb0EEEvOT1_OT2_OT3_T4_EUlTnmvE_EEvOT0_m:
   86|  13.2k|   {
   87|  13.2k|      if constexpr (N > 0) {
   88|  13.2k|         assert(index < N && "glz::visit index out of range");
  ------------------
  |  Branch (88:10): [True: 13.2k, False: 0]
  |  Branch (88:10): [True: 13.2k, Folded]
  |  Branch (88:10): [True: 13.2k, False: 0]
  ------------------
   89|       |         // Explicit sizes for small N to help the compiler and make debugging easier
   90|       |         if constexpr (N == 1) {
   91|       |            (void)index;
   92|       |            (void)(lambda.template operator()<0>());
   93|       |         }
   94|       |         else if constexpr (N == 2) {
   95|       |            switch (index) {
   96|       |            case 0:
   97|       |               lambda.template operator()<0>();
   98|       |               break;
   99|       |            case 1:
  100|       |               lambda.template operator()<1>();
  101|       |               break;
  102|       |            default:
  103|       |               std::unreachable();
  104|       |            }
  105|       |         }
  106|       |         else if constexpr (N == 3) {
  107|       |            switch (index) {
  108|       |            case 0:
  109|       |               lambda.template operator()<0>();
  110|       |               break;
  111|       |            case 1:
  112|       |               lambda.template operator()<1>();
  113|       |               break;
  114|       |            case 2:
  115|       |               lambda.template operator()<2>();
  116|       |               break;
  117|       |            default:
  118|       |               std::unreachable();
  119|       |            }
  120|       |         }
  121|  13.2k|         else if constexpr (N == 4) {
  122|  13.2k|            switch (index) {
  123|  3.45k|            case 0:
  ------------------
  |  Branch (123:13): [True: 3.45k, False: 9.83k]
  ------------------
  124|  3.45k|               lambda.template operator()<0>();
  125|  3.45k|               break;
  126|  3.10k|            case 1:
  ------------------
  |  Branch (126:13): [True: 3.10k, False: 10.1k]
  ------------------
  127|  3.10k|               lambda.template operator()<1>();
  128|  3.10k|               break;
  129|  2.16k|            case 2:
  ------------------
  |  Branch (129:13): [True: 2.16k, False: 11.1k]
  ------------------
  130|  2.16k|               lambda.template operator()<2>();
  131|  2.16k|               break;
  132|  4.57k|            case 3:
  ------------------
  |  Branch (132:13): [True: 4.57k, False: 8.71k]
  ------------------
  133|  4.57k|               lambda.template operator()<3>();
  134|  4.57k|               break;
  135|      0|            default:
  ------------------
  |  Branch (135:13): [True: 0, False: 13.2k]
  ------------------
  136|      0|               std::unreachable();
  137|  13.2k|            }
  138|       |         }
  139|       |         else if constexpr (N == 5) {
  140|       |            switch (index) {
  141|       |            case 0:
  142|       |               lambda.template operator()<0>();
  143|       |               break;
  144|       |            case 1:
  145|       |               lambda.template operator()<1>();
  146|       |               break;
  147|       |            case 2:
  148|       |               lambda.template operator()<2>();
  149|       |               break;
  150|       |            case 3:
  151|       |               lambda.template operator()<3>();
  152|       |               break;
  153|       |            case 4:
  154|       |               lambda.template operator()<4>();
  155|       |               break;
  156|       |            default:
  157|       |               std::unreachable();
  158|       |            }
  159|       |         }
  160|       |         else if constexpr (N == 6) {
  161|       |            switch (index) {
  162|       |            case 0:
  163|       |               lambda.template operator()<0>();
  164|       |               break;
  165|       |            case 1:
  166|       |               lambda.template operator()<1>();
  167|       |               break;
  168|       |            case 2:
  169|       |               lambda.template operator()<2>();
  170|       |               break;
  171|       |            case 3:
  172|       |               lambda.template operator()<3>();
  173|       |               break;
  174|       |            case 4:
  175|       |               lambda.template operator()<4>();
  176|       |               break;
  177|       |            case 5:
  178|       |               lambda.template operator()<5>();
  179|       |               break;
  180|       |            default:
  181|       |               std::unreachable();
  182|       |            }
  183|       |         }
  184|       |         else if constexpr (N == 7) {
  185|       |            switch (index) {
  186|       |            case 0:
  187|       |               lambda.template operator()<0>();
  188|       |               break;
  189|       |            case 1:
  190|       |               lambda.template operator()<1>();
  191|       |               break;
  192|       |            case 2:
  193|       |               lambda.template operator()<2>();
  194|       |               break;
  195|       |            case 3:
  196|       |               lambda.template operator()<3>();
  197|       |               break;
  198|       |            case 4:
  199|       |               lambda.template operator()<4>();
  200|       |               break;
  201|       |            case 5:
  202|       |               lambda.template operator()<5>();
  203|       |               break;
  204|       |            case 6:
  205|       |               lambda.template operator()<6>();
  206|       |               break;
  207|       |            default:
  208|       |               std::unreachable();
  209|       |            }
  210|       |         }
  211|       |         else if constexpr (N == 8) {
  212|       |            switch (index) {
  213|       |            case 0:
  214|       |               lambda.template operator()<0>();
  215|       |               break;
  216|       |            case 1:
  217|       |               lambda.template operator()<1>();
  218|       |               break;
  219|       |            case 2:
  220|       |               lambda.template operator()<2>();
  221|       |               break;
  222|       |            case 3:
  223|       |               lambda.template operator()<3>();
  224|       |               break;
  225|       |            case 4:
  226|       |               lambda.template operator()<4>();
  227|       |               break;
  228|       |            case 5:
  229|       |               lambda.template operator()<5>();
  230|       |               break;
  231|       |            case 6:
  232|       |               lambda.template operator()<6>();
  233|       |               break;
  234|       |            case 7:
  235|       |               lambda.template operator()<7>();
  236|       |               break;
  237|       |            default:
  238|       |               std::unreachable();
  239|       |            }
  240|       |         }
  241|       |         else if constexpr (N == 9) {
  242|       |            switch (index) {
  243|       |            case 0:
  244|       |               lambda.template operator()<0>();
  245|       |               break;
  246|       |            case 1:
  247|       |               lambda.template operator()<1>();
  248|       |               break;
  249|       |            case 2:
  250|       |               lambda.template operator()<2>();
  251|       |               break;
  252|       |            case 3:
  253|       |               lambda.template operator()<3>();
  254|       |               break;
  255|       |            case 4:
  256|       |               lambda.template operator()<4>();
  257|       |               break;
  258|       |            case 5:
  259|       |               lambda.template operator()<5>();
  260|       |               break;
  261|       |            case 6:
  262|       |               lambda.template operator()<6>();
  263|       |               break;
  264|       |            case 7:
  265|       |               lambda.template operator()<7>();
  266|       |               break;
  267|       |            case 8:
  268|       |               lambda.template operator()<8>();
  269|       |               break;
  270|       |            default:
  271|       |               std::unreachable();
  272|       |            }
  273|       |         }
  274|       |         else if constexpr (N == 10) {
  275|       |            switch (index) {
  276|       |            case 0:
  277|       |               lambda.template operator()<0>();
  278|       |               break;
  279|       |            case 1:
  280|       |               lambda.template operator()<1>();
  281|       |               break;
  282|       |            case 2:
  283|       |               lambda.template operator()<2>();
  284|       |               break;
  285|       |            case 3:
  286|       |               lambda.template operator()<3>();
  287|       |               break;
  288|       |            case 4:
  289|       |               lambda.template operator()<4>();
  290|       |               break;
  291|       |            case 5:
  292|       |               lambda.template operator()<5>();
  293|       |               break;
  294|       |            case 6:
  295|       |               lambda.template operator()<6>();
  296|       |               break;
  297|       |            case 7:
  298|       |               lambda.template operator()<7>();
  299|       |               break;
  300|       |            case 8:
  301|       |               lambda.template operator()<8>();
  302|       |               break;
  303|       |            case 9:
  304|       |               lambda.template operator()<9>();
  305|       |               break;
  306|       |            default:
  307|       |               std::unreachable();
  308|       |            }
  309|       |         }
  310|       |         else {
  311|       |#ifdef _MSC_VER
  312|       |            using Lambda = std::decay_t<decltype(lambda)>;
  313|       |            static const auto jump_table = []<size_t... I>(std::index_sequence<I...>) {
  314|       |               return std::array{make_jump_function<I, Lambda>()...};
  315|       |            }(std::make_index_sequence<N>{});
  316|       |#else
  317|       |            static constexpr auto jump_table = []<size_t... I>(std::index_sequence<I...>) {
  318|       |               return std::array{+[](std::decay_t<decltype(lambda)>& l) { l.template operator()<I>(); }...};
  319|       |            }(std::make_index_sequence<N>{});
  320|       |#endif
  321|       |
  322|       |#if defined(__clang_major__) && (__clang_major__ >= 19)
  323|       |            [[assume(index < N)]];
  324|       |#endif
  325|       |            jump_table[index](lambda);
  326|       |
  327|       |            // This code runs significantly slower on Clang
  328|       |            // Simple tests with assembly show that this should be faster,
  329|       |            // but full Glaze assembly need to be looked into
  330|       |            /*[&, index]<size_t... I>(std::index_sequence<I...>) {
  331|       |               (void)((index == I ? lambda.template operator()<I>() : void()), ...);
  332|       |            }(std::make_index_sequence<N>{});*/
  333|       |         }
  334|  13.2k|      }
  335|  13.2k|   }

_ZN3glz8to_charsIaQsr3stdE7same_asIu14__remove_cvrefIT_EaEEEPcS3_S1_:
  277|   864k|   {
  278|   864k|      *buf = '-';
  279|   864k|      return to_chars(buf + (val < 0), uint8_t(val ^ (val >> 7)) - (val >> 7));
  280|   864k|   }
_ZN3glz8to_charsIiQsr3stdE7same_asIu14__remove_cvrefIT_EiEEEPcS3_S1_:
  213|  2.86M|   {
  214|  2.86M|      *buf = '-';
  215|  2.86M|      return to_chars(buf + (val < 0), uint32_t(val ^ (val >> 31)) - (val >> 31));
  216|  2.86M|   }
_ZN3glz8to_charsIjQsr3stdE7same_asIu14__remove_cvrefIT_EjEEEPcS3_S1_:
  191|  2.86M|   {
  192|  2.86M|      using namespace itoa_impl;
  193|  2.86M|      if (val < 100) {
  ------------------
  |  Branch (193:11): [True: 1.28M, False: 1.58M]
  ------------------
  194|  1.28M|         return u32_2(buf, val);
  195|  1.28M|      }
  196|  1.58M|      else if (val < 10000) {
  ------------------
  |  Branch (196:16): [True: 1.10M, False: 476k]
  ------------------
  197|  1.10M|         return u32_4(buf, val);
  198|  1.10M|      }
  199|   476k|      else if (val < 1000000) {
  ------------------
  |  Branch (199:16): [True: 476k, False: 0]
  ------------------
  200|   476k|         return u32_6(buf, val);
  201|   476k|      }
  202|      0|      else if (val < 100000000) {
  ------------------
  |  Branch (202:16): [True: 0, False: 0]
  ------------------
  203|      0|         return u32_8(buf, val);
  204|      0|      }
  205|      0|      else {
  206|      0|         return u32_10(buf, val);
  207|      0|      }
  208|  2.86M|   }
_ZN3glz9itoa_impl5u32_2EPcj:
   74|  4.11M|      {
   75|  4.11M|         const uint32_t lz = val < 10;
   76|  4.11M|         std::memcpy(buf, char_table + ((val * 2) | lz), 2);
   77|  4.11M|         return buf + 2 - lz;
   78|  4.11M|      }
_ZN3glz9itoa_impl5u32_4EPcj:
   81|  1.55M|      {
   82|  1.55M|         const uint32_t aa = (val * 5243) >> 19; // val / 100
   83|  1.55M|         const uint32_t lz = aa < 10;
   84|  1.55M|         std::memcpy(buf, char_table + ((aa * 2) | lz), 2);
   85|  1.55M|         std::memcpy(buf + 2 - lz, &digit_pairs[val - aa * 100], 2);
   86|  1.55M|         return buf + 4 - lz;
   87|  1.55M|      }
_ZN3glz9itoa_impl5u32_6EPcj:
   90|   476k|      {
   91|   476k|         const uint32_t aa = uint32_t((uint64_t(val) * 429497) >> 32); // val / 10000
   92|   476k|         const uint32_t bbcc = val - aa * 10000;
   93|   476k|         const uint32_t bb = (bbcc * 5243) >> 19; // bbcc / 100
   94|   476k|         const uint32_t lz = aa < 10;
   95|   476k|         std::memcpy(buf, char_table + ((aa * 2) | lz), 2);
   96|   476k|         std::memcpy(buf + 2 - lz, &digit_pairs[bb], 2);
   97|   476k|         std::memcpy(buf + 4 - lz, &digit_pairs[bbcc - bb * 100], 2);
   98|   476k|         return buf + 6 - lz;
   99|   476k|      }
_ZN3glz8to_charsIsQsr3stdE7same_asIu14__remove_cvrefIT_EsEEEPcS3_S1_:
  306|  2.00M|   {
  307|  2.00M|      *buf = '-';
  308|  2.00M|      return to_chars(buf + (val < 0), uint16_t(val ^ (val >> 15)) - (val >> 15));
  309|  2.00M|   }
_ZN3glz8to_charsIhQsr3stdE7same_asIu14__remove_cvrefIT_EhEEEPcS3_S1_:
  259|  2.22M|   {
  260|  2.22M|      using namespace itoa_impl;
  261|  2.22M|      if (val < 100) {
  ------------------
  |  Branch (261:11): [True: 2.04M, False: 183k]
  ------------------
  262|  2.04M|         return u32_2(buf, val);
  263|  2.04M|      }
  264|   183k|      else {
  265|       |         // 100-255: 3 digits
  266|   183k|         const uint32_t q = val / 100;
  267|   183k|         *buf = char('0' + q);
  268|   183k|         std::memcpy(buf + 1, &digit_pairs[val - q * 100], 2);
  269|   183k|         return buf + 3;
  270|   183k|      }
  271|  2.22M|   }
_ZN3glz8to_charsItQsr3stdE7same_asIu14__remove_cvrefIT_EtEEEPcS3_S1_:
  286|  1.77M|   {
  287|  1.77M|      using namespace itoa_impl;
  288|  1.77M|      if (val < 100) {
  ------------------
  |  Branch (288:11): [True: 787k, False: 984k]
  ------------------
  289|   787k|         return u32_2(buf, val);
  290|   787k|      }
  291|   984k|      else if (val < 10000) {
  ------------------
  |  Branch (291:16): [True: 446k, False: 538k]
  ------------------
  292|   446k|         return u32_4(buf, val);
  293|   446k|      }
  294|   538k|      else {
  295|       |         // 10000-65535: 5 digits
  296|   538k|         const uint32_t q = val / 10000;
  297|   538k|         *buf = char('0' + q);
  298|   538k|         return u64_len_4(buf + 1, val - q * 10000);
  299|   538k|      }
  300|  1.77M|   }
_ZN3glz9itoa_impl9u64_len_4EPcj:
  148|   538k|      {
  149|   538k|         const uint32_t aa = (val * 5243) >> 19;
  150|   538k|         std::memcpy(buf, &digit_pairs[aa], 2);
  151|   538k|         std::memcpy(buf + 2, &digit_pairs[val - aa * 100], 2);
  152|   538k|         return buf + 4;
  153|   538k|      }

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

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