LLVMFuzzerTestOneInput:
    7|  1.31k|{
    8|       |   // use a vector with null termination instead of a std::string to avoid
    9|       |   // small string optimization to hide bounds problems
   10|  1.31k|   std::vector<char> buffer{Data, Data + Size};
   11|       |
   12|       |   // non-null terminated
   13|  1.31k|   {
   14|  1.31k|      const auto& input = buffer;
   15|  1.31k|      [[maybe_unused]] auto beautiful = glz::prettify_json(input);
   16|  1.31k|   }
   17|       |
   18|       |   // null terminated
   19|  1.31k|   {
   20|  1.31k|      buffer.push_back('\0');
   21|  1.31k|      const auto& input = buffer;
   22|  1.31k|      [[maybe_unused]] auto beautiful = glz::prettify_json(input);
   23|  1.31k|   }
   24|       |
   25|  1.31k|   return 0;
   26|  1.31k|}

_ZN3glz11grow_bufferINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEvRT_m:
   88|  10.3k|   {
   89|  10.3k|      using traits = buffer_traits<std::remove_cvref_t<B>>;
   90|  10.3k|      if constexpr (requires { traits::grow(b, required); }) {
   91|  10.3k|         traits::grow(b, required);
   92|       |      }
   93|       |      else {
   94|       |         // A user specialization written before `grow` existed: keep the growth it used to get.
   95|       |         b.resize(2 * required);
   96|       |      }
   97|  10.3k|   }
_ZN3glz13buffer_traitsINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE4growERS7_mQL_ZNS_13buffer_traits12is_resizableEE:
   63|  10.3k|      {
   64|  10.3k|         b.resize(2 * required);
   65|  10.3k|      }

_ZN3glz14read_iteratorsITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELb0ETkNS_10contiguousERKNSt3__16vectorIcNS2_9allocatorIcEEEEEEDaOT1_:
   40|  2.63k|   {
   41|  2.63k|      static_assert(sizeof(decltype(*buffer.data())) == 1);
   42|       |
   43|  2.63k|      auto it = reinterpret_cast<const char*>(buffer.data());
   44|  2.63k|      auto end = reinterpret_cast<const char*>(buffer.data()); // to be incremented
   45|       |
   46|       |      if constexpr (Padded) {
   47|       |         end += buffer.size() - padding_bytes;
   48|       |      }
   49|  2.63k|      else {
   50|  2.63k|         end += buffer.size();
   51|  2.63k|      }
   52|       |
   53|  2.63k|      return std::pair{it, end};
   54|  2.63k|   }

_ZN3glz6detail16read_json_stringITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERPKcS4_Qntcl15check_is_paddedT_EEENSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEOT0_T1_:
  110|   488k|   {
  111|   488k|      auto start = it;
  112|   488k|      ++it; // skip quote
  113|  1.64M|      for (const auto end_m7 = end - 7; it < end_m7;) {
  ------------------
  |  Branch (113:41): [True: 1.64M, False: 370]
  ------------------
  114|  1.64M|         uint64_t chunk;
  115|  1.64M|         std::memcpy(&chunk, it, 8);
  116|       |         if constexpr (std::endian::native == std::endian::big) {
  117|       |            chunk = std::byteswap(chunk);
  118|       |         }
  119|  1.64M|         const uint64_t quote = has_quote(chunk);
  120|  1.64M|         if (quote) {
  ------------------
  |  Branch (120:14): [True: 488k, False: 1.15M]
  ------------------
  121|   488k|            it += (countr_zero(quote) >> 3);
  122|       |
  123|   488k|            auto* prev = it - 1;
  124|   490k|            while (*prev == '\\') {
  ------------------
  |  Branch (124:20): [True: 1.26k, False: 488k]
  ------------------
  125|  1.26k|               --prev;
  126|  1.26k|            }
  127|   488k|            if (size_t(it - prev) % 2) {
  ------------------
  |  Branch (127:17): [True: 488k, False: 488]
  ------------------
  128|   488k|               ++it; // add quote
  129|   488k|               return {start, size_t(it - start)};
  130|   488k|            }
  131|    488|            ++it; // skip escaped quote and continue
  132|    488|         }
  133|  1.15M|         else {
  134|  1.15M|            it += 8;
  135|  1.15M|         }
  136|  1.64M|      }
  137|       |
  138|       |      // Tail end of buffer. Should be rare we even get here
  139|    903|      while (it < end) {
  ------------------
  |  Branch (139:14): [True: 789, False: 114]
  ------------------
  140|    789|         if (*it == '"') {
  ------------------
  |  Branch (140:14): [True: 288, False: 501]
  ------------------
  141|    288|            auto* prev = it - 1;
  142|  1.41k|            while (*prev == '\\') {
  ------------------
  |  Branch (142:20): [True: 1.12k, False: 288]
  ------------------
  143|  1.12k|               --prev;
  144|  1.12k|            }
  145|    288|            if (size_t(it - prev) % 2) {
  ------------------
  |  Branch (145:17): [True: 256, False: 32]
  ------------------
  146|    256|               ++it; // add quote
  147|    256|               return {start, size_t(it - start)};
  148|    256|            }
  149|    288|         }
  150|    533|         ++it;
  151|    533|      }
  152|       |
  153|    114|      return {};
  154|    370|   }
_ZN3glz6detail15append_new_lineILb0ELh3ERNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEERmEEvOT1_OT2_l:
   63|   100M|   {
   64|   100M|      dump('\n', b, ix);
   65|       |      if constexpr (use_tabs) {
   66|       |         dumpn('\t', indent, b, ix);
   67|       |      }
   68|   100M|      else {
   69|   100M|         dumpn(' ', indent * indentation_width, b, ix);
   70|   100M|      }
   71|   100M|   };
_ZN3glz6detail16read_json_numberILb0ERPKcS3_EENSt3__117basic_string_viewIcNS5_11char_traitsIcEEEEOT0_T1_:
  197|   507k|   {
  198|   507k|      auto start = it;
  199|       |      if constexpr (null_terminated) {
  200|       |         while (numeric_table[uint8_t(*it)]) {
  201|       |            ++it;
  202|       |         }
  203|       |      }
  204|   507k|      else {
  205|  3.16M|         while ((it < end) && numeric_table[uint8_t(*it)]) {
  ------------------
  |  Branch (205:17): [True: 3.16M, False: 46]
  |  Branch (205:31): [True: 2.65M, False: 507k]
  ------------------
  206|  2.65M|            ++it;
  207|  2.65M|         }
  208|   507k|      }
  209|   507k|      return {start, size_t(it - start)};
  210|   507k|   }

_ZN3glz13prettify_jsonITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEENSt3__16vectorIcNS2_9allocatorIcEEEEEENS2_12basic_stringIcNS2_11char_traitsIcEES5_EERKT0_:
  231|  2.63k|   {
  232|  2.63k|      context ctx{};
  233|  2.63k|      std::string out{};
  234|  2.63k|      detail::prettify_json<Opts>(ctx, in, out);
  235|  2.63k|      return out;
  236|  2.63k|   }
_ZN3glz6detail13prettify_jsonITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEETkNS_10contiguousERKNSt3__16vectorIcNS3_9allocatorIcEEEETkNS_13output_bufferERNS3_12basic_stringIcNS3_11char_traitsIcEES6_EETkNS_10is_contextERNS_7contextEEEvOT2_OT0_OT1_:
  188|  2.63k|      {
  189|  2.63k|         if constexpr (resizable<Out>) {
  190|  2.63k|            if (in.empty()) {
  ------------------
  |  Branch (190:17): [True: 0, False: 2.63k]
  ------------------
  191|      0|               out.clear();
  192|      0|               return;
  193|      0|            }
  194|  2.63k|            out.resize(in.size() * 2);
  195|  2.63k|         }
  196|      0|         size_t ix = 0;
  197|  2.63k|         auto [it, end] = read_iterators<Opts>(in);
  198|  2.63k|         if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (198:14): [True: 0, False: 2.63k]
  ------------------
  199|      0|            return;
  200|      0|         }
  201|       |
  202|       |         if constexpr (string_t<In>) {
  203|       |            prettify_json<opt_true<Opts, &opts::null_terminated>>(ctx, it, end, out, ix);
  204|       |         }
  205|  2.63k|         else {
  206|  2.63k|            prettify_json<opt_false<Opts, &opts::null_terminated>>(ctx, it, end, out, ix);
  207|  2.63k|         }
  208|       |
  209|  2.63k|         if constexpr (resizable<Out>) {
  210|  2.63k|            out.resize(ix);
  211|  2.63k|         }
  212|  2.63k|      }
_ZN3glz6detail13prettify_jsonITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETkNS_10is_contextERNS_7contextERPKcS7_RNSt3__112basic_stringIcNS8_11char_traitsIcEENS8_9allocatorIcEEEEmEEvOT0_OT1_OT2_OT3_RT4_:
   16|  2.63k|      {
   17|  2.63k|         constexpr bool use_tabs = check_indentation_char(Opts) == '\t';
   18|  2.63k|         constexpr auto indent_width = check_indentation_width(Opts);
   19|       |
   20|  2.63k|         using enum json_type;
   21|       |
   22|  2.63k|         std::vector<json_type> state(64);
   23|  2.63k|         int64_t indent{};
   24|       |
   25|   119M|         while (it < end) {
  ------------------
  |  Branch (25:17): [True: 119M, False: 1.10k]
  ------------------
   26|   119M|            switch (json_types[uint8_t(*it)]) {
   27|   488k|            case String: {
  ------------------
  |  Branch (27:13): [True: 488k, False: 118M]
  ------------------
   28|   488k|               const auto value = read_json_string<Opts>(it, end);
   29|   488k|               dump_maybe_empty(value, b, ix);
   30|   488k|               break;
   31|      0|            }
   32|  52.0M|            case Comma: {
  ------------------
  |  Branch (32:13): [True: 52.0M, False: 67.3M]
  ------------------
   33|  52.0M|               dump(',', b, ix);
   34|  52.0M|               ++it;
   35|  52.0M|               if constexpr (check_new_lines_in_arrays(Opts)) {
   36|  52.0M|                  append_new_line<use_tabs, indent_width>(b, ix, indent);
   37|       |               }
   38|       |               else {
   39|       |                  if (state[indent] == Object_Start) {
   40|       |                     append_new_line<use_tabs, indent_width>(b, ix, indent);
   41|       |                  }
   42|       |                  else {
   43|       |                     if constexpr (use_tabs) {
   44|       |                        dump('\t', b, ix);
   45|       |                     }
   46|       |                     else {
   47|       |                        dump(' ', b, ix);
   48|       |                     }
   49|       |                  }
   50|       |               }
   51|  52.0M|               break;
   52|      0|            }
   53|   507k|            case Number: {
  ------------------
  |  Branch (53:13): [True: 507k, False: 118M]
  ------------------
   54|   507k|               const auto value = read_json_number<Opts.null_terminated>(it, end);
   55|   507k|               dump_not_empty(value, b, ix);
   56|   507k|               break;
   57|      0|            }
   58|  3.29M|            case Colon: {
  ------------------
  |  Branch (58:13): [True: 3.29M, False: 116M]
  ------------------
   59|       |               if constexpr (use_tabs) {
   60|       |                  dump(":\t", b, ix);
   61|       |               }
   62|  3.29M|               else {
   63|  3.29M|                  dump(": ", b, ix);
   64|  3.29M|               }
   65|  3.29M|               ++it;
   66|  3.29M|               break;
   67|      0|            }
   68|  11.2M|            case Array_Start: {
  ------------------
  |  Branch (68:13): [True: 11.2M, False: 108M]
  ------------------
   69|  11.2M|               dump('[', b, ix);
   70|  11.2M|               ++it;
   71|  11.2M|               ++indent;
   72|  11.2M|               if (size_t(indent) >= state.size()) [[unlikely]] {
  ------------------
  |  Branch (72:20): [True: 726, False: 11.2M]
  ------------------
   73|    726|                  state.resize(state.size() * 2);
   74|    726|                  if (state.size() >= max_recursive_depth_limit) [[unlikely]] {
  ------------------
  |  Branch (74:23): [True: 60, False: 666]
  ------------------
   75|     60|                     ctx.error = error_code::exceeded_max_recursive_depth;
   76|     60|                     return;
   77|     60|                  }
   78|    726|               }
   79|  11.2M|               state[indent] = Array_Start;
   80|  11.2M|               if constexpr (check_new_lines_in_arrays(Opts)) {
   81|  11.2M|                  if constexpr (not Opts.null_terminated) {
   82|  11.2M|                     if (it != end && *it != ']') {
  ------------------
  |  Branch (82:26): [True: 11.2M, False: 115]
  |  Branch (82:39): [True: 10.7M, False: 470k]
  ------------------
   83|  10.7M|                        append_new_line<use_tabs, indent_width>(b, ix, indent);
   84|  10.7M|                     }
   85|       |                  }
   86|       |                  else {
   87|       |                     if (*it != ']') {
   88|       |                        append_new_line<use_tabs, indent_width>(b, ix, indent);
   89|       |                     }
   90|       |                  }
   91|  11.2M|               }
   92|  11.2M|               break;
   93|  11.2M|            }
   94|  11.9M|            case Array_End: {
  ------------------
  |  Branch (94:13): [True: 11.9M, False: 107M]
  ------------------
   95|  11.9M|               --indent;
   96|  11.9M|               if (indent < 0) {
  ------------------
  |  Branch (96:20): [True: 10, False: 11.9M]
  ------------------
   97|     10|                  ctx.error = error_code::syntax_error;
   98|     10|                  return;
   99|     10|               }
  100|  11.9M|               if constexpr (check_new_lines_in_arrays(Opts)) {
  101|  11.9M|                  if (it[-1] != '[') {
  ------------------
  |  Branch (101:23): [True: 11.4M, False: 471k]
  ------------------
  102|  11.4M|                     append_new_line<use_tabs, indent_width>(b, ix, indent);
  103|  11.4M|                  }
  104|  11.9M|               }
  105|  11.9M|               dump(']', b, ix);
  106|  11.9M|               ++it;
  107|  11.9M|               break;
  108|  11.9M|            }
  109|  12.6k|            case Null: {
  ------------------
  |  Branch (109:13): [True: 12.6k, False: 119M]
  ------------------
  110|  12.6k|               dump("null", b, ix);
  111|  12.6k|               it += 4;
  112|  12.6k|               break;
  113|  11.9M|            }
  114|  1.56M|            case Bool: {
  ------------------
  |  Branch (114:13): [True: 1.56M, False: 117M]
  ------------------
  115|  1.56M|               if (*it == 't') {
  ------------------
  |  Branch (115:20): [True: 1.55M, False: 9.09k]
  ------------------
  116|  1.55M|                  dump("true", b, ix);
  117|  1.55M|                  it += 4;
  118|  1.55M|                  break;
  119|  1.55M|               }
  120|  9.09k|               else {
  121|  9.09k|                  dump("false", b, ix);
  122|  9.09k|                  it += 5;
  123|  9.09k|                  break;
  124|  9.09k|               }
  125|  1.56M|            }
  126|  19.5M|            case Object_Start: {
  ------------------
  |  Branch (126:13): [True: 19.5M, False: 99.7M]
  ------------------
  127|  19.5M|               dump('{', b, ix);
  128|  19.5M|               ++it;
  129|  19.5M|               ++indent;
  130|  19.5M|               if (size_t(indent) >= state.size()) [[unlikely]] {
  ------------------
  |  Branch (130:20): [True: 382, False: 19.5M]
  ------------------
  131|    382|                  state.resize(state.size() * 2);
  132|    382|                  if (state.size() >= max_recursive_depth_limit) [[unlikely]] {
  ------------------
  |  Branch (132:23): [True: 52, False: 330]
  ------------------
  133|     52|                     ctx.error = error_code::exceeded_max_recursive_depth;
  134|     52|                     return;
  135|     52|                  }
  136|    382|               }
  137|  19.5M|               state[indent] = Object_Start;
  138|  19.5M|               if constexpr (not Opts.null_terminated) {
  139|  19.5M|                  if (it != end && *it != '}') [[unlikely]] {
  ------------------
  |  Branch (139:23): [True: 19.5M, False: 120]
  |  Branch (139:36): [True: 13.7M, False: 5.75M]
  ------------------
  140|  13.7M|                     append_new_line<use_tabs, indent_width>(b, ix, indent);
  141|  13.7M|                  }
  142|       |               }
  143|       |               else {
  144|       |                  if (*it != '}') {
  145|       |                     append_new_line<use_tabs, indent_width>(b, ix, indent);
  146|       |                  }
  147|       |               }
  148|  19.5M|               break;
  149|  19.5M|            }
  150|  18.7M|            case Object_End: {
  ------------------
  |  Branch (150:13): [True: 18.7M, False: 100M]
  ------------------
  151|  18.7M|               --indent;
  152|  18.7M|               if (indent < 0) {
  ------------------
  |  Branch (152:20): [True: 50, False: 18.7M]
  ------------------
  153|     50|                  ctx.error = error_code::syntax_error;
  154|     50|                  return;
  155|     50|               }
  156|  18.7M|               if (it[-1] != '{') {
  ------------------
  |  Branch (156:20): [True: 12.9M, False: 5.75M]
  ------------------
  157|  12.9M|                  append_new_line<use_tabs, indent_width>(b, ix, indent);
  158|  12.9M|               }
  159|  18.7M|               dump('}', b, ix);
  160|  18.7M|               ++it;
  161|  18.7M|               break;
  162|  18.7M|            }
  163|  1.72k|            case Comment: {
  ------------------
  |  Branch (163:13): [True: 1.72k, False: 119M]
  ------------------
  164|       |               if constexpr (Opts.comments) {
  165|       |                  const auto value = read_jsonc_comment(it, end);
  166|       |                  dump_not_empty(value, b, ix);
  167|       |                  break;
  168|       |               }
  169|  1.72k|               else {
  170|  1.72k|                  [[fallthrough]];
  171|  1.72k|               }
  172|  1.72k|            }
  173|  2.93k|            case Whitespace: {
  ------------------
  |  Branch (173:13): [True: 1.21k, False: 119M]
  ------------------
  174|       |               // Skip whitespace characters that are part of raw JSON content
  175|  2.93k|               ++it;
  176|  2.93k|               break;
  177|  1.72k|            }
  178|  1.35k|            [[unlikely]] default: {
  ------------------
  |  Branch (178:26): [True: 1.35k, False: 119M]
  ------------------
  179|  1.35k|               ctx.error = error_code::syntax_error;
  180|  1.35k|               return;
  181|      0|            }
  182|   119M|            }
  183|   119M|         }
  184|  2.63k|      }

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

_ZN3glz16dump_maybe_emptyILb1ENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEvNS1_17basic_string_viewIcS4_EERT0_Rm:
  281|   488k|   {
  282|   488k|      const auto n = str.size();
  283|   488k|      if (n) {
  ------------------
  |  Branch (283:11): [True: 488k, False: 114]
  ------------------
  284|   488k|         if constexpr (vector_like<B>) {
  285|   488k|            if constexpr (Checked) {
  286|   488k|               const auto k = ix + n;
  287|   488k|               if (k > b.size()) [[unlikely]] {
  ------------------
  |  Branch (287:20): [True: 55, False: 488k]
  ------------------
  288|     55|                  grow_buffer(b, k);
  289|     55|               }
  290|   488k|            }
  291|   488k|         }
  292|   488k|         std::memcpy(&b[ix], str.data(), n);
  293|   488k|         ix += n;
  294|   488k|      }
  295|   488k|   }
_ZN3glz4dumpILb1ENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEETkNS_10byte_sizedEcEEvT1_RT0_Rm:
  112|   214M|   {
  113|   214M|      if constexpr (Checked && vector_like<B>) {
  114|   214M|         if (ix == b.size()) [[unlikely]] {
  ------------------
  |  Branch (114:14): [True: 1.16k, False: 214M]
  ------------------
  115|  1.16k|            grow_buffer(b, b.size() == 0 ? 64 : ix + 1);
  ------------------
  |  Branch (115:28): [True: 0, False: 1.16k]
  ------------------
  116|  1.16k|         }
  117|   214M|      }
  118|   214M|      assign_maybe_cast(c, b, ix);
  119|   214M|      ++ix;
  120|   214M|   }
_ZN3glz17assign_maybe_castITkNS_10byte_sizedEcNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEvT_RT0_Rm:
   57|   214M|   {
   58|   214M|      using V = std::decay_t<decltype(b[0])>;
   59|   214M|      using C = std::decay_t<decltype(c)>;
   60|   214M|      if constexpr (std::same_as<V, C>) {
   61|   214M|         b[ix] = c;
   62|       |      }
   63|       |      else {
   64|       |         b[ix] = static_cast<V>(c);
   65|       |      }
   66|   214M|   }
_ZN3glz5dumpnINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEETkNS_10byte_sizedEcEEvT0_mRT_Rm:
  184|   100M|   {
  185|   100M|      if constexpr (vector_like<B>) {
  186|   100M|         const auto k = ix + n;
  187|   100M|         if (k > b.size()) [[unlikely]] {
  ------------------
  |  Branch (187:14): [True: 8.89k, False: 100M]
  ------------------
  188|  8.89k|            grow_buffer(b, k);
  189|  8.89k|         }
  190|   100M|      }
  191|   100M|      std::memset(data_at(b, ix), c, n);
  192|   100M|      ix += n;
  193|   100M|   }
_ZN3glz7data_atINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEDaRT_m:
   79|   100M|   {
   80|       |      if constexpr (std::is_pointer_v<std::remove_cvref_t<B>>) {
   81|       |         return b + ix;
   82|       |      }
   83|   100M|      else {
   84|   100M|         static_assert(has_data<std::remove_cvref_t<B>>,
   85|   100M|                       "an output buffer must be contiguous: dump writes through memset and memcpy");
   86|       |         if constexpr (has_data_offset<std::remove_cvref_t<B>>) {
   87|       |            assert(ix >= b.data_offset() && "Index before flush offset");
   88|       |            return b.data() + (ix - b.data_offset());
   89|       |         }
   90|   100M|         else {
   91|   100M|            return b.data() + ix;
   92|   100M|         }
   93|   100M|      }
   94|   100M|   }
_ZN3glz14dump_not_emptyILb1ENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEvNS1_17basic_string_viewIcS4_EERT0_Rm:
  265|   507k|   {
  266|   507k|      const auto n = str.size();
  267|   507k|      if constexpr (vector_like<B>) {
  268|   507k|         if constexpr (Checked) {
  269|   507k|            const auto k = ix + n;
  270|   507k|            if (k > b.size()) [[unlikely]] {
  ------------------
  |  Branch (270:17): [True: 48, False: 507k]
  ------------------
  271|     48|               grow_buffer(b, k);
  272|     48|            }
  273|   507k|         }
  274|   507k|      }
  275|   507k|      std::memcpy(&b[ix], str.data(), n);
  276|   507k|      ix += n;
  277|   507k|   }
_ZN3glz4dumpILb1ENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEvNS1_17basic_string_viewIcS4_EERT0_Rm:
  154|  4.87M|   {
  155|  4.87M|      const auto n = str.size();
  156|  4.87M|      if constexpr (vector_like<B>) {
  157|  4.87M|         if constexpr (Checked) {
  158|  4.87M|            const auto k = ix + n;
  159|  4.87M|            if (ix + n > b.size()) [[unlikely]] {
  ------------------
  |  Branch (159:17): [True: 142, False: 4.87M]
  ------------------
  160|    142|               grow_buffer(b, k);
  161|    142|            }
  162|  4.87M|         }
  163|  4.87M|      }
  164|  4.87M|      std::memcpy(&b[ix], str.data(), n);
  165|  4.87M|      ix += n;
  166|  4.87M|   }

_ZN3glz9has_quoteEm:
  534|  1.64M|   {
  535|  1.64M|      return has_zero(chunk ^ repeat_byte8('"'));
  536|  1.64M|   }
_ZN3glz8has_zeroEm:
  529|  1.64M|   {
  530|  1.64M|      return (((chunk - 0x0101010101010101u) & ~chunk) & 0x8080808080808080u);
  531|  1.64M|   }