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

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

_ZN3glz6detail16read_json_stringITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj32EEERPKcS4_Qcl15check_is_paddedT_EEENSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEOT0_T1_:
   76|  2.17k|   {
   77|  2.17k|      auto start = it;
   78|  2.17k|      ++it; // skip quote
   79|  1.49M|      while (it < end) [[likely]] {
  ------------------
  |  Branch (79:14): [True: 1.49M, False: 108]
  ------------------
   80|  1.49M|         uint64_t chunk;
   81|  1.49M|         std::memcpy(&chunk, it, 8);
   82|       |         if constexpr (std::endian::native == std::endian::big) {
   83|       |            chunk = std::byteswap(chunk);
   84|       |         }
   85|  1.49M|         const uint64_t quote = has_quote(chunk);
   86|  1.49M|         if (quote) {
  ------------------
  |  Branch (86:14): [True: 3.06k, False: 1.49M]
  ------------------
   87|  3.06k|            it += (countr_zero(quote) >> 3);
   88|       |
   89|  3.06k|            auto* prev = it - 1;
   90|  4.83k|            while (*prev == '\\') {
  ------------------
  |  Branch (90:20): [True: 1.77k, False: 3.06k]
  ------------------
   91|  1.77k|               --prev;
   92|  1.77k|            }
   93|  3.06k|            if (size_t(it - prev) % 2) {
  ------------------
  |  Branch (93:17): [True: 2.06k, False: 998]
  ------------------
   94|  2.06k|               ++it; // add quote
   95|  2.06k|               return {start, size_t(it - start)};
   96|  2.06k|            }
   97|    998|            ++it; // skip escaped quote and continue
   98|    998|         }
   99|  1.49M|         else {
  100|  1.49M|            it += 8;
  101|  1.49M|         }
  102|  1.49M|      }
  103|       |
  104|    108|      return {};
  105|  2.17k|   }
_ZN3glz6detail16read_json_numberILb1ERPKcS3_EENSt3__117basic_string_viewIcNS5_11char_traitsIcEEEEOT0_T1_:
  197|  7.04k|   {
  198|  7.04k|      auto start = it;
  199|  7.04k|      if constexpr (null_terminated) {
  200|  24.7k|         while (numeric_table[uint8_t(*it)]) {
  ------------------
  |  Branch (200:17): [True: 17.6k, False: 7.04k]
  ------------------
  201|  17.6k|            ++it;
  202|  17.6k|         }
  203|       |      }
  204|       |      else {
  205|       |         while ((it < end) && numeric_table[uint8_t(*it)]) {
  206|       |            ++it;
  207|       |         }
  208|       |      }
  209|  7.04k|      return {start, size_t(it - start)};
  210|  7.04k|   }

_ZN3glz11minify_jsonITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEETkNS_9resizableENSt3__16vectorIcNS2_9allocatorIcEEEEEENS2_12basic_stringIcNS2_11char_traitsIcEES5_EERT0_:
  202|  3.36k|   {
  203|  3.36k|      context ctx{};
  204|  3.36k|      std::string out{};
  205|  3.36k|      detail::minify_json<Opts>(ctx, in, out);
  206|  3.36k|      return out;
  207|  3.36k|   }
_ZN3glz6detail11minify_jsonITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERNSt3__16vectorIcNS3_9allocatorIcEEEETkNS_13output_bufferERNS3_12basic_stringIcNS3_11char_traitsIcEES6_EETkNS_10is_contextERNS_7contextEQaa10contiguousIT0_E9resizableISG_EEEvOT2_OSG_OT1_:
  159|  3.36k|      {
  160|  3.36k|         if (in.empty()) {
  ------------------
  |  Branch (160:14): [True: 0, False: 3.36k]
  ------------------
  161|      0|            return;
  162|      0|         }
  163|  3.36k|         in.resize(in.size() + padding_bytes);
  164|       |
  165|  3.36k|         if constexpr (resizable<Out>) {
  166|  3.36k|            out.resize(in.size() + padding_bytes);
  167|  3.36k|         }
  168|  3.36k|         size_t ix = 0;
  169|  3.36k|         auto [it, end] = read_iterators<Opts, true>(in);
  170|  3.36k|         if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (170:14): [True: 0, False: 3.36k]
  ------------------
  171|      0|            return;
  172|      0|         }
  173|       |
  174|  3.36k|         static constexpr auto O = is_padded_on<Opts>();
  175|  3.36k|         if constexpr (string_t<In>) {
  176|  3.36k|            minify_json<opt_true<O, &opts::null_terminated>>(ctx, it, end, out, ix);
  177|       |         }
  178|       |         else {
  179|       |            minify_json<opt_false<O, &opts::null_terminated>>(ctx, it, end, out, ix);
  180|       |         }
  181|       |
  182|  3.36k|         if constexpr (resizable<Out>) {
  183|  3.36k|            out.resize(ix);
  184|  3.36k|         }
  185|  3.36k|         in.resize(in.size() - padding_bytes);
  186|  3.36k|      }
_ZN3glz6detail11minify_jsonITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj32EEETkNS_10is_contextERNS_7contextERPKcS7_RNSt3__112basic_stringIcNS8_11char_traitsIcEENS8_9allocatorIcEEEEmEEvOT0_OT1_OT2_OT3_RT4_:
   17|  3.36k|      {
   18|  3.36k|         using enum json_type;
   19|       |
   20|  3.36k|         auto ws_start = it;
   21|  3.36k|         uint64_t ws_size{};
   22|       |
   23|  3.36k|         auto skip_expected_whitespace = [&] {
   24|  3.36k|            auto new_ws_start = it;
   25|  3.36k|            if (ws_size && ws_size < size_t(end - it)) [[likely]] {
   26|  3.36k|               skip_matching_ws(ws_start, it, ws_size);
   27|  3.36k|            }
   28|       |
   29|  3.36k|            if constexpr (Opts.null_terminated) {
   30|  3.36k|               while (whitespace_table[uint8_t(*it)]) {
   31|  3.36k|                  ++it;
   32|  3.36k|               }
   33|  3.36k|            }
   34|  3.36k|            else {
   35|  3.36k|               while ((it < end) && whitespace_table[uint8_t(*it)]) {
   36|  3.36k|                  ++it;
   37|  3.36k|               }
   38|  3.36k|            }
   39|  3.36k|            ws_start = new_ws_start;
   40|  3.36k|            ws_size = size_t(it - new_ws_start);
   41|  3.36k|         };
   42|       |
   43|  3.36k|         auto skip_whitespace = [&] {
   44|  3.36k|            if constexpr (Opts.null_terminated) {
   45|  3.36k|               while (whitespace_table[uint8_t(*it)]) {
   46|  3.36k|                  ++it;
   47|  3.36k|               }
   48|  3.36k|            }
   49|  3.36k|            else {
   50|  3.36k|               while ((it < end) && whitespace_table[uint8_t(*it)]) {
   51|  3.36k|                  ++it;
   52|  3.36k|               }
   53|  3.36k|            }
   54|  3.36k|         };
   55|       |
   56|  3.36k|         skip_whitespace();
   57|       |
   58|   111k|         while ([&]() -> bool {
  ------------------
  |  Branch (58:17): [True: 111k, Folded]
  ------------------
   59|   111k|            if constexpr (Opts.null_terminated) {
   60|   111k|               return true;
   61|   111k|            }
   62|   111k|            else {
   63|   111k|               return it < end;
   64|   111k|            }
   65|   111k|         }()) {
   66|   111k|            switch (json_types[uint8_t(*it)]) {
   67|  2.17k|            case String: {
  ------------------
  |  Branch (67:13): [True: 2.17k, False: 109k]
  ------------------
   68|  2.17k|               const auto value = read_json_string<Opts>(it, end);
   69|  2.17k|               dump_maybe_empty<false>(value, b, ix);
   70|  2.17k|               skip_whitespace();
   71|  2.17k|               break;
   72|      0|            }
   73|  32.2k|            case Comma: {
  ------------------
  |  Branch (73:13): [True: 32.2k, False: 79.3k]
  ------------------
   74|  32.2k|               dump<false>(',', b, ix);
   75|  32.2k|               ++it;
   76|  32.2k|               skip_expected_whitespace();
   77|  32.2k|               break;
   78|      0|            }
   79|  7.04k|            case Number: {
  ------------------
  |  Branch (79:13): [True: 7.04k, False: 104k]
  ------------------
   80|  7.04k|               const auto value = read_json_number<Opts.null_terminated>(it, end);
   81|  7.04k|               dump<false>(value, b, ix); // we couldn't have gotten here without one valid character
   82|  7.04k|               skip_whitespace();
   83|  7.04k|               break;
   84|      0|            }
   85|  6.16k|            case Colon: {
  ------------------
  |  Branch (85:13): [True: 6.16k, False: 105k]
  ------------------
   86|  6.16k|               dump<false>(':', b, ix);
   87|  6.16k|               ++it;
   88|  6.16k|               skip_whitespace();
   89|  6.16k|               break;
   90|      0|            }
   91|  17.2k|            case Array_Start: {
  ------------------
  |  Branch (91:13): [True: 17.2k, False: 94.4k]
  ------------------
   92|  17.2k|               dump<false>('[', b, ix);
   93|  17.2k|               ++it;
   94|  17.2k|               skip_expected_whitespace();
   95|  17.2k|               break;
   96|      0|            }
   97|  5.95k|            case Array_End: {
  ------------------
  |  Branch (97:13): [True: 5.95k, False: 105k]
  ------------------
   98|  5.95k|               dump<false>(']', b, ix);
   99|  5.95k|               ++it;
  100|  5.95k|               skip_whitespace();
  101|  5.95k|               break;
  102|      0|            }
  103|    830|            case Null: {
  ------------------
  |  Branch (103:13): [True: 830, False: 110k]
  ------------------
  104|    830|               dump<false>("null", b, ix);
  105|    830|               it += 4;
  106|    830|               skip_whitespace();
  107|    830|               break;
  108|      0|            }
  109|  11.3k|            case Bool: {
  ------------------
  |  Branch (109:13): [True: 11.3k, False: 100k]
  ------------------
  110|  11.3k|               if (*it == 't') {
  ------------------
  |  Branch (110:20): [True: 9.41k, False: 1.96k]
  ------------------
  111|  9.41k|                  dump<false>("true", b, ix);
  112|  9.41k|                  it += 4;
  113|  9.41k|                  skip_whitespace();
  114|  9.41k|                  break;
  115|  9.41k|               }
  116|  1.96k|               else {
  117|  1.96k|                  dump<false>("false", b, ix);
  118|  1.96k|                  it += 5;
  119|  1.96k|                  skip_whitespace();
  120|  1.96k|                  break;
  121|  1.96k|               }
  122|  11.3k|            }
  123|  22.0k|            case Object_Start: {
  ------------------
  |  Branch (123:13): [True: 22.0k, False: 89.6k]
  ------------------
  124|  22.0k|               dump<false>('{', b, ix);
  125|  22.0k|               ++it;
  126|  22.0k|               skip_expected_whitespace();
  127|  22.0k|               break;
  128|  11.3k|            }
  129|  3.20k|            case Object_End: {
  ------------------
  |  Branch (129:13): [True: 3.20k, False: 108k]
  ------------------
  130|  3.20k|               dump<false>('}', b, ix);
  131|  3.20k|               ++it;
  132|  3.20k|               skip_whitespace();
  133|  3.20k|               break;
  134|  11.3k|            }
  135|     10|            case Comment: {
  ------------------
  |  Branch (135:13): [True: 10, False: 111k]
  ------------------
  136|       |               if constexpr (Opts.comments) {
  137|       |                  const auto value = read_jsonc_comment(it, end);
  138|       |                  if (value.size()) [[likely]] {
  139|       |                     dump<false>(value, b, ix);
  140|       |                  }
  141|       |                  skip_whitespace();
  142|       |                  break;
  143|       |               }
  144|     10|               else {
  145|     10|                  [[fallthrough]];
  146|     10|               }
  147|     10|            }
  148|  3.36k|            [[unlikely]] default: {
  ------------------
  |  Branch (148:26): [True: 3.35k, False: 108k]
  ------------------
  149|  3.36k|               ctx.error = error_code::syntax_error;
  150|  3.36k|               return;
  151|     10|            }
  152|   111k|            }
  153|   111k|         }
  154|  3.36k|      }
_ZZN3glz6detail11minify_jsonITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj32EEETkNS_10is_contextERNS_7contextERPKcS7_RNSt3__112basic_stringIcNS8_11char_traitsIcEENS8_9allocatorIcEEEEmEEvOT0_OT1_OT2_OT3_RT4_ENKUlvE0_clEv:
   43|  40.1k|         auto skip_whitespace = [&] {
   44|  40.1k|            if constexpr (Opts.null_terminated) {
   45|   315k|               while (whitespace_table[uint8_t(*it)]) {
  ------------------
  |  Branch (45:23): [True: 275k, False: 40.1k]
  ------------------
   46|   275k|                  ++it;
   47|   275k|               }
   48|       |            }
   49|       |            else {
   50|       |               while ((it < end) && whitespace_table[uint8_t(*it)]) {
   51|       |                  ++it;
   52|       |               }
   53|       |            }
   54|  40.1k|         };
_ZZN3glz6detail11minify_jsonITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj32EEETkNS_10is_contextERNS_7contextERPKcS7_RNSt3__112basic_stringIcNS8_11char_traitsIcEENS8_9allocatorIcEEEEmEEvOT0_OT1_OT2_OT3_RT4_ENKUlvE1_clEv:
   58|   111k|         while ([&]() -> bool {
   59|   111k|            if constexpr (Opts.null_terminated) {
   60|   111k|               return true;
   61|       |            }
   62|       |            else {
   63|       |               return it < end;
   64|       |            }
   65|   111k|         }()) {
_ZZN3glz6detail11minify_jsonITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj32EEETkNS_10is_contextERNS_7contextERPKcS7_RNSt3__112basic_stringIcNS8_11char_traitsIcEENS8_9allocatorIcEEEEmEEvOT0_OT1_OT2_OT3_RT4_ENKUlvE_clEv:
   23|  71.5k|         auto skip_expected_whitespace = [&] {
   24|  71.5k|            auto new_ws_start = it;
   25|  71.5k|            if (ws_size && ws_size < size_t(end - it)) [[likely]] {
  ------------------
  |  Branch (25:17): [True: 47.5k, False: 23.9k]
  |  Branch (25:28): [True: 46.0k, False: 1.47k]
  ------------------
   26|  46.0k|               skip_matching_ws(ws_start, it, ws_size);
   27|  46.0k|            }
   28|       |
   29|  71.5k|            if constexpr (Opts.null_terminated) {
   30|  31.5M|               while (whitespace_table[uint8_t(*it)]) {
  ------------------
  |  Branch (30:23): [True: 31.4M, False: 71.5k]
  ------------------
   31|  31.4M|                  ++it;
   32|  31.4M|               }
   33|       |            }
   34|       |            else {
   35|       |               while ((it < end) && whitespace_table[uint8_t(*it)]) {
   36|       |                  ++it;
   37|       |               }
   38|       |            }
   39|  71.5k|            ws_start = new_ws_start;
   40|  71.5k|            ws_size = size_t(it - new_ws_start);
   41|  71.5k|         };

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

_ZN3glz16dump_maybe_emptyILb0ENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEvNS1_17basic_string_viewIcS4_EERT0_Rm:
  267|  2.17k|   {
  268|  2.17k|      const auto n = str.size();
  269|  2.17k|      if (n) {
  ------------------
  |  Branch (269:11): [True: 2.06k, False: 108]
  ------------------
  270|  2.06k|         if constexpr (vector_like<B>) {
  271|       |            if constexpr (Checked) {
  272|       |               const auto k = ix + n;
  273|       |               if (k > b.size()) [[unlikely]] {
  274|       |                  b.resize(2 * k);
  275|       |               }
  276|       |            }
  277|  2.06k|         }
  278|  2.06k|         std::memcpy(&b[ix], str.data(), n);
  279|  2.06k|         ix += n;
  280|  2.06k|      }
  281|  2.17k|   }
_ZN3glz4dumpILb0ENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEETkNS_10byte_sizedEcEEvT1_RT0_Rm:
   98|  86.8k|   {
   99|       |      if constexpr (Checked && vector_like<B>) {
  100|       |         if (ix == b.size()) [[unlikely]] {
  101|       |            b.resize(b.size() == 0 ? 128 : b.size() * 2);
  102|       |         }
  103|       |      }
  104|  86.8k|      assign_maybe_cast(c, b, ix);
  105|  86.8k|      ++ix;
  106|  86.8k|   }
_ZN3glz17assign_maybe_castITkNS_10byte_sizedEcNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEvT_RT0_Rm:
   55|  86.8k|   {
   56|  86.8k|      using V = std::decay_t<decltype(b[0])>;
   57|  86.8k|      using C = std::decay_t<decltype(c)>;
   58|  86.8k|      if constexpr (std::same_as<V, C>) {
   59|  86.8k|         b[ix] = c;
   60|       |      }
   61|       |      else {
   62|       |         b[ix] = static_cast<V>(c);
   63|       |      }
   64|  86.8k|   }
_ZN3glz4dumpILb0ENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEvNS1_17basic_string_viewIcS4_EERT0_Rm:
  140|  19.2k|   {
  141|  19.2k|      const auto n = str.size();
  142|  19.2k|      if constexpr (vector_like<B>) {
  143|       |         if constexpr (Checked) {
  144|       |            const auto k = ix + n;
  145|       |            if (ix + n > b.size()) [[unlikely]] {
  146|       |               b.resize(2 * k);
  147|       |            }
  148|       |         }
  149|  19.2k|      }
  150|  19.2k|      std::memcpy(&b[ix], str.data(), n);
  151|  19.2k|      ix += n;
  152|  19.2k|   }

_ZN3glz9has_quoteEm:
  534|  1.49M|   {
  535|  1.49M|      return has_zero(chunk ^ repeat_byte8('"'));
  536|  1.49M|   }
_ZN3glz8has_zeroEm:
  529|  1.49M|   {
  530|  1.49M|      return (((chunk - 0x0101010101010101u) & ~chunk) & 0x8080808080808080u);
  531|  1.49M|   }
_ZN3glz16skip_matching_wsIcRPKcEEvPKT_OT0_m:
  689|  46.0k|   {
  690|  46.0k|      if (length > 7) {
  ------------------
  |  Branch (690:11): [True: 17.3k, False: 28.7k]
  ------------------
  691|  17.3k|         uint64_t v[2];
  692|  24.5k|         while (length > 8) {
  ------------------
  |  Branch (692:17): [True: 15.4k, False: 9.13k]
  ------------------
  693|  15.4k|            std::memcpy(v, ws, 8);
  694|  15.4k|            std::memcpy(v + 1, it, 8);
  695|  15.4k|            if (v[0] != v[1]) {
  ------------------
  |  Branch (695:17): [True: 8.16k, False: 7.26k]
  ------------------
  696|  8.16k|               return;
  697|  8.16k|            }
  698|  7.26k|            length -= 8;
  699|  7.26k|            ws += 8;
  700|  7.26k|            it += 8;
  701|  7.26k|         }
  702|       |
  703|  9.13k|         const auto shift = 8 - length;
  704|  9.13k|         ws -= shift;
  705|  9.13k|         it -= shift;
  706|       |
  707|  9.13k|         std::memcpy(v, ws, 8);
  708|  9.13k|         std::memcpy(v + 1, it, 8);
  709|  9.13k|         if (v[0] != v[1]) {
  ------------------
  |  Branch (709:14): [True: 5.40k, False: 3.72k]
  ------------------
  710|  5.40k|            return;
  711|  5.40k|         }
  712|  3.72k|         it += 8;
  713|  3.72k|         return;
  714|  9.13k|      }
  715|  28.7k|      {
  716|  28.7k|         constexpr uint64_t n{sizeof(uint32_t)};
  717|  28.7k|         if (length >= n) {
  ------------------
  |  Branch (717:14): [True: 9.73k, False: 19.0k]
  ------------------
  718|  9.73k|            uint32_t v[2];
  719|  9.73k|            std::memcpy(v, ws, n);
  720|  9.73k|            std::memcpy(v + 1, it, n);
  721|  9.73k|            if (v[0] != v[1]) {
  ------------------
  |  Branch (721:17): [True: 5.84k, False: 3.89k]
  ------------------
  722|  5.84k|               return;
  723|  5.84k|            }
  724|  3.89k|            length -= n;
  725|  3.89k|            ws += n;
  726|  3.89k|            it += n;
  727|  3.89k|         }
  728|  28.7k|      }
  729|  22.9k|      {
  730|  22.9k|         constexpr uint64_t n{sizeof(uint16_t)};
  731|  22.9k|         if (length >= n) {
  ------------------
  |  Branch (731:14): [True: 13.3k, False: 9.63k]
  ------------------
  732|  13.3k|            uint16_t v[2];
  733|  13.3k|            std::memcpy(v, ws, n);
  734|  13.3k|            std::memcpy(v + 1, it, n);
  735|  13.3k|            if (v[0] != v[1]) {
  ------------------
  |  Branch (735:17): [True: 7.71k, False: 5.60k]
  ------------------
  736|  7.71k|               return;
  737|  7.71k|            }
  738|       |            // length -= n;
  739|       |            // ws += n;
  740|  5.60k|            it += n;
  741|  5.60k|         }
  742|  22.9k|      }
  743|       |      // We have to call a whitespace check after this function
  744|       |      // in case the whitespace is mismatching.
  745|       |      // So, we forgo this check as to not duplicate.
  746|       |      /*if (length && *ws == *it) {
  747|       |         ++it;
  748|       |      }*/
  749|  22.9k|   }