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

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

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

_ZN3glz11minify_jsonITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEETkNS_9resizableENSt3__16vectorIcNS2_9allocatorIcEEEEEENS2_12basic_stringIcNS2_11char_traitsIcEES5_EERT0_:
  202|  3.33k|   {
  203|  3.33k|      context ctx{};
  204|  3.33k|      std::string out{};
  205|  3.33k|      detail::minify_json<Opts>(ctx, in, out);
  206|  3.33k|      return out;
  207|  3.33k|   }
_ZN3glz6detail11minify_jsonITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERNSt3__16vectorIcNS3_9allocatorIcEEEETkNS_13output_bufferERNS3_12basic_stringIcNS3_11char_traitsIcEES6_EETkNS_10is_contextERNS_7contextEQaa10contiguousIT0_E9resizableISG_EEEvOT2_OSG_OT1_:
  159|  3.33k|      {
  160|  3.33k|         if (in.empty()) {
  ------------------
  |  Branch (160:14): [True: 0, False: 3.33k]
  ------------------
  161|      0|            return;
  162|      0|         }
  163|  3.33k|         in.resize(in.size() + padding_bytes);
  164|       |
  165|  3.33k|         if constexpr (resizable<Out>) {
  166|  3.33k|            out.resize(in.size() + padding_bytes);
  167|  3.33k|         }
  168|  3.33k|         size_t ix = 0;
  169|  3.33k|         auto [it, end] = read_iterators<Opts, true>(in);
  170|  3.33k|         if (bool(ctx.error)) [[unlikely]] {
  ------------------
  |  Branch (170:14): [True: 0, False: 3.33k]
  ------------------
  171|      0|            return;
  172|      0|         }
  173|       |
  174|  3.33k|         static constexpr auto O = is_padded_on<Opts>();
  175|  3.33k|         if constexpr (string_t<In>) {
  176|  3.33k|            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.33k|         if constexpr (resizable<Out>) {
  183|  3.33k|            out.resize(ix);
  184|  3.33k|         }
  185|  3.33k|         in.resize(in.size() - padding_bytes);
  186|  3.33k|      }
_ZN3glz6detail11minify_jsonITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj32EEETkNS_10is_contextERNS_7contextERPKcS7_RNSt3__112basic_stringIcNS8_11char_traitsIcEENS8_9allocatorIcEEEEmEEvOT0_OT1_OT2_OT3_RT4_:
   17|  3.33k|      {
   18|  3.33k|         using enum json_type;
   19|       |
   20|  3.33k|         auto ws_start = it;
   21|  3.33k|         uint64_t ws_size{};
   22|       |
   23|  3.33k|         auto skip_expected_whitespace = [&] {
   24|  3.33k|            auto new_ws_start = it;
   25|  3.33k|            if (ws_size && ws_size < size_t(end - it)) [[likely]] {
   26|  3.33k|               skip_matching_ws(ws_start, it, ws_size);
   27|  3.33k|            }
   28|       |
   29|  3.33k|            if constexpr (Opts.null_terminated) {
   30|  3.33k|               while (whitespace_table[uint8_t(*it)]) {
   31|  3.33k|                  ++it;
   32|  3.33k|               }
   33|  3.33k|            }
   34|  3.33k|            else {
   35|  3.33k|               while ((it < end) && whitespace_table[uint8_t(*it)]) {
   36|  3.33k|                  ++it;
   37|  3.33k|               }
   38|  3.33k|            }
   39|  3.33k|            ws_start = new_ws_start;
   40|  3.33k|            ws_size = size_t(it - new_ws_start);
   41|  3.33k|         };
   42|       |
   43|  3.33k|         auto skip_whitespace = [&] {
   44|  3.33k|            if constexpr (Opts.null_terminated) {
   45|  3.33k|               while (whitespace_table[uint8_t(*it)]) {
   46|  3.33k|                  ++it;
   47|  3.33k|               }
   48|  3.33k|            }
   49|  3.33k|            else {
   50|  3.33k|               while ((it < end) && whitespace_table[uint8_t(*it)]) {
   51|  3.33k|                  ++it;
   52|  3.33k|               }
   53|  3.33k|            }
   54|  3.33k|         };
   55|       |
   56|  3.33k|         skip_whitespace();
   57|       |
   58|   113k|         while ([&]() -> bool {
  ------------------
  |  Branch (58:17): [True: 113k, Folded]
  ------------------
   59|   113k|            if constexpr (Opts.null_terminated) {
   60|   113k|               return true;
   61|   113k|            }
   62|   113k|            else {
   63|   113k|               return it < end;
   64|   113k|            }
   65|   113k|         }()) {
   66|   113k|            switch (json_types[uint8_t(*it)]) {
   67|  2.06k|            case String: {
  ------------------
  |  Branch (67:13): [True: 2.06k, False: 111k]
  ------------------
   68|  2.06k|               const auto value = read_json_string<Opts>(it, end);
   69|  2.06k|               dump_maybe_empty<false>(value, b, ix);
   70|  2.06k|               skip_whitespace();
   71|  2.06k|               break;
   72|      0|            }
   73|  35.7k|            case Comma: {
  ------------------
  |  Branch (73:13): [True: 35.7k, False: 77.6k]
  ------------------
   74|  35.7k|               dump<false>(',', b, ix);
   75|  35.7k|               ++it;
   76|  35.7k|               skip_expected_whitespace();
   77|  35.7k|               break;
   78|      0|            }
   79|  7.17k|            case Number: {
  ------------------
  |  Branch (79:13): [True: 7.17k, False: 106k]
  ------------------
   80|  7.17k|               const auto value = read_json_number<Opts.null_terminated>(it, end);
   81|  7.17k|               dump<false>(value, b, ix); // we couldn't have gotten here without one valid character
   82|  7.17k|               skip_whitespace();
   83|  7.17k|               break;
   84|      0|            }
   85|  5.55k|            case Colon: {
  ------------------
  |  Branch (85:13): [True: 5.55k, False: 107k]
  ------------------
   86|  5.55k|               dump<false>(':', b, ix);
   87|  5.55k|               ++it;
   88|  5.55k|               skip_whitespace();
   89|  5.55k|               break;
   90|      0|            }
   91|  16.6k|            case Array_Start: {
  ------------------
  |  Branch (91:13): [True: 16.6k, False: 96.7k]
  ------------------
   92|  16.6k|               dump<false>('[', b, ix);
   93|  16.6k|               ++it;
   94|  16.6k|               skip_expected_whitespace();
   95|  16.6k|               break;
   96|      0|            }
   97|  5.71k|            case Array_End: {
  ------------------
  |  Branch (97:13): [True: 5.71k, False: 107k]
  ------------------
   98|  5.71k|               dump<false>(']', b, ix);
   99|  5.71k|               ++it;
  100|  5.71k|               skip_whitespace();
  101|  5.71k|               break;
  102|      0|            }
  103|  1.09k|            case Null: {
  ------------------
  |  Branch (103:13): [True: 1.09k, False: 112k]
  ------------------
  104|  1.09k|               dump<false>("null", b, ix);
  105|  1.09k|               it += 4;
  106|  1.09k|               skip_whitespace();
  107|  1.09k|               break;
  108|      0|            }
  109|  10.1k|            case Bool: {
  ------------------
  |  Branch (109:13): [True: 10.1k, False: 103k]
  ------------------
  110|  10.1k|               if (*it == 't') {
  ------------------
  |  Branch (110:20): [True: 8.10k, False: 2.01k]
  ------------------
  111|  8.10k|                  dump<false>("true", b, ix);
  112|  8.10k|                  it += 4;
  113|  8.10k|                  skip_whitespace();
  114|  8.10k|                  break;
  115|  8.10k|               }
  116|  2.01k|               else {
  117|  2.01k|                  dump<false>("false", b, ix);
  118|  2.01k|                  it += 5;
  119|  2.01k|                  skip_whitespace();
  120|  2.01k|                  break;
  121|  2.01k|               }
  122|  10.1k|            }
  123|  22.6k|            case Object_Start: {
  ------------------
  |  Branch (123:13): [True: 22.6k, False: 90.7k]
  ------------------
  124|  22.6k|               dump<false>('{', b, ix);
  125|  22.6k|               ++it;
  126|  22.6k|               skip_expected_whitespace();
  127|  22.6k|               break;
  128|  10.1k|            }
  129|  3.26k|            case Object_End: {
  ------------------
  |  Branch (129:13): [True: 3.26k, False: 110k]
  ------------------
  130|  3.26k|               dump<false>('}', b, ix);
  131|  3.26k|               ++it;
  132|  3.26k|               skip_whitespace();
  133|  3.26k|               break;
  134|  10.1k|            }
  135|      6|            case Comment: {
  ------------------
  |  Branch (135:13): [True: 6, False: 113k]
  ------------------
  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|      6|               else {
  145|      6|                  [[fallthrough]];
  146|      6|               }
  147|      6|            }
  148|  3.33k|            [[unlikely]] default: {
  ------------------
  |  Branch (148:26): [True: 3.33k, False: 110k]
  ------------------
  149|  3.33k|               ctx.error = error_code::syntax_error;
  150|  3.33k|               return;
  151|      6|            }
  152|   113k|            }
  153|   113k|         }
  154|  3.33k|      }
_ZZN3glz6detail11minify_jsonITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj32EEETkNS_10is_contextERNS_7contextERPKcS7_RNSt3__112basic_stringIcNS8_11char_traitsIcEENS8_9allocatorIcEEEEmEEvOT0_OT1_OT2_OT3_RT4_ENKUlvE0_clEv:
   43|  38.3k|         auto skip_whitespace = [&] {
   44|  38.3k|            if constexpr (Opts.null_terminated) {
   45|   353k|               while (whitespace_table[uint8_t(*it)]) {
  ------------------
  |  Branch (45:23): [True: 315k, False: 38.3k]
  ------------------
   46|   315k|                  ++it;
   47|   315k|               }
   48|       |            }
   49|       |            else {
   50|       |               while ((it < end) && whitespace_table[uint8_t(*it)]) {
   51|       |                  ++it;
   52|       |               }
   53|       |            }
   54|  38.3k|         };
_ZZN3glz6detail11minify_jsonITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj32EEETkNS_10is_contextERNS_7contextERPKcS7_RNSt3__112basic_stringIcNS8_11char_traitsIcEENS8_9allocatorIcEEEEmEEvOT0_OT1_OT2_OT3_RT4_ENKUlvE1_clEv:
   58|   113k|         while ([&]() -> bool {
   59|   113k|            if constexpr (Opts.null_terminated) {
   60|   113k|               return true;
   61|       |            }
   62|       |            else {
   63|       |               return it < end;
   64|       |            }
   65|   113k|         }()) {
_ZZN3glz6detail11minify_jsonITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj32EEETkNS_10is_contextERNS_7contextERPKcS7_RNSt3__112basic_stringIcNS8_11char_traitsIcEENS8_9allocatorIcEEEEmEEvOT0_OT1_OT2_OT3_RT4_ENKUlvE_clEv:
   23|  75.0k|         auto skip_expected_whitespace = [&] {
   24|  75.0k|            auto new_ws_start = it;
   25|  75.0k|            if (ws_size && ws_size < size_t(end - it)) [[likely]] {
  ------------------
  |  Branch (25:17): [True: 48.1k, False: 26.9k]
  |  Branch (25:28): [True: 46.6k, False: 1.47k]
  ------------------
   26|  46.6k|               skip_matching_ws(ws_start, it, ws_size);
   27|  46.6k|            }
   28|       |
   29|  75.0k|            if constexpr (Opts.null_terminated) {
   30|  34.5M|               while (whitespace_table[uint8_t(*it)]) {
  ------------------
  |  Branch (30:23): [True: 34.4M, False: 75.0k]
  ------------------
   31|  34.4M|                  ++it;
   32|  34.4M|               }
   33|       |            }
   34|       |            else {
   35|       |               while ((it < end) && whitespace_table[uint8_t(*it)]) {
   36|       |                  ++it;
   37|       |               }
   38|       |            }
   39|  75.0k|            ws_start = new_ws_start;
   40|  75.0k|            ws_size = size_t(it - new_ws_start);
   41|  75.0k|         };

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

_ZN3glz16dump_maybe_emptyILb0ENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEvNS1_17basic_string_viewIcS4_EERT0_Rm:
  251|  2.06k|   {
  252|  2.06k|      const auto n = str.size();
  253|  2.06k|      if (n) {
  ------------------
  |  Branch (253:11): [True: 1.99k, False: 72]
  ------------------
  254|  1.99k|         if constexpr (vector_like<B>) {
  255|       |            if constexpr (Checked) {
  256|       |               const auto k = ix + n;
  257|       |               if (k > b.size()) [[unlikely]] {
  258|       |                  b.resize(2 * k);
  259|       |               }
  260|       |            }
  261|  1.99k|         }
  262|  1.99k|         std::memcpy(&b[ix], str.data(), n);
  263|  1.99k|         ix += n;
  264|  1.99k|      }
  265|  2.06k|   }
_ZN3glz4dumpILb0ENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEETkNS_10byte_sizedEcEEvT1_RT0_Rm:
   82|  89.6k|   {
   83|       |      if constexpr (Checked && vector_like<B>) {
   84|       |         if (ix == b.size()) [[unlikely]] {
   85|       |            b.resize(b.size() == 0 ? 128 : b.size() * 2);
   86|       |         }
   87|       |      }
   88|  89.6k|      assign_maybe_cast(c, b, ix);
   89|  89.6k|      ++ix;
   90|  89.6k|   }
_ZN3glz17assign_maybe_castITkNS_10byte_sizedEcNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEvT_RT0_Rm:
   55|  89.6k|   {
   56|  89.6k|      using V = std::decay_t<decltype(b[0])>;
   57|  89.6k|      using C = std::decay_t<decltype(c)>;
   58|  89.6k|      if constexpr (std::same_as<V, C>) {
   59|  89.6k|         b[ix] = c;
   60|       |      }
   61|       |      else {
   62|       |         b[ix] = static_cast<V>(c);
   63|       |      }
   64|  89.6k|   }
_ZN3glz4dumpILb0ENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEvNS1_17basic_string_viewIcS4_EERT0_Rm:
  124|  18.3k|   {
  125|  18.3k|      const auto n = str.size();
  126|  18.3k|      if constexpr (vector_like<B>) {
  127|       |         if constexpr (Checked) {
  128|       |            const auto k = ix + n;
  129|       |            if (ix + n > b.size()) [[unlikely]] {
  130|       |               b.resize(2 * k);
  131|       |            }
  132|       |         }
  133|  18.3k|      }
  134|  18.3k|      std::memcpy(&b[ix], str.data(), n);
  135|  18.3k|      ix += n;
  136|  18.3k|   }

_ZN3glz9has_quoteEm:
  534|  1.12M|   {
  535|  1.12M|      return has_zero(chunk ^ repeat_byte8('"'));
  536|  1.12M|   }
_ZN3glz8has_zeroEm:
  529|  1.12M|   {
  530|  1.12M|      return (((chunk - 0x0101010101010101u) & ~chunk) & 0x8080808080808080u);
  531|  1.12M|   }
_ZN3glz16skip_matching_wsIcRPKcEEvPKT_OT0_m:
  689|  46.6k|   {
  690|  46.6k|      if (length > 7) {
  ------------------
  |  Branch (690:11): [True: 17.3k, False: 29.2k]
  ------------------
  691|  17.3k|         uint64_t v[2];
  692|  26.0k|         while (length > 8) {
  ------------------
  |  Branch (692:17): [True: 16.5k, False: 9.49k]
  ------------------
  693|  16.5k|            std::memcpy(v, ws, 8);
  694|  16.5k|            std::memcpy(v + 1, it, 8);
  695|  16.5k|            if (v[0] != v[1]) {
  ------------------
  |  Branch (695:17): [True: 7.87k, False: 8.70k]
  ------------------
  696|  7.87k|               return;
  697|  7.87k|            }
  698|  8.70k|            length -= 8;
  699|  8.70k|            ws += 8;
  700|  8.70k|            it += 8;
  701|  8.70k|         }
  702|       |
  703|  9.49k|         const auto shift = 8 - length;
  704|  9.49k|         ws -= shift;
  705|  9.49k|         it -= shift;
  706|       |
  707|  9.49k|         std::memcpy(v, ws, 8);
  708|  9.49k|         std::memcpy(v + 1, it, 8);
  709|  9.49k|         if (v[0] != v[1]) {
  ------------------
  |  Branch (709:14): [True: 5.44k, False: 4.05k]
  ------------------
  710|  5.44k|            return;
  711|  5.44k|         }
  712|  4.05k|         it += 8;
  713|  4.05k|         return;
  714|  9.49k|      }
  715|  29.2k|      {
  716|  29.2k|         constexpr uint64_t n{sizeof(uint32_t)};
  717|  29.2k|         if (length >= n) {
  ------------------
  |  Branch (717:14): [True: 10.2k, False: 19.0k]
  ------------------
  718|  10.2k|            uint32_t v[2];
  719|  10.2k|            std::memcpy(v, ws, n);
  720|  10.2k|            std::memcpy(v + 1, it, n);
  721|  10.2k|            if (v[0] != v[1]) {
  ------------------
  |  Branch (721:17): [True: 6.08k, False: 4.11k]
  ------------------
  722|  6.08k|               return;
  723|  6.08k|            }
  724|  4.11k|            length -= n;
  725|  4.11k|            ws += n;
  726|  4.11k|            it += n;
  727|  4.11k|         }
  728|  29.2k|      }
  729|  23.1k|      {
  730|  23.1k|         constexpr uint64_t n{sizeof(uint16_t)};
  731|  23.1k|         if (length >= n) {
  ------------------
  |  Branch (731:14): [True: 13.4k, False: 9.78k]
  ------------------
  732|  13.4k|            uint16_t v[2];
  733|  13.4k|            std::memcpy(v, ws, n);
  734|  13.4k|            std::memcpy(v + 1, it, n);
  735|  13.4k|            if (v[0] != v[1]) {
  ------------------
  |  Branch (735:17): [True: 7.62k, False: 5.79k]
  ------------------
  736|  7.62k|               return;
  737|  7.62k|            }
  738|       |            // length -= n;
  739|       |            // ws += n;
  740|  5.79k|            it += n;
  741|  5.79k|         }
  742|  23.1k|      }
  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|  23.1k|   }